One question at a time. Build your Oracle Java Foundations understanding.
First 50 of 200 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.
Continue in the practice tool above to load more questions, 50 at a time.
char is the 16-bit primitive type that holds one Unicode character, written with single quotes such as 'A'. byte and short are 8-bit and 16-bit integer types that hold numeric values, and String is a reference type rather than a primitive.
The JVM looks for a method that is public, static, returns void, is named main, and accepts a single String[] parameter, because it is invoked without creating an instance of the class. Any deviation from that signature means the class has no launchable entry point.
An identifier must begin with a letter, an underscore, or a dollar sign, and may not contain punctuation such as a hyphen or be a reserved keyword. Digits are allowed only after the first character.
For arrays, the element count is exposed through the final field length, accessed without parentheses. Method-style accessors belong to other types: size() is used by collections and length() by String.
The conditional operator evaluates the boolean expression first and returns the second operand when it is true, otherwise the third. Since 5 > 3 is true, y receives 10 and the value 20 is never used.
The + operator is evaluated left to right, and once the left operand is a String the operator performs concatenation rather than addition. The first step yields "Total: 2", and appending 3 gives "Total: 23".
A final variable may be assigned exactly once, after which any further assignment is a compile-time error. The restriction is enforced by the compiler, so the program never runs.
Division of two ints performs integer division, discarding the fractional part, so 7 / 2 is 3. The remainder operator gives 7 % 2 = 1, and the values are joined by string concatenation.
A narrowing cast from double to int discards the fractional part, truncating toward zero. It does not round, and the cast is legal when written explicitly.
For reference types, == compares whether two variables refer to the same object, not whether the contents match. Two separate new String calls create two distinct objects, so the comparison is false.
A do-while loop executes its body before testing the condition for the first time. The body runs once printing 10, and the condition 11 < 5 then ends the loop.
Execution jumps to the matching case label and then continues into subsequent cases until a break or the end of the switch is reached. Matching case 2 prints B and falls through to case 3, which prints C before breaking.
continue abandons the rest of the current iteration and moves on to the update and next condition check; it does not end the loop. Only the iteration where i equals 2 skips its print, so 1, 3, and 4 are printed.
A local variable declared inside a block exists only within that block. Once the closing brace is reached, the name is out of scope, so the later reference cannot be resolved by the compiler.
StringBuilder is mutable, so append modifies the same object's character sequence and returns that object. Printing it therefore shows the combined content abc.
The two-argument substring takes characters from the begin index up to but not including the end index. Indices 4, 5, 6, and 7 of the string are P, r, o, and g.
A char is an unsigned 16-bit numeric value, so 'A' corresponds to 65 and adding 2 gives 67, which is 'C'. Compound assignment such as += applies an implicit narrowing cast back to char.
The postfix i++ yields the old value 5 and then increments i to 6. The prefix ++i increments first to 7 and yields 7, so j is 5 + 7 = 12 and i ends at 7.
The && operator short-circuits: when the left operand is false, the right operand is never evaluated. Because s != null is false, s.length() is never called, so the else branch prints no.
int arithmetic silently wraps around on overflow, following two's-complement representation. Adding 1 to the largest int produces the smallest int value, -2147483648.
A labeled break terminates the loop named by the label, not merely the innermost loop. The first time j reaches 1 the outer loop is abandoned, so only the single iteration printing 00 completes.
Autoboxing of values in the range -128 to 127 reuses cached Integer instances, so a and b refer to the same object. Values outside that range create separate objects, so c == d compares distinct references and is false.
Fields (instance and static) are automatically initialized to their type's default value, and the default for boolean is false. Only local variables lack default values and must be assigned before use.
char is the only primitive type designated for a single 16-bit Unicode code unit. byte is an 8-bit signed integer and short is a 16-bit signed integer, both used for arithmetic values rather than characters.
Underscores may appear between digits in a numeric literal but not adjacent to a prefix or suffix. A floating-point literal also cannot carry the L suffix, which is reserved for integral long literals.
double is a 64-bit IEEE 754 floating-point type, which is 8 bytes. float is the 32-bit (4-byte) floating-point type, and char/short are 16-bit (2-byte) types.
When both operands of / are integers, Java performs integer division and discards the fractional part, so 7 / 2 yields 3. The result is also of type int, so no decimal point appears.
Java has eight primitive types, including int, which store values directly. String, Integer and arrays are all reference types whose variables hold references to objects.
Assigning an int value to a long is a widening conversion, which the compiler performs automatically. The other options either narrow the value or use a constant outside the target type's range.
Binary numeric promotion converts byte operands to int, so b + 1 is an int and cannot be assigned back to a byte without a cast. The initializer 10 is fine because it is a constant that fits in byte.
Compound assignment operators such as += include an implicit cast back to the type of the left-hand operand, so b += 5 is legal for a byte. A plain assignment of an int expression to a byte is rejected.
A literal with a decimal point is a double unless it carries the f suffix, so only the version with f can initialize a float directly. The d suffix explicitly makes the literal a double, which narrows to float.
The + operator applied to two char operands performs binary numeric promotion to int, so it adds the code values 97 and 98. The resulting int 195 is printed numerically rather than as characters.
Only fields receive default values; local variables have no default and must be definitely assigned before use. The compiler therefore rejects any read of an uninitialized local variable.
String objects are immutable, so concat returns a new String instead of modifying the original. Because the returned reference is discarded, the variable s still refers to "Java".
The operands of / are both int, so integer division is performed first and produces 2. That int result is then widened to double for the assignment, giving 2.0.
var is local-variable type inference: the compiler derives a static type from the initializer, so an initializer is mandatory in the same declaration. It cannot be used for fields, method parameters, or return types.
Converting a double to an integral type is a narrowing conversion and must be explicit. The cast truncates the fractional part, so c receives the value 9.
StringBuilder is mutable, so append modifies the same object and returns it for chaining. Printing sb therefore shows the accumulated text "Java SE".
An integral literal without a suffix has type int, and 2147483648 exceeds Integer.MAX_VALUE. Adding the L suffix, as in 2147483648L, would make it a valid long literal.
== on two reference variables compares references, and autoboxing caches only values from -128 to 127. Both 1000 values therefore become distinct Integer objects, so the comparison is false and equals must be used for value comparison.
A narrowing cast to byte keeps only the low 8 bits, and the result is interpreted as a signed two's-complement value. The bit pattern of 130 becomes 10000010, which is -126.
Both operands of + are int, so the addition is performed in 32-bit int arithmetic and wraps around before the assignment. The overflowed int is then widened to long, preserving the negative value.
0x10 is hexadecimal 16, 010 is octal 8, and 0b10 is binary 2. Adding them with ordinary int arithmetic gives 26.
Both operands of the division are int values, so Java performs integer division and discards the fractional part. The exact quotient 3.5 is truncated toward zero, so 3 is stored.
The remainder operator returns what is left over after integer division: 17 divided by 5 is 3 with a remainder of 2. Because both operands are int, the result is also an int.
Multiplication has higher precedence than addition, so 3 * 4 is evaluated first and its result is then added to 2. Parentheses would be required to force the addition to happen first.
The postfix form x++ produces the current value of x and only then increments x. As a result y receives 5 while x becomes 6.
The conditional operator tests its boolean condition and yields the second operand when the condition is true. Since 4 % 2 equals 0, the first value is selected.
A switch selector may be one of the integral types char, byte, short or int, an enum constant, or a String. Floating-point and boolean values are not permitted.