Java silver SE17 Quizzes 4

The program first displays "DD136" and then stops by throwing a StackOverflowError.

Let's look at the behavior of this code step by step.

Call to `check((char)(1 + 11))`: `1 + 11` is 12. This is cast to char and the check method is called.
It matches `case 12:` of the switch statement.

`System.out.print('D' + "" + 'D');`
Calculation is 'D' (char) + "" (empty string) + 'D' (char).
When concatenating a string and a character with +, the character is converted to a string. As a result, the string "DD" is output to the console.

`System.out.print('D' + 'D');`
Calculation is 'D' (char) + 'D' (char).
When adding characters together with +, their character codes (ASCII values) are added.
The character code for 'D' is 68, so 68 + 68 = 136. As a result, the number 136 is output to the console.
The output at this point is DD136. This case returns 136 via `yield 'D' + 'D';`.

Call to `check('D')`
Matches `case 'D':` of the switch statement. This case returns ' ' (space character).

Call to `check('a')`
'a' matches neither `case 'D'` nor `case 12`, so `default` processing is executed.
`default` calls `check((char)('D' + 'D'))`. This is equivalent to calling `check((char)136)`.
Recursive call: The called `check((char)136)` also matches no case, so it enters `default` again and calls `check((char)136)` again. This falls into infinite recursion repeating endlessly.

Conclusion: The program outputs DD136 to the screen in the first call to the check method. Then, during the third call `check('a')`, infinite recursion occurs, eventually exhausting the stack area, throwing a `java.lang.StackOverflowError`, and terminating the program abnormally.

`A a = new B();`
An instance of Class B is created and assigned to variable `a` of type A. The declared type is A, but the actual instance type is B.

Evaluation of `var i = a.useA();`
Calls the `useA()` method of `a`. Class B does not override `useA()`, so the parent class A's `useA()` is called. Inside A's `useA()`, `return a();` is executed.
The important point here is that Class A's `a()` method is declared as private. Private methods are not subject to overriding.
Therefore, even if the actual instance of `a` is B, when `a()` is called from within A's code, A's own private `a()` method is always executed. A's `private A a()` method returns `new A(i)` (where i is Byte 1).
As a result, an instance of A with `i` field set to 1 is assigned to variable `i` in the main method. Thus, `i.i` is 1.

Evaluation of `var j = a.a_(a);`
This is the most critical point. In Java, which overloaded method to call is determined at compile time based on the declared type of the variable. The compiler sees the call `a.a_(a)`. The declared type of variable `a` is A. The argument `a` is also of declared type A.
The compiler looks for an `a_` method that can be called on variable of type A. Class A only has the method `a_(Object i)`. (The method `a_(A a)` defined in Class B is not visible at this point because the variable type is A).
Therefore, at compile time, it is decided to call the `a_(Object i)` method. Next, at runtime, it is determined which overridden method to execute. The actual instance of `a` is B.
Class B overrides the `a_(Object)` method as `public B a_(Object j)`. Therefore, Class B's `a_(Object j)` method is actually executed.
This method executes `return new B();`. When a B instance is created, the no-argument constructor `B()` is called, which implicitly calls the parent class's no-argument constructor `A()`.
In the `A()` constructor, the `Byte i` field is not initialized. Since Byte is a wrapper class (object), the default value for an uninitialized field is `null`.
As a result, an instance of B with `i` field set to `null` is assigned to variable `j` in the main method. Thus, `j.i` is null.

Execution of `System.out.println(""+i.i+j.i);`
`i.i` is 1. `j.i` is null. The expression evaluates to `"" + 1 + null`.
Due to string concatenation, it becomes `"1" + null`, and finally the string "1null" is output.

A method whose return type is set to something other than void (in this case, Main) must reach a return statement regardless of the execution path taken.
In the `count` method, the only return statement is inside the for-each loop. If the array `i` passed as an argument is an empty array (zero elements), this for-each loop will not execute even once.
As a result, execution would pass through the loop and reach the end of the method, but since there is no return statement there, the compiler determines that "the method might end without returning a value".
This causes a "missing return statement" compilation error. Therefore, this program cannot generate an executable file (.class file) and cannot be run.

A: Correct: OutOfMemoryError is a subclass of Error and is an unchecked exception. A throws clause is not required, and no compilation error occurs.
B: Incorrect: When `return;` is executed, the method ends. The subsequent `throw new Exception();` becomes unreachable code, causing a compilation error.
C: Incorrect: `2.0` is a double literal. The result of `2.0 / i` is double type. Returning a double value as a smaller float return type without an explicit cast is a narrowing conversion and causes a compilation error. (Correctly, `return (float)(2.0/i);` is needed.)
D: Incorrect: When `throw new RuntimeException();` is executed, the method terminates immediately. The subsequent `System.out.println();` becomes unreachable code, causing a compilation error.

1st do-while loop (label a)
Enters infinite for loop (label b). `System.out.print(";");` is executed.

Enters for loop (label c).
First extended for loop:
When k is 0: `0 % 2 == 1` is false (0 is even). Executes `System.out.print(k);` in else, printing 0.
When k is 1: `1 % 2 == 1` is true (1 is odd). `break;` is executed, exiting this extended for loop.

Next extended for loop:
When k is 0: `0 % 2 == 0` is true (0 is even). `break c;` is executed, forcibly exiting the entire for loop labeled c. Processing proceeds to the line after for loop c.

Last extended for loop:
When k is 0: Evaluates condition `if (k%3==0 & p==0)`. `0 % 3 == 0` is true AND `p == 0` is true.
`p++;` updates value of p from 0 to 1. `continue a;` is executed, returning to the beginning of the do-while loop labeled a, starting the next iteration.

2nd do-while loop (label a)
Enters infinite for loop (label b).
`System.out.print(";");` is executed. Enters for loop (label c).

First extended for loop:
When k is 0: Outputs 0. When k is 1: Exits this loop with `break;`.

Next extended for loop:
When k is 0: `break c;` is executed, forcibly exiting the entire for loop labeled c.

Last extended for loop:
When k is 0: Evaluates condition `if (k%3==0 & p==0)`. `0 % 3 == 0` is true, but `p == 0` is false (since p is 1). The condition is false overall. Executes `else System.out.print(k);`, outputting 0. `break a;` is executed, exiting the entire do-while loop labeled a, and the program ends.

The reason this code causes a compilation error is in the line `i.i=i.a(2, 2);` inside the main method.
Here the method `a` is called, but parent class A defines two methods named `a`.
One takes arguments `(int i, double j)`. The other takes arguments `(float i, long j)`.
When passing two integers 2 and 2 as arguments like `i.a(2, 2)`, the compiler cannot decide which `a` method to call.

The argument 2 is int type, but int type can be converted to double, float, or long. Therefore, for the compiler, both `a(int i, double j)` and `a(float i, long j)` are candidates for the call, and since there is no clear rule to prioritize one over the other, an "ambiguous method call" error occurs.

By the way, if this compilation error did not exist, the call `i.b(new ArrayList())` in the next if statement would select the `b(List i)` method. Although ArrayList is a Collection, the method taking the more specific type List is prioritized.

The problem is the line `C c=(C)b;` in the main method.
`A a=new B();`: Variable `a` is type A, but the content is an instance of class B.
`var b=(B)a;`: The content of variable `a` (B instance) is cast (type converted) to type B. This succeeds without issues. Variable `b` becomes type B.
`C c=(C)b;`: Attempts to cast the content of variable `b` (B instance) to type C. Here a problem occurs. C is a child class inheriting from B, but the content of `b` is purely a B instance created with `new B()`, not an instance of C. You cannot forcibly convert an instance of a parent class (B) to a child class type (C), so a `ClassCastException` (runtime exception) is thrown when this line executes, and the program terminates forcibly.

A: `private record A(int j) ...`: You cannot specify the private access modifier for a top-level type (class, interface, record, etc.). Only public or package-private (no modifier) are permitted.

B: `abstract record A(...)`: Records are implicitly final and assume they will not be inherited. Therefore, they cannot be defined with the abstract keyword.

C: `sealed record A(int i){...}`: Since records are always final, they cannot be inherited further. Therefore, you cannot use the sealed modifier on a record. Sealed is used on classes to control inheritance.

D: `public record A(...){public int k;}`: Records cannot declare instance fields (non-static fields) other than components (variables defined in parentheses ()). `public int k;` tries to add an instance field, causing an error.

E: `record A(int i) implements B{}` and `interface B{default void i(){}}`: `record A(int i)` implicitly generates an accessor method (method to get value) named `public int i()`. Meanwhile, interface B has a method `default void i()`. When A implements B, two methods with the same name (i) but different return types (int vs void) conflict, causing a compilation error.

F: `final record A extends Record{}`: All records automatically inherit the `java.lang.Record` class without the developer needing to write it explicitly. It is grammatically prohibited for developers to explicitly write `extends Record` in the code. Also, they cannot `extends` other classes.

Re-explanation of the three codes that throw exceptions
The code fragments that throw an exception (RuntimeException) at runtime are A, B, and D.
A: `List i=List.of(new Object(),1,"2");i.add(false);i.remove(3);`
The `List.of()` method creates an unmodifiable list (immutable list). Trying to add elements like `i.add();` or `i.remove();` throws an `UnsupportedOperationException` at runtime because the list size cannot be changed.

B: `Collection i=Arrays.asList(new Object[]{new Object(), true, ' ',3});i.add(false);i.remove(3);`
The `Arrays.asList()` method creates a fixed-size list backed by the array. Similarly, attempting to add elements like `i.add();` or `i.remove();` throws an `UnsupportedOperationException` at runtime because the list size cannot be changed.

D: `List i=new ArrayList();i.add(1);i.remove(1);`
In the first two lines, list `i` contains only one element `[1]` (element 1 exists at index 0).
The argument 1 in `i.remove(1);` is interpreted as an index, not the element value. Since the list only has an element at index 0, trying to remove index 1 which does not exist throws an `IndexOutOfBoundsException` at runtime.

Code fragments that do not throw exceptions (or are compilation errors)
C: `Collection