The b variable is declared in the first statement without being initialized. This variable may then be set to 1 in the try block. However, if the expression a > c evaluates to true, this variable will never be initialized. This potential uninitialized state leads to a compile-time error.
Notice the compiler doesn’t execute any expression at compilation time. This means even when the expression a > c evaluates to false, we still see an error because the compiler doesn’t know about such an expression result.

The condition expression of the do statement is a constant expression with the value of true. This means the body of the do block would get executed forever, making the following statements unreachable. This unreachable state prevents the code from being compiled.
This excerpt from section 14.21 of the Java Language Specification should make things clears:
A do statement can complete normally if and only if at least one of the following is true:
The contained statement can complete normally and the condition expression is not a constant expression with value true.
The do statement contains a reachable continue statement with no label, and the do statement is the innermost while, do, or for statement that contains that continue statement, and the continue statement continues that do statement, and the condition expression is not a constant expression with value true.
The do statement contains a reachable continue statement with a label L, and the do statement has label L, and the continue statement continues that do statement, and the condition expression is not a constant expression with value true.
There is a reachable break statement that exits the do statement.
Reference:
https://docs.oracle.com/javase/specs/jls/se11/html/jls-14.html#jls-14.21

The -p and –module-path options specify where to find application modules.
Reference:
https://docs.oracle.com/en/java/javase/11/tools/javac.html

Notice a string created with a string literal, string-valued constant expression or with the String#intern method is always put into the string constant pool.
When the String constructor is called, the first object is created. The intern method then puts this string into the string constant pool and no new object is created. The next method in the chain, toUpperCase, generates a new string object without putting it into the pool. This means after the first statement, two objects are existent.
The second statement just takes the string “hello” from the constant pool and assigns it to the string2 variable. No new object is created here.
In the last statement, a String object with content “HELLO” is created and added to the pool. When the toLowerCase method is called on this string, one more String object is created.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#intern()

Option A is incorrect as the number of parameters doesn’t match.
Option B is incorrect as the return type doesn’t match.
Option C is incorrect because when the return keyword is used, the body of a lambda expression must be in its complete form. Specifically, this option would have been correct had a semicolon been inserted right before the closing curly bracket.
Option D is incorrect as the type of the second parameter doesn’t match. It must have been Integer instead of int.

The access array[2][3] is valid, meaning the first dimension of the array must have at least three elements, while the second must have at least four. Array 1 and array 2 have only two elements in the first dimension, hence invalid.
Array 3 has three elements in the first dimension, but the second dimension has no elements. Therefore, an access to any element will lead to a NullPointerException. Notice the for loop seems to initialize elements of the first dimension, but it doesn’t. The reason is that the newly created one-dimensional arrays aren’t assigned back to the original two-dimensional array.
Array 3 would have also been correct had the for loop been replaced by:
for (int i = 0; i < array.length; i++) {     array[i] = new String[4]; }

The existing code cannot compile as the m method in the Bar class is static, while the one with the same signature in the FooBar class is non-static. A non-static method cannot override a static method, thereby causing a compile-time error. Option E is incorrect, then.
Declaring the m method as static doesn’t help because the Foo interface also has a method with the same signature, and this method is non-static. A static method cannot hide a non-static method; thus, the compiler still fails. Removing the m method doesn’t work either as the FooBar class still has a method with the same signature, which is inherited from the Bar class. Therefore, it’s clear that options B and C are incorrect.
Declaring the FooBar class as abstract doesn’t have any influence on method overriding and hiding that we’ve just discussed, meaning option A is incorrect.
In fact, with the given Foo and Bar types, no classes can extend Bar and implement Foo at the same time.

To use a static member of a type directly in another type, we must use a static import statement. We can either import that particular static member:
import static foo.MyFoo.myField;
Or import all static members of the enclosing type:
import static foo.MyFoo.*;
Reference:
https://docs.oracle.com/javase/tutorial/java/package/usepkgs.html

The compiler doesn’t evaluate any expression at compile time; thus, the code must prepare for all possible workflows.
In the given program, the else branch of the if statement is never executed. Nonetheless, the compiler doesn’t know that. As a result, the IOException listed in the throws clause of the first m method must be handled. The solution mentioned in option C specifies this exception, allowing it to be thrown up the call stack.
The second m method specifies NullPointerException. This exception is unchecked, hence doesn’t need to be handled.

A switch expression can only work with the byte, short, char, and int primitive data types, meaning options from C to G are all invalid.
In the body of the select method, the operand 10 is of type int, hence the expression x * 10 returns an int value. This value can be cast to more widening primitive types, but none of these types is valid to be used in the switch statement.
Reference:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html

The replace method with two char parameters simply returns the String object on which the method are called if those parameters are the same. The replace method with two CharSequence parameters and the replaceAll method always return a new object.

There’s nothing wrong with the given code. When assigning a literal to a variable of a primitive type, the compiler just checks if the input value is within the range of the declared primitive type. In the main method, the character variable is set to the Unicode character with code point 1.
The three methods with name aMethod are overloaded. When calling these methods with a given argument, the compiler determines the applicable method by following these three phases – which is documented in the section 15.12.2 of the Java Language Specification:
The first phase performs overload resolution without permitting boxing or unboxing conversion, or the use of variable arity method invocation. If no applicable method is found during this phase, then processing continues to the second phase.
The second phase performs overload resolution while allowing boxing and unboxing, but still precludes the use of variable arity method invocation. If no applicable method is found during this phase, then processing continues to the third phase.
The third phase allows overloading to be combined with variable arity methods, boxing, and unboxing.
The cast from char to int or double is widening, hence the first two overloaded methods match the invocation in phase 1. Type int is closer to char than double, implying the first method is executed.
The last method also matches the invocation, but it only happens in phase 2.
Reference:
https://docs.oracle.com/javase/specs/jls/se11/html/jls-15.html#jls-15.12.2

In options B and D, the lambda expression parameters are declared with names that have already been used in the main method, thus a compile-time error occurs.
In option C, the lambda expression parameters are incorrectly defined, hence this option is incorrect as well.
Notice option E enables the program to compile, but it may not produce a result we expect. In this case, the lambda expression parameters are ignored, and the comparison is made based on variables declared outside of the expression itself.
In contrast, option A shows a correct use of lambda expressions.

When method overriding occurs, the overriding method cannot specify a checked exception that isn’t specified by the overridden one.
In the given code, the m method in the Foo class specifies IOException. This requires the method in the Bar class not to specify any checked exception that isn’t IOException.
Among all the options, NullPointerException is unchecked, thus it’s valid. FileNotFoundException is a subtype of IOException, meaning it’s valid too.
The Exception class isn’t a subtype of IOException; hence, this exception class cannot be specified.

The mismatch method finds and returns the index of the first mismatch between two array arguments, otherwise return -1 if no mismatch is found.
In the given code, all three arrays only have the first element in common. Therefore, all the invocations of mismatch return the index of the second element.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html#mismatch(java.lang.Object%5B%5D,java.lang.Object%5B%5D)

The continue statement isn’t applicable in a switch construct. In the given code, a continue statement doesn’t skip a switch label but rather the current iteration of the for-each loop.
Each time a switch label is matched, the continue statement gets executed, skipping the rest of the for-each construct. This makes the println statement unreachable, thereby causing a compile-time error.

Let’s re-write the given code to make it clearer:
int i = 0;
i = i + (i = 10) * (i + 1);
System.out.println(i);
Because i equals 0, this fragment is equivalent to:
int i = 0;
i = (i = 10) * (i + 1);
System.out.println(i);
Now, re-write it again:
int i = 10;
i = 10 * (i + 1);
System.out.println(i);
At this point, it should be clear that the final value of variable i is 110.

Here are a few notes regarding executing a modular program:
The main module and all the dependency modules must be added to the module path This module path is indicated by the m or -module-path option
When adding a module in a JAR file to the module path, we can specify that file or its containing directory
The main class to be run must be specified under the containing module with the m or -module option
Option A is incorrect as a module path option isn’t specified.
Option C is incorrect as the -module option is invalid. We must use -m or –module instead.
Option D is incorrect as the module option is missing, while module path value is invalid.
Option E and G are incorrect as main method mustn’t be specified.
Option F is incorrect as the -m option value is invalid, while the -c option doesn’t exist.
Reference:
https://docs.oracle.com/en/java/javase/11/tools/java.html

The foo variable references an object of the MyBar class. When method calculate is called, the number field in this class is changed to 30. However, the reference type of foo is MyFoo, meaning a field accessed via this variable is the one that’s defined in the MyFoo interface. The value of this field is 0, hence number 0 is printed to the console.

The j variable is declared within the try block. After that, there’s a catch block. This catch block isn’t enclosed in the try block, hence the declaration of j is invisible in the catch block.
However, in the catch block, there’s a reference to the j variable. A reference to an invisible variable like this leads to a compile-time error.

On line 2, the m method is called on a Bar object. However, the type of the variable referencing that object is Foo. This type doesn’t have an m method with a String parameter. Consequently, the compiler fails over here.
The m method in the Bar class doesn’t have the same signature as the one in the Foo class, meaning it doesn’t override that method. As a result, the method in Bar can specify any exception, and line 1 is valid.
The Bar class inherits the no-parameter method from the Foo class; hence, line 3 is valid as well.

The entry method of a program must be a public static method. Its name must be main, the parameter type is String[] or String…, and the return type is void. The parameter name as well as the order of modifiers aren’t important.

If the iteration variable i is set to 1, the given method returns straight away due to the return statement in the switch construct. This means the break statement can never be reached, leading to a compile-time error.

When each of variables s1, s2 and s3 is initialized, a new String object is constructed. This means after the third statement, three objects have been created.
Notice the String class is immutable, hence any change to a string generates a new object instead of modifying the existing one. In the last statement, the expression s1 + s2 creates a new String object. This object is then concatenated with the string referenced by s3, resulting one more String object.

In Java, fields and static methods aren’t polymorphic. This means we can hide fields and static methods, not override them.
In the given code, the variable foo has reference type Foo, but the object it refers to is an instance of the Bar class. Since myField is a field and myMethod is a static method, what we see over here is field and method hiding.
When hiding happens, the members of an object that get accessed is determined by the reference type at compile-time. The reference type of variable foo is Foo, thus both myField and myMethod in the main method refer to members of the Foo class.
Notice field hiding occurs even if the fields in the subclass and superclass have different types.
Reference:
https://docs.oracle.com/javase/tutorial/java/IandI/override.html
https://docs.oracle.com/javase/tutorial/java/IandI/hidevariables.html

The expression a = b = c simply sets variables a and b to the value of c, hence they are all equal to 3 at this point.
The other statements can be rewritten as:
b = 0 – d;
c = c * c;
d = d % a;

Adding a method implementation at position 2 in fact doesn’t solve any problems. When the implements Foo clause is inserted at position 3, it only makes methodA valid. The remaining method in the FooBar class, methodB, carries the @Override annotation without overriding any supertype’s method. Therefore, option D is the correct answer.

The test module depends on the foo module, which in turn depends on the bar module. Notice the dependency of foo on bar is transitive, implying the test module depends on the bar module as well.
In addition to dependencies between declared modules, all the modules also depend on the base module. Among all the given graphs, only option D describes the dependencies correctly.

When an exception is thrown from within a try block, the first exception handler whose exception type matches the exception object takes action.
In the given code, when an IOException is thrown, the second catch block handles it because Exception is the parent of IOException. This means the last catch block can never be reached, leading to a compile-time error.
Notice when specify multiple catch blocks with exception types in the same inheritance hierarchy, the block with the most specific type must go first, and the one with the most general type is the last.

Among all the options, only B and C have valid array access syntax. The statements in theses options reads the second and the forth element in the third array, respectively. In both cases, an ArrayIndexOutOfBoundsException is thrown.
To get the third element in the second array – letter “f”, an access with indexes [1][2] is needed:
String element = matrix[1][2];

The first occurrence of the string “is” in the given text is at index 2, thus the value of text after the first invocation of the substring method is “is it”. The second substring calling returns a new string, but this return value isn’t assigned back to the text variable. Therefore, the string referenced by text is still the same – that’s “is it”. This is the value getting printed.

Unlike all other operators in Java, assignment operators are evaluated from right to left. Therefore, the given assignments can be rewritten as:
y = y + z;
x = x – y;

Foo is an abstract class, but this doesn’t prevent us from defining its constructors. However, such constructors can only be invoked from within a constructor of its subclasses. The call on line 4 isn’t one of those cases, resulting in a compile-time error.

The compiler only adds the default constructor if a class isn’t defined with an explicit one. In the given code, the Foo class has a constructor with a CharSequence parameter, hence no default constructor is added. Therefore, the invocation of such a constructor on line 1 leads to a compile-time error.
Notice both String and StringBuilder classes implement the CharSequence interface, thus we can use objects of these classes to call the constructor of the Foo class.

The replace method replaces the substring “BC” with “C”. So, the builder after the replacement is “ACD”. The builder’s length at this point is 3, hence the offset for an insert mustn’t larger than 3. However, in the given code, letter “Q” is inserted at the offset 4, resulting in a StringIndexOutOfBoundsException.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuilder.html#replace(int,int,java.lang.String)
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuilder.html#insert(int,java.lang.CharSequence)

The tools and commands the JDK provides can be found via the referenced link. Integrated Development Environments (IDE) and Version Control Systems are very important to developing applications, but they aren’t included in the JDK.
Reference:
https://docs.oracle.com/en/java/javase/11/tools/

Lines 1 and 2 are valid as those fields just hide fields of the same name in the Foo interface.
The Foo#methodB method is static and belongs to the Foo interface itself. Subtypes of this interface don’t even inherit that static method, hence they can define a method with the exact same signature.
Line 3 is invalid as a static method cannot override or hide a non-static one.

In the given program, the dependency between the foo and bar modules is circular. Such a dependency is forbidden in Java, leading to a compile-time error.

When the while condition expression is executed for the first time, it returns true. Inside the body of the statement, the language variable is flipped to its uppercase version, then back to lowercase right afterward. As a result, the condition expression is evaluated to true over and over again, leading to an infinite loop.
Reference:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html

Option A is incorrect as an exception handler may contain only a try and a finally block.
Option D is incorrect because if the JVM exits while the try or catch code is being executed, then the finally block may not execute. Likewise, if the thread executing the try or catch code is interrupted or killed, the finally block may not execute even though the application as a whole continues.
Option E is incorrect as the finally block is just a normal block of code. We can handle an exception thrown from such a block by catching or specifying it in the containing method’s declaration.
Reference:
https://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html

The isEmpty method returns true if and only if its length is 0
The isBlank method returns true if the string is empty or contains only white space codepoints, otherwise false.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#isEmpty()
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#isBlank()

methodA in the Foo class is abstract, but it’s already overridden in the Bar class, hence the Baz class doesn’t override it. methodB is a concrete method, thus it doesn’t need to be overridden either.
methodC is an abstract method in the Bar class, but it hasn’t been overridden. This is the method the Baz class must override.

As per the JDK API Specification, the Arrays#mismatch method finds and returns the index of the first mismatch between two Object arrays, otherwise return -1 if no mismatch is found. The index will be in the range of 0 (inclusive) up to the length (inclusive) of the smaller array.
If the two arrays share a common prefix, then the returned index is the length of the common prefix and it follows that there is a mismatch between the two elements at that index within the respective arrays. If one array is a proper prefix of the other, then the returned index is the length of the smaller array and it follows that the index is only valid for the larger array. Otherwise, there is no mismatch.
In the given code, array2 is a proper prefix of array1, hence the returned index is the length of array1, which is 1 in this case.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html#mismatch(java.lang.Object%5B%5D,java.lang.Object%5B%5D)

Here’s a description of the jdeps command:
The jdeps command shows the package-level or class-level dependencies of Java class files. The input class can be a path name to a .class file, a directory, a JAR file, or it can be a fully qualified class name to analyze all class files. The options determine the output. By default, the jdeps command writes the dependencies to the system output. The command can generate the dependencies in DOT language (stored in .dot files).
Reference:
https://docs.oracle.com/en/java/javase/11/tools/jdeps.html

There’s nothing wrong with the given code. The fact that the loop label has the same name as the containing method doesn’t matter.
Now, let’s go over iterations of the while construct:
Iteration 1:
Variable number is compared to 5 – the expression evaluates to true, meaning the while body is executed
Variable number is increased to 1
The if expression evaluates to false, thus the continue statement is skipped
The current value of number, which is 1, is printed out
Iteration 2:
Variable number is compared to 5 – the expression evaluates to true, meaning the while body is executed
Variable number is increased to 2
The if expression evaluates to true, thus the continue statement is executed and the current iteration is skipped
Iteration 3: Similar to iteration 1; variable number is increased to 3 and gets printed
Iteration 4: Similar to iteration 2; variable number is increased to 4 and nothing is printed
Iteration 5: Similar to iteration 1; variable number is increased to 5 and gets printed
In the next iteration, the condition expression evaluates to false, hence the while statement exits, and the program terminates.
Reference:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/branch.html

When a class is compiled, a field initialization statement can be considered an initialization block, and all initialization block bodies are copied to the beginning of each constructor. As a result, at the bytecode level, a constructor body always follows the initialization of any field, hence can reference that field.
Outside of the constructors, however, a field can only reference other fields that have been defined before it; otherwise we’ll have an illegal forward reference error.
On line 2, the text1 field references text2, which hasn’t been defined until line 3. Therefore, the compilation fails on line 2.

When a class declares an extended class and implemented interfaces, the class name must go first, then interface names which are separated by commas. This doesn’t happen in the given code.
Had the Test class declaration been:
public class Test extends Bar implements Foo {
    // class body
}
Option F would have been the correct answer.

In options A and C, the name field isn’t private, thus it’s accessible to the outside of the class. As a result, the field and its associated accessors no longer form a single unit.

Option B is incorrect because the strip method just removes leading and trailing while spaces.
Notice both the trim and strip method remove white spaces, but they use different definitions of white spaces: for trim, it’s all character whose codepoint is less than or equal to ‘U+0020’; for strip, it’s all character whose codepoint returns true when passed to the Character#isWhitespace method. We can say that strip is “Unicode-aware” evolution of trim.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#trim()
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#strip()

No matter what happens inside the playWithData method, the variable that references the passed-in object still points to the same object after the method completes. As a result, this object isn’t ready to be garbage collected even after the given method returns.

Since the text field is static, it can be accessed via both class references and instance references. The Bar class is a subtype of the Foo class, hence inherits that field. This explains why we can access the text field using any of the expressions shown in options A to E.

When dividing number 1 by 0, we get an ArithmeticException. This exception is then caught by the first catch block and re-thrown. Before the program exits with an exception, the finally block gets executed, printing out the string “finally”.
Notice the second catch block only processes exceptions thrown by the first try block – it doesn’t belong to the same exception handler as the second try block, thereby taking no action when the ArithmeticException is re-thrown.

Option A is incorrect as variables i and j are defined in the initialization expression and aren’t visible outside of the for construct.
Option B is incorrect as variable i is defined twice: the first is right before the for construct and the second is in the initialization expression;
Option C is incorrect as variable i is defined in the initialization expression but never be set a value, hence its existence in the System.out.println statement leads to a compile-time error.
Option D is incorrect as the if/else construct makes the last statement unreachable, which also results in a compile-time error.
Reference:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/branch.html

A type defined with no package declaration is part of an unnamed package. Such a type can be referenced from other types in the unnamed package, but invisible to types in named packages.
Reference:
https://docs.oracle.com/javase/specs/jls/se11/html/jls-7.html#jls-7.4.2

The add method with two parameters inserts the specified element, denoted by the second parameter, at the specified location, denoted by the first parameter.
In the given code fragment, number 3 is inserted at position 1, hence the resulting list is [1, 3, 2].
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html

Here’s a description of the –print-module-deps option of the jdeps command:
Same as –list-reduced-deps with printing a comma-separated list of module dependencies. The output can be used by jlink –add-modules to create a custom image that contains those modules and their transitive dependencies.
Reference:
https://docs.oracle.com/en/java/javase/11/tools/jdeps.html

In the Foo class, methodA has return type Object. In order to override this method, a method in the Bar class must has a return type that is a subtype of Object. On line 1, the return type is a primitive type, hence invalid. On line 2, the return type is a subclass of Object, meaning this line can be uncommented.
Meanwhile, methodB in the Foo class has return type String. None of the methods named methodB in the Bar class has a return type that is a subtype of String. As a result, lines 3, 4 and 5 are all invalid.

As per the JDK API Specification, the asList method returns a fixed-size list backed by the specified array. (Changes to the returned list “write through” to the array.) This method acts as bridge between array-based and collection-based APIs, in combination with Collection.toArray().
Since all the changes are written through, the created list and its backing array contain the same elements. These are set for the last time in the two statements following the invocation of the asList method.
Reference:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html#asList(T…)

All expressions, including initialization, termination and increment, in the for loop are empty. This may look weird but is entirely valid. Instead of relying on such expressions, we must control the for loop using statements in its body.
In the first iteration, variable number starts with the value of 0, making the if expression evaluate to true. Since the body of the if statement is executed, number 0 is printed and the break statement terminates the for loop.
As a result, only number 0 is printed to the console.
Reference:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html

If existent, the package statement must be the first in a source file, before any other statement. In the given code, the package statement follows an import one, resulting in a compile-time error.

The remove method with an int parameter removes the element at the specified position and returns the element itself. Thus, the first calling of remove in the given code returns “A”.
The other overloaded method, the one with an Object parameter, removes the first occurrence of the specified element, returning true if the list contains such an element and false otherwise. After the first removal, our list has only one element left: “B”. This means the removal of “A” returns false while that of “B” returns true.
Reference: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#remove(int)
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#remove(java.lang.Object)

The Foo constructor may throw an IOException. This is a checked exception, thus must be caught or specified. The solution in option A specifies this exception on the constructor’s declaration, which solves the issue.

The MyBar class extends MyFoo but doesn’t inherit its abstract method, which is package-private. This means MyBar doesn’t override the m method defined in MyFoo, resulting in a compile-time error.
Option A is incorrect since such a change would lead to the overriding method having weaker access privilege than the overridden one. Such an overriding behavior is forbidden.
Option B is incorrect as such a change doesn’t modify the fact that MyBar doesn’t have access to the m method in MyFoo, hence cannot override it.
Option C is incorrect as MyFoo would become a non-abstract class that contains an abstract method. This kind of class declaration is invalid.
Option D is correct as this change would turn MyBar into an abstract class, which doesn’t need to override any abstract methods in its super-classes.

When classes are loaded, all static fields are initialized, and static methods/initialization blocks are executed. Thus, the strings “Init Foo” and “Init Bar” are printed prior to “Super” and “Sub”.
The Bar class extends Foo, thus has a dependency on this superclass. As a result, Foo is loaded before Bar, meaning “Init Foo” is printed before “Init Bar”.
When the no-argument constructor of the Bar class is invoked, it makes a call to the no-argument constructor of the Foo class. Therefore, the string “Super” goes before “Sub”.

During the first iteration of the do/while construct, when the variable number reaches 3, the break statement gets executed. This is a labeled statement, terminating the do/while construct instead of the for loop. At this point, the value of variable sum is 3, which is the sum of the first two numbers.