Advanced Java Programming Quiz

At // doStuff, two CardBoard objects are eligible for garbage collection: c1 and the object originally referenced by c1 before go() was called. The go() method sets its local parameter cb to null, but this does not affect the actual c2 object. After c1 = null, the first CardBoard object becomes eligible. c2 remains referenced.

Compilation fails because 7 is an integer literal of type int. Java does not allow implicit narrowing conversions (from int to short) during method invocation resolution. Since there is no invade(int) or invade(int...) method, the compiler cannot find a matching method signature for invade(7).

Line 7 casts o1 (which is a 2D int array) to a 1D int array. At runtime, this fails because o1 actually references int[][], not int[]. The cast compiles but throws ClassCastException at runtime. Line 4 compiles correctly because a[1] is a 1D array being cast to int[].

The call doX(s,s) passes short values. Java's most specific matching overload is doX(Integer, Integer) because short widens to int, then autoboxes to Integer (Java 5 feature). The call doX(7,7) passes int literals which autobox to Integer, matching the same overload. Output is "3 1" - wait, 7 as int matches Integer exactly, not Long.

Reference variables can exist on the stack as local variables or on the heap as instance variables. The garbage collector can be requested using System.gc() or Runtime.getRuntime().gc(). Distractors are incorrect because local variables themselves are not garbage collected, finalize is not guaranteed to run immediately before GC, and islands of isolated objects can be GCed.

Java 5 introduced autoboxing. Line 4: Long.valueOf returns Long but assigns to long - unboxing works in Java 5, not 1.4. Line 5: Long to Long assignment works in both. Line 7: longValue() returns long but assigns to Long - boxing works in Java 5, not 1.4. Line 8: parseLong returns long, assigning to Long requires boxing in Java 5 only.

Faster is an enum defined inside class Better. To reference it outside, you need the fully qualified name Better.Faster. Options C and E use correct syntax: Better.Faster is the type, and values are Better.Faster.Higher and Better.Faster.Longer. Options A, B, D are missing the outer class name.

Short is a wrapper class and inherits from Number. Options B and D are correct: s instanceof Short checks if s is a Short instance (true), and s instanceof Number checks if s is a Number instance (also true, since Short extends Number). Option A has reversed instanceof syntax. Options C, E use dot notation instead of instanceof keyword.

Java 1.3 allows assert as an identifier, so One.java compiles with -source 1.3. Java 1.4 made assert a keyword, so One.java fails with -source 1.4. Two.java uses assert as a keyword, so it compiles with -source 1.4 but fails with -source 1.3. Exactly two compilations succeed. Using -source 1.4 in Java 5+ produces a warning about obsolete source option.

m2.go() prints hi because m2's m1 is null by default. m3.go() prints hi because m3's m1 is set to m2. m4.go() prints hi because m4 is same as m3's m1. When m5.go() is called, m2.m1 is null (default value), so calling go() on null throws NullPointerException after printing hi twice.

Explanation:
Let's go through the code step by step to understand the result.

1. We have a class called "Fizz" with an instance variable "x" initialized to 5.

2. In the main method, we create two instances of the "Fizz" class - f1 and f2.

3. We then call the static method "FizzSwitch" passing f1 and f2 as arguments. In this method, we declare a final variable "z" and assign it the value of "x" (which is f1).

4. Next, we modify the value of "x" using the "z" reference. Therefore, the value of "x" in f1 is changed to 6.

5. Finally, we return the reference "z" (which is f1) and assign it to the variable "f3".

6. In the println statement, we compare if f1 and f3 are the same object reference (f1 == f3) and if their instance variable "x" is the same (f1.x == f3.x).

Now let's analyze the options:

Option A) true true - This option is correct because f1 and f3 refer to the same object, and the value of "x" in both objects is 6.

Option B) false true - This option is incorrect because f1 and f3 refer to the same object, so f1 == f3 should be true.

Option C) true false - This option is incorrect because f1 and f3 refer to the same object, so f1 == f3 should be true.

Option D) false false - This option is incorrect because f1 and f3 refer to the same object, so f1 == f3 should be true.

Option E) Compilation fails - The code does not have any compilation errors, so this option is incorrect.

Option F) An exception is thrown at runtime - The code does not have any exceptional behavior, so this option is incorrect.

The correct answer is option A) true true. This option is correct because f1 and f3 refer to the same object, and the value of "x" in both objects is 6.

Therefore, the result of the code is "true true".

The correct answer is option A.

Static field tooth (343) prints first. The final local tooth (340) shadows the static field. doIt receives 340, pre-increments to 341 (prints), pre-increments to 342 (returns, discarded). main's final tooth remains 340 (passed by value).

Line 10 attempts e2.e = el, but e2 was set to null on line 8. Accessing e2.e throws NullPointerException. Note: el is a typo (should be e1), but the null dereference happens first.

A method marked as final cannot be overridden in subclasses. The parent class Clidders declares flipper() as final, but the child class Clidlets attempts to override it with its own flipper() method. This violates Java's rules for final methods, causing a compilation error.

Private methods are not visible to subclasses and therefore cannot be overridden. The Clidder class has a private final flipper(), but since it's private, Clidlet can define its own public flipper() method without any conflict. This is not overriding but defining a new method. The code compiles and outputs 'Flip a Clidlet'.

Analyzing each fragment: F1 (f1 == f2) won't compile - comparing primitive to 2D array. F2 (f1 == f2[2][1]) compiles and compares 2.3f == 2.7f, which is false. F3 (x == f2[0][0]) compiles with unboxing, 42L == 42.0f is true. F4 (f1 == f2[1,1]) won't compile - invalid comma syntax. F5 (f3 == f2[2]) compiles but compares array references, which is false. Thus F2, F3, F5 compile (3 total), but only F3 is true (1 true).

MyInner is a static nested class. To instantiate it from outside MyOuter, we use the syntax MyOuter.MyInner m = new MyOuter.MyInner();. Option A has a typo ('Mylnner' with an 'l' instead of 'I' in the constructor call), but conceptually it represents this correct instantiation syntax.

new Foo() prints 'foo'. makeBar() instantiates an anonymous subclass of inner class Bar using new Bar() {}, which executes Bar's constructor and prints 'bar'. It then calls go() which prints 'hi', resulting in 'foobarhi'.

This code contains an infinite loop because the for loop has no initialization, condition, or increment/decrement parts - it is written as 'for(;;)' which creates an endless loop. The statement 'I am in for loop' will print continuously without termination. Options A, C, and D are incorrect because the code compiles successfully and runs indefinitely.