CHS-J1 Exam Domains 2026: Complete Guide to All 5 Content Areas

The CodeHS Java Level 1 Exam at a Glance

The CodeHS Java Level 1 Certification Exam is a CodeHS-issued credential that checks whether you can read, trace, and reason about core Java code. It is delivered as an online timed exam of 45 multiple-choice questions. According to the CodeHS Certifications FAQ, the exam is timed at 90 minutes, which works out to an average of two minutes per question. The passing score for Java is 50%.

There are no prerequisites. Anyone can sit the exam, although CodeHS recommends its AP CSA course as preparation. If you want the full eligibility picture, see our breakdown of CHS-J1 requirements, prerequisites, and how to qualify.

This guide walks through each of the five content areas CodeHS names in its official overview, explains what each one is really asking you to do, and shows how to sequence your preparation. If you are looking for a broader plan, pair it with the CHS-J1 study guide for passing on your first attempt.

How CodeHS Organizes the Five Content Areas

The official overview groups the exam into five headings. Here is the full map in one place:

Notice the verbs. CodeHS uses words like evaluate, understand, recognize, and analyze repeatedly. In a multiple-choice format, that points to questions where you read a snippet and predict behavior rather than write code from scratch. Your practice should mirror that: trace code by hand, predict output, and spot why a snippet fails or what a variable holds at a given line.

Domain 1: Java Fundamentals

Input and Output with Standard Packages

CodeHS specifically names Scanner. Expect to recognize how a program imports a standard package, creates a Scanner object, reads values, and prints results. A multiple-choice question might show a short program and ask what it prints given certain input, or which line is needed for the code to compile and run.

Details worth drilling:

• The difference between System.out.print and System.out.println, and how that changes the output you would see line by line.
• How Scanner methods for different types (reading an integer versus a full line of text) behave, including the classic leftover-newline surprise when you mix them.
• Why an import statement matters for classes that live outside the default package.
• How string concatenation and escape sequences affect printed output.

Evaluating Variable Scope

Scope questions ask where a variable exists and where using it will cause an error. Candidates commonly miss these because they skim. The pattern to internalize:

• A variable declared inside a loop or block is not visible after the closing brace.
• A loop variable declared in a for header disappears when the loop ends.
• Local variables in a method are invisible to other methods.
• Instance variables belong to an object; a local variable with the same name can shadow one.

When you see a scope question, mentally draw boxes around each pair of braces and ask which box each variable lives in.

Domain 2: Working with Data Types, Variables, and Expressions

This is the broadest domain by topic count. CodeHS lists five distinct subtopics here, and each one can generate several different question styles. Expect a substantial share of your 45 questions to touch this material, even though CodeHS does not publish an exact figure.

Primitives, Casting, and Arithmetic

Java's arithmetic rules are a frequent source of trick questions. Be ready for:

• Integer division: dividing two ints discards the fractional part, so the result may not be what a calculator shows.
• The modulus operator: remainders, evenness checks, and wrap-around logic.
• Casting: converting a double to an int truncates rather than rounds, and where you place the cast in an expression changes the result.
• Operator precedence: multiplication and division before addition and subtraction, with parentheses overriding.
• Compound assignment and increment/decrement: how += and ++ change a variable.

Strings and String Methods, Including Parsing

Strings are objects in Java, which creates distinctive pitfalls. Know the common methods well enough to evaluate them by hand: finding length, extracting substrings by index, locating a character or fragment, and comparing strings. Remember that comparing string contents requires the equals method rather than the == operator, and that strings are immutable, so a method that appears to change a string actually returns a new one.

CodeHS also names parsing. That means converting text into numeric values, such as turning the string "42" into an int, and being able to tell when such a conversion is appropriate. Pay attention to the relationship between text and numbers, since adding two strings that look like numbers concatenates rather than sums them.

Arrays and ArrayLists

Arrays and ArrayLists are listed separately, so expect questions on both and on the differences between them. Arrays have a fixed size set at creation and use bracket notation and a length field. ArrayLists resize dynamically and use method calls such as adding, getting, setting, removing, and checking size.

• Off-by-one errors are the dominant trap: valid array indexes run from 0 to length minus one.
• Know the default values of newly created arrays (zeros for numeric types, false for booleans, null for objects).
• When an element is removed from an ArrayList, later elements shift, which can change what a loop sees.
• Traversal questions often ask what an array contains after a loop modifies it.

2D Arrays

Two-dimensional arrays are traversed with nested loops. The key habit is distinguishing rows from columns: the first index selects the row, the second selects the column, and the number of columns is the length of a row. Practice tracing a nested loop on a small grid, writing out values in the order they are visited, then summing a row, a column, or a diagonal.

Domain 3: Implement Flow Control

Boolean Expressions and Logic

CodeHS asks you to understand and evaluate logic expressions. In practice that means being fluent with relational operators, the logical operators AND, OR, and NOT, and compound conditions in if and else if chains. Skills that pay off:

• Evaluating a compound condition by substituting actual values and simplifying step by step.
• Applying De Morgan's laws to recognize that a negated compound condition can be rewritten in an equivalent form.
• Understanding short-circuit evaluation: in an AND, if the left side is false the right side is never evaluated, which matters when the right side could cause an error.
• Knowing that in an if/else if/else chain only the first true branch runs.

Loops: for, for-each, and while

Loop questions test whether you can count iterations and predict final values. Be comfortable with all three forms CodeHS names:

• for loops: initialization, condition, and update; know exactly when each executes and what value the loop variable holds on exit.
• for-each loops: traverse every element of an array or ArrayList without an index; recognize that you cannot use them to assign new values to primitive array elements through the loop variable.
• while loops: condition checked before each pass; watch for loops that never execute or never terminate.

A reliable technique is the trace table: columns for each variable, one row per iteration. It is slow in practice sessions but builds the accuracy you need when two answer choices differ by a single iteration.

Domain 4: Perform Object-Oriented Programming

This domain needs the most careful reading of the scope, because CodeHS draws an explicit boundary around it. The official topics are creating and using objects, writing classes (including methods, instance variables, and static methods), and recognizing class hierarchies and inheritance. The exam excludes implementing inheritance, polymorphism, abstract classes, and interfaces.

Creating and Using Objects

Know how to instantiate an object with new, how a constructor initializes it, and how to call methods on it. A common question style gives you a short class definition and a few lines of client code, then asks what is printed or which call is valid. Remember that variables holding objects store references, so two variables can point to the same object and a change through one is visible through the other.

Writing Classes

Writing classes covers three building blocks CodeHS names directly:

• Instance variables: data each object owns, typically declared private.
• Methods: behavior, including accessors that return values and mutators that change state; pay attention to return types and parameters.
• Static methods: methods that belong to the class rather than to any object, called on the class name and unable to use instance variables directly.

Tracing questions in this area often involve calling a mutator several times and then asking for the state of an object, or distinguishing a static call from an instance call.

Recognizing Hierarchies Without Implementing Them

The wording matters: you need to recognize class hierarchies and inheritance, not build them. That means being able to read a snippet in which one class extends another and understand the relationship at a conceptual level. Because implementing inheritance, polymorphism, abstract classes, and interfaces is outside the stated scope, do not burn study hours on writing those constructs. Spend that time on the writing-classes and object-usage skills that are explicitly in scope.

Domain 5: Recursion

The recursion domain is explicitly about analysis. You are not expected to invent clever recursive algorithms; you are expected to read a recursive method and determine what it returns, how many times it runs, and why it stops.

Base Cases

Every recursive method needs a base case that ends the chain of calls. Practice identifying it first. If you cannot find a condition under which the method stops calling itself, the method will recurse until it fails, and that is itself a testable observation.

Execution Counts

CodeHS names execution counts specifically. A question might ask how many times a method is called, or how many times a print statement runs, for a given input. The reliable approach is to draw the call tree: write the initial call, branch to each recursive call it makes, and keep going until every branch hits a base case. Then count the nodes. For methods that make a single recursive call, the count is usually linear in the input; for methods that make two, the tree fans out and counts grow quickly.

Also watch the order of operations. Whether a print statement comes before or after the recursive call changes whether output appears on the way down or on the way back up.

Scheduling Your Prep Around the Five Domains

Because the domains build on one another, sequence matters more than total hours. Fundamentals and data structures feed loops, loops feed object-oriented tracing, and recursion rewards everything before it. Here is one way to order the work across a five-week window; adjust to your own timeline.

This ordering puts recursion last on purpose: you need confident loop and method-call tracing before call trees make sense. Use the CHS-J1 practice test to run timed sets and tag each miss by domain so Week 5 targets real gaps.

Scoring, Vouchers, and Credential Logistics

Knowing the content is half the job; the rest is understanding how the exam is administered. From the official CodeHS sources:

• Format: 45 multiple-choice questions, online and timed, with a 90-minute limit.
• Passing score: 50% for Java, per the CodeHS Certifications FAQ. See CHS-J1 passing score explained for how to think about that threshold.
• Vouchers: a new voucher is required for each exam attempt, so a retake means obtaining another voucher.
• Credential lifespan: CodeHS states certification credentials expire after 10 years.
• Prerequisites: none; CodeHS recommends its AP CSA course for preparation.

CodeHS does not publish fee amounts or pass rates in the sources we rely on, so we do not quote any. For what is known about costs and how to budget for them, read our CHS-J1 certification cost breakdown, and for a realistic sense of effort see how hard the CHS-J1 exam is.

Pacing the 90 Minutes

With 45 questions in 90 minutes you have roughly two minutes each, but the questions are not equal. Quick wins such as scope checks, simple boolean evaluations, and single-method string questions can take under a minute. Nested-loop tracing, 2D array traversals, and recursion call trees deserve more time. A sensible approach is to answer the fast questions first, mark the long traces, and return to them with the time you saved.

Frequently Asked Questions