Unit 2 - Practice Quiz

The for loop is ideal for situations where the number of iterations is known, as its structure compactly includes initialization, a condition, and an increment/decrement expression.

A while loop is a pre-test loop. It evaluates its condition before each iteration. If the condition is false initially, the loop body will not execute at all.

A do-while loop is a post-test loop. It executes the loop body first and then checks the condition, ensuring at least one execution regardless of whether the condition is initially true or false.

The for-each loop (or enhanced for loop) provides a simpler, more readable syntax for iterating through all the elements of an array or a collection without using an index variable.

The correct syntax for declaring and initializing an array in one statement is type[] arrayName = {value1, value2, ...};. The form type arrayName[] is also valid for declaration.

Array indexing in Java is 0-based. For an array of size 10, the indices start at 0 and go up to length - 1, which is 9.

The standard syntax to declare and instantiate a multi-dimensional array is type[][] arrayName = new type[rows][columns];.

Varargs (variable-length arguments) allows a method to accept zero or more arguments of a specified type. Inside the method, the varargs are treated as an array of that type.

An enumeration is a special data type that represents a set of predefined constants. It is defined using the enum keyword.

Enum constants are accessed statically using the enum's name, followed by a dot, and then the constant's name, like Level.MEDIUM.

A class is a blueprint, and an object is a concrete instance created from that blueprint. It has state (fields) and behavior (methods) as defined by its class.

A constructor is a special method called when an object is instantiated. Its primary role is to initialize the state (instance variables) of the new object.

Method overloading allows multiple methods in the same class to share the same name, as long as their parameter lists (number, type, or order of parameters) are different.

Just like methods, constructors can be overloaded. This allows you to create objects in different ways by providing different sets of initial values.

The this keyword is a reference to the current object—the object whose method or constructor is being called. It is often used to disambiguate between instance variables and parameters.

An instance initializer block is a set of curly braces {} defined at the class level. Its code is run before the constructor every time a new object is created.

String objects in Java are immutable, which means once a String object is created, its value cannot be changed. Any operation that appears to modify a string actually creates a new String object.

The length() method in the java.lang.String class returns the length of the string, which is the count of its characters.

The charAt(int index) method returns the character at the specified index. Since strings are 0-indexed, index 1 corresponds to the second character, which is 'e'. The return type is char.

StringBuilder is designed for creating and manipulating mutable sequences of characters. It is more performance-efficient than String for operations involving frequent changes because it does not create a new object for every modification.

The outer loop runs for i = 0, i = 1, and i = 2.

• When i = 0, the inner loop runs for j = 0, 1, 2. count becomes 3.
• When i = 1, the inner loop runs for j = 0. count becomes 4. When j becomes 1, the condition i == 1 && j > 0 is true, and the break OUTER; statement terminates the entire outer loop.
• The loop for i = 2 is never reached.
  Thus, the final value of count is 4.

A do-while loop always executes its body at least once. In the first iteration, x is 10. The body x -= 3; executes, and x becomes 7. Then, the condition while (x > 10); is checked. Since 7 is not greater than 10, the condition is false, and the loop terminates. The final value of x, which is 7, is printed.

The code iterates through a ragged 2D array and sums the last element of each inner array.

• For i = 0, arr[0].length is 2. The last element is arr[0][1], which is 2. sum is 2.
• For i = 1, arr[1].length is 3. The last element is arr[1][2], which is 5. sum is 2 + 5 = 7.
• For i = 2, arr[2].length is 1. The last element is arr[2][0], which is 6. sum is 7 + 6 = 13.
  The final sum printed is 13.

In a for-each loop with primitive types (like int), the loop variable x is a copy of the array element's value, not a reference to the element itself. Therefore, modifying x inside the first loop (x = x + 5;) does not change the original values in the numbers array. The second loop iterates over the unchanged array and prints its original elements: 10 20 30.

Java's method overloading resolution prefers a specific match over a varargs match. When test(10, 20) is called, the compiler finds a method signature test(int x, int y) that is an exact match for the arguments provided. The varargs method test(int... v) is only chosen if no more specific method signature is available. Therefore, the test(int x, int y) method is invoked, and it prints "int, int".

Enums in Java can have constructors, fields, and methods. In this example, the Signal enum has a constructor that takes a String and assigns it to the action field. When the enum constants GREEN, YELLOW, and RED are created, their respective constructors are called with the provided strings. The line Signal current = Signal.YELLOW; assigns the YELLOW constant to the current variable. Calling current.getAction() invokes the getAction method on the YELLOW instance, which returns the value of its action field, initialized to "Wait".

In Java, object references are passed by value.

1. box1 and box2 are created, both with size = 10.
2. box1.updateSize(box2, 20) is called. Inside the method, the parameter b is a copy of the reference to box2.
3. b.size = newSize; changes the size of the object that b (and box2) points to. So, box2.size becomes 20.
4. b = new Box(); reassigns the local parameter b to point to a new Box object. This does not affect the original box2 reference in main.
5. b.size = 5; changes the size of this new Box object, which is local to the method and is discarded when the method ends.
6. The updateSize method does not modify box1 at all.
   Therefore, the output is the size of box1 (10) and the modified size of box2 (20).

The method call calc.add(10, 20) provides two integer literals. The compiler looks for a matching add(int, int) method. Since one doesn't exist, it looks for methods that can be called via type promotion (widening conversion).

• add(int a, double b) is a potential match because the second argument 20 (int) can be promoted to a double.
• add(double a, int b) is also a potential match because the first argument 10 (int) can be promoted to a double.
  Since both methods are equally applicable after one promotion, the compiler cannot decide which one to choose. This results in a compilation error for an ambiguous method call.

1. new Car("Sedan") calls the first constructor Car(String model).
2. The first line in this constructor is this(model, 2023), which is a call to another constructor in the same class (constructor chaining). This call must be the very first statement.
3. The second constructor Car(String model, int year) is executed. It initializes this.model and this.year, and then prints "C2 ".
4. After the second constructor finishes, control returns to the first constructor.
5. The first constructor then executes its next statement, System.out.print("C1 ");.
6. Finally, in the main method, System.out.print(myCar.year); prints the value of year, which was set to 2023.
   The final output is "C2 C1 2023".

In the constructor Point(int x, int y), the statement x = x; refers to the local parameter x on both sides of the assignment. It is assigning the value of the parameter x (which is 10) to itself. The instance variable this.x is never assigned a value, so it retains its default value for an int, which is 0. The statement this.y = y; correctly uses the this keyword to distinguish the instance variable this.y from the parameter y, so the instance variable y is correctly assigned the value 20. Therefore, the output is "x=0, y=20".

The order of execution is as follows:

1. Static initializer block: Runs only once when the class is first loaded into the JVM. This prints "S".
2. First object creation (new MyClass()):
   a. The instance initializer block runs. This prints "I".
   b. The constructor runs. This prints "C".
3. Second object creation (new MyClass()):
   a. The static block does not run again.
   b. The instance initializer block runs again for the new object. This prints "I".
   c. The constructor runs again for the new object. This prints "C".
   Combining these steps, the final output is "S I C I C".

The key concept here is the immutability of the String class in Java. When methods like concat() or toUpperCase() are called on a String object, they do not modify the original string. Instead, they return a new String object with the result.

• s1 is initialized to "hello".
• s1.concat(" world") creates a new string "hello world" which is assigned to s2.
• s1.toUpperCase() creates a new string "HELLO", but its return value is not assigned to any variable. s1 itself remains unchanged.
• Therefore, s1 is still "hello" and s2 is "hello world". The output is "hello hello world".

StringBuilder is mutable, so its methods modify the object in place.

1. sb is initialized to "start".
2. sb.append("le"): sb becomes "startle".
3. sb.insert(5, "t"): The character 't' is inserted at index 5. sb becomes "starttle".
4. sb.delete(1, 4): Deletes characters from the starting index 1 (inclusive) to the ending index 4 (exclusive). It deletes 't', 'a', and 'r'. sb becomes "stle".
   Finally, "stle" is printed.

• s1 == s2: s1 is a string literal from the string pool. s2 is created using new, so it's a new object on the heap. The == operator compares object references (memory addresses), which are different. So, this is false.
• s1 == s3: Both s1 and s3 are string literals with the same value. Java's string pool reuses this literal, so both variables point to the same object in memory. This is true.
• s1.equals(s2): The .equals() method compares the actual character sequences of the strings. Since both strings contain "Java", this is true.
  Therefore, the output is "false, true, true".

This code demonstrates method chaining, which is possible because the add and subtract methods return this (a reference to the current object).

1. calc.add(10): result becomes 10. The method returns the calc object.
2. .subtract(3) is called on the returned calc object. result becomes 10 - 3 = 7. The method returns the calc object again.
3. .add(5) is called on the returned calc object. result becomes 7 + 5 = 12. The method returns the calc object.
4. .getResult() is called on the calc object, which returns the final value of result, which is 12.
   This value is then printed to the console.

In Java, array variables are references.

• int[] a = {1, 2, 3}; creates an array object and a holds its memory address.
• int[] b = {1, 2, 3}; creates a new, separate array object with the same content. b holds a different memory address.
• int[] c = a; makes the reference c point to the same array object as a.
• check1 = (a == b): Compares the memory addresses of a and b. Since they are different objects, this is false.
• check2 = (a == c): Compares the memory addresses of a and c. Since they point to the same object, this is true.
• c[1] = 5;: Modifies the second element of the array that both c and a are pointing to. Therefore, a[1] also becomes 5.
  The output is false, true, 5.

Let's trace the values of i and j in each iteration of the while loop.
The loop continues as long as i < j.

• Start: i=0, j=10. Condition 0 < 10 is true.
• Iter 1: i becomes 1, j becomes 9. Prints '#'. Condition 1 < 9 is true.
• Iter 2: i becomes 2, j becomes 8. Prints '#'. Condition 2 < 8 is true.
• Iter 3: i becomes 3, j becomes 7. Prints '#'. Condition 3 < 7 is true.
• Iter 4: i becomes 4, j becomes 6. Prints '#'. Condition 4 < 6 is true.
• Iter 5: i becomes 5, j becomes 5. Prints '#'. Condition 5 < 5 is now false.
  The loop terminates. The character '#' was printed 5 times.

1. StringBuilder sb = new StringBuilder(5); creates a StringBuilder with an initial capacity of 5.
2. sb.append("Java"); adds a 4-character string. The length is now 4, capacity is 5.
3. sb.append(" is fun"); attempts to add a 7-character string. The total required length is 4 + 7 = 11. Since this exceeds the current capacity of 5, the StringBuilder must expand its internal array. The new capacity is typically calculated as (old_capacity * 2) + 2. So, new capacity becomes (5 * 2) + 2 = 12.
4. The final string is "Java is fun", which has a length of 11.
5. The final capacity is 12. So, len is 11 and cap is 12.

Java passes object references by value.

1. In main, myBook is created, pointing to a Book object with title "A Tale of Two Cities".
2. changeTitle(myBook) is called. The parameter book inside the method receives a copy of the reference from myBook. Both myBook and book now point to the same object.
3. book.title = "The Great Gatsby";: This line modifies the title field of the object that both references are pointing to. So, myBook.title is now "The Great Gatsby".
4. book = new Book("Moby Dick");: This reassigns the local reference book to a brand new Book object. This action does not affect the myBook reference in main, which still points to the original object.
5. book.title = "1984";: This modifies the title of the new, local object. This change is lost when the method ends.
6. Back in main, System.out.println(myBook.title); prints the title of the original object, which was last changed to "The Great Gatsby".

Constructors for enums must be private (or package-private, which is the default). They cannot be declared public or protected. The reason is that only the JVM can construct enum instances; you cannot create them manually using new. Snippet B attempts to declare a public constructor public Size() {}, which is a compilation error. Snippet C is valid because it explicitly declares a private constructor. Snippet A is valid because the compiler provides a default private constructor. Snippet D is a valid basic enum declaration.

Let's trace the execution:

• i = 0:
  • j = 0: i == j is true. continue outer; is executed. The inner loop terminates

The order of execution is critical:

1. Static Initialization (once, when class is loaded):
   a. The static variable s1 is initialized to "Static".
   b. The static initializer block is executed. It prints "Static ".
2. Object Creation (new Demo(10);):
   a. The constructor Demo(int x) is called.
   b. Instance Initialization begins: The instance variable s2 is initialized to "Instance".
   c. The instance initializer block { s2 = "Block"; } is executed. s2 is now "Block".
   d. The body of Demo(int x) starts. It first calls this(), which invokes the no-argument constructor.
   e. The no-argument constructor Demo() is executed. It prints the current value of s2, which is "Block ".
   f. Control returns to the Demo(int x) constructor. It prints s1 + "-" + x, which is "Static-10 ".

Combining the print statements in order gives: Static Block Static-10.

Java's overloading resolution rules are tested here.

1. ot.process(5, Integer.valueOf(10)); perfectly matches process(int i, Integer j). No ambiguity.
2. ot.process(new Integer(5), 10); perfectly matches process(Integer i, int j). No ambiguity.
3. ot.process(5); does not match the two-argument methods. It matches the varargs method process(int... i). No ambiguity.
4. ot.process(5, 10); is ambiguous. The compiler needs to decide between process(Integer i, int j) and process(int i, Integer j). To match the first, it would need to autobox the first argument (5 to Integer). To match the second, it would need to autobox the second argument (10 to Integer). Since both options require one level of conversion (autoboxing) and neither is more specific than the other, the compiler cannot choose and reports an 'ambiguous method call' error.

This question tests the understanding that arrays are objects and array variables are references.

1. matrix[0] points to the array {1, 2}.
2. matrix[1] points to the array {3, 4, 5}.
3. matrix[2] = matrix[0]; makes matrix[2] point to the same array object as matrix[0]. They are now aliases.
4. matrix[1][1] = 9; changes the second array to {3, 9, 5}. This does not affect matrix[0] or matrix[2].
5. matrix[2][0] = 7; modifies the array pointed to by matrix[2]. Since matrix[0] points to the same array, the array is now {7, 2}. This change is visible via both matrix[0] and matrix[2].
6. The sum is calculated:
   • matrix[0][0] is now 7.
   • matrix[0][1] is 2.
   • matrix[2][1] is also 2 (since matrix[2] is the same as matrix[0]).
7. The final sum is 7 + 2 + 2 = 11.

The key is the order of operations in the constructors due to the this() call.

1. new Point(5) calls the Point(int x) constructor.
2. The first statement in this constructor is this(x, x + 10), which is this(5, 15). This call must be the very first statement.
3. The Point(int x, int y) constructor is executed. It sets this.x = 5 and this.y = 15.
4. After the Point(int x, int y) constructor finishes, control returns to the Point(int x) constructor.
5. The next line in Point(int x) is this.x = x * 2;. Here, x is the parameter passed to this constructor, which is 5. So, this.x is set to 5 * 2 = 10. The value of this.x is overwritten from 5 to 10.
6. The y coordinate remains 15.
7. Finally, print() is called on the newly created object, which prints x=10, y=15.

This question tests advanced enum features: constructors, abstract methods, and initialization order.

1. When the Element enum class is loaded, its constants are initialized in the order they are declared.
2. The HELIUM constant is created first. Its constructor Element("He", 2) is called, which prints "He ".
3. The SODIUM constant is created next. Its constructor Element("Na", 11) is called, which prints "Na ".
4. This static initialization phase happens before main is executed. So the output so far is "He Na ".
5. The main method starts.
6. System.out.print(SODIUM.isReactive() + " "); calls the overridden isReactive method for SODIUM, which returns true. This prints "true ".
7. System.out.print(HELIUM.atomicNumber); accesses the atomicNumber field of the HELIUM constant, which is 2. This prints "2".
8. The final combined output is He Na true 2.

This question tests the difference between StringBuilder's mutable nature and String's immutability, along with method behaviors.

1. StringBuilder sb = new StringBuilder("race"); -> sb contains "race".
2. sb.append("car"); -> sb is modified to "racecar".
3. sb.reverse(); -> sb is modified to "racecar".
4. String s = sb.substring(0, 4); -> A new String object s is created with the content "ecar". The StringBuilder sb remains unchanged ("racecar").
5. s.toUpperCase(); -> This method call returns a new String object "ECAR", but this returned value is not assigned to any variable. The original String s is immutable and remains "ecar".
6. System.out.println(s + "-" + sb.length()); -> This prints the value of s ("ecar"), a hyphen, and the length of the StringBuilder sb ("racecar"), which is 7.
7. The final output is ecar-7.

This requires careful tracing of the loop condition

This question tests the behavior of the for-each loop with object references.

1. Box[] boxes is an array of references to three Box objects.
2. The first for-each loop starts. The loop variable b is a local copy of the reference from the array.
3. Iteration 1: b points to the same Box object as boxes[0].
   • b.val += 5; modifies the val field of the original object in the array. boxes[0].val is now 15.
   • b = new Box(0); reassigns the local loop variable b to point to a new Box object. This has no effect on the original boxes array.
4. Iteration 2: b points to the same Box object as boxes[1].
   • b.val += 5; modifies the original object. boxes[1].val is now 25.
   • b = new Box(0); reassigns the local b again.
5. Iteration 3: b points to the same Box object as boxes[2].
   • b.val += 5; modifies the original object. boxes[2].val is now 35.
   • b = new Box(0); reassigns the local b.
6. The second loop iterates through the boxes array, which still contains references to the original (but modified) objects. It prints the val of each, resulting in 15 25 35.

This is a tricky overload resolution problem involving varargs, autoboxing, and widening.

1. The call is go(b, b), where b is a byte. So the signature is go(byte, byte).
2. The compiler looks for a matching method.
   • go(byte... b): This is a potential match. It's a varargs match.
   • go(int x, int... y): To match this, both byte arguments must be widened to int. This is a valid conversion (widening primitive conversion).
   • go(long x, long... y): To match this, both byte arguments must be widened to long. This is also a valid conversion.
3. Java's resolution rules prefer widening over varargs. Therefore, go(byte... b) is eliminated from consideration first.
4. Now the compiler must choose between go(int x, int... y) and go(long x, long... y). Both are applicable through widening.
5. The rule is to choose the most specific method. Widening from byte to int is a "smaller" jump than widening from byte to long. Therefore, go(int, int...) is more specific than go(long, long...).
6. The compiler selects go(int x, int... y). The program compiles and prints 'A'.

This question requires a step-by-step trace of StringBuilder's state

This question tests a fundamental rule of constructor chaining. The this() call is used to invoke another constructor within the same class. The Java language specification mandates that if it is used, it must be the very first statement in the constructor. This ensures that the object is properly initialized by the chained constructor before any other logic in the calling constructor is executed. The other options are incorrect: this() can be used in no-arg constructors, it can call constructors with varargs, and it can call any other constructor in the same class regardless of access modifier.

This question addresses the concept of array covariance in Java. Because String is a subclass of Object, an array of String (String[]) can be assigned to a variable of type Object[]. This is syntactically valid and compiles without error. However, at runtime, the object is still fundamentally a String array. The line objArray[1] = 100; attempts to store an Integer object into this String array. The JVM's type system knows the actual type of the array object and prevents this, throwing an ArrayStoreException at runtime. It's not a ClassCastException because no explicit casting is performed, and it's not a compile-time error because of array covariance rules.

This question tests the tracking of multiple variables within a for loop's declaration and update sections.
Let's trace the loop iterations:

• Before Loop: result = 0, i = 1, j = 10.
• Iteration 1:
  • Condition: i < j (1 < 10) is true.
  • Body: result += (10 - 1); result becomes 9.
  • Update: i becomes 1 + 2 = 3, j becomes 10 - 1 = 9.
• Iteration 2:
  • Condition: i < j (3 < 9) is true.
  • Body: result += (9 - 3); result becomes 9 + 6 = 15.
  • Update: i becomes 3 + 2 = 5, j becomes 9 - 1 = 8.
• Iteration 3:
  • Condition: i < j (5 < 8) is true.
  • Body: result += (8 - 5); result becomes 15 + 3 = 18.
  • Update: i becomes 5 + 2 = 7, j becomes 8 - 1 = 7.
• Iteration 4:
  • Condition: i < j (7 < 7) is false.
• The loop terminates. The final value of result printed is 18.

This question tests the overload resolution priority: Widening beats Boxing, which beats Varargs.

1. The argument is a short primitive s.
2. The compiler looks for the best match for a short argument.
3. Exact Match: There is no method(short s).
4. Widening Primitive Conversion: short can be widened to int, long, float, or double. The method(int i) and method(long l) are both applicable via widening. Between these two, int is a "smaller" or more specific conversion than long, so method(int i) is preferred over method(long l).
5. Autoboxing: The short s could be autoboxed to a Short object. Then, this Short object could be passed to a method that takes a superclass, like method(Object o). There is no method(Short s).
6. Boxing then Widening: The short s could be autoboxed to Short, and then the reference could be widened to Object. This matches method(Object o).
7. Resolution Rule: The compiler strictly prefers widening of primitives over autoboxing. Since method(int i) is available via widening, it is chosen without ever considering the boxing options (method(Integer i) or method(Object o)). Therefore, method(int i) is called, and 'A' is printed.

This question dives deep into the String pool and the difference between string literals and new String().

1. s1 == s2: s1 refers to the string "abc" in the string constant pool. s2 is created using new, which explicitly creates a new object on the heap, separate from the pool. Therefore, their references are different, and the result is false.
2. s1 == s3: s3 is initialized with a constant expression "a" + "b" + "c". The Java compiler is smart enough to evaluate this at compile time to the single string literal "abc". Therefore, s3 will also point to the same object in the string pool as s1. The result is true.
3. s2.intern() == s1: The intern() method checks the string pool for a string with the same value as s2. It finds the existing string ("abc", referenced by s1). It then returns the reference to that string from the pool. So, this comparison becomes s1 == s1, which is true.

This question reveals a crucial concept: enum constants are singleton instances.

1. RED, AMBER, and GREEN are the only three instances of the TrafficLight enum that will ever exist in the JVM.
2. TrafficLight light = TrafficLight.RED; creates a reference light that points to the single RED instance.
3. light.setDuration(45); calls the setter method on the object that light refers to. This is the one and only RED instance. This action modifies the internal state (duration field) of that singleton RED object from 30 to 45.
4. System.out.println(TrafficLight.RED.getDuration()); accesses the same singleton RED instance and calls its getter. Since its state was just modified, it will return the new value, 45.
   This demonstrates that while enum constants are fixed, their internal state can be mutable if they are designed with mutable fields and setters, which is generally considered a poor design practice for enums.

This question tests the precise execution order of instance initializer blocks and the constructor, especially in relation to a final instance variable.

1. When new InitOrder() is called, the instance initialization process begins before the constructor body is executed.
2. Instance initializer blocks are executed in the order they appear in the source code.
3. First, Block 1 executes, printing "Block 1 -> ".
4. Second, Block 2 executes, printing "Block 2 -> ".
5. After all instance initializers are complete, the constructor body is executed. It initializes the final variable name to "Default" and then prints "Constructor -> ".
6. Finally, back in main, System.out.print(io.name) prints the value of the now-initialized name field, which is "Default".
   The final output is the concatenation of these print statements: Block 1 -> Block 2 -> Constructor -> Default.

This loop seems to be summing digits