Hard Difficulty Questions

Heap

Why wrong: Heap stores objects and arrays, not local primitives.

Native method area

Why wrong: Native area is for native method stacks.

Method area

Why wrong: Method area stores class structures, not local variables.

Compilation error: cannot apply += between int and double.

Why wrong: Compound assignment compiles.

Lossy conversion causes runtime exception.

Why wrong: No exception; value is truncated.

x is promoted to double, result is double.

Why wrong: x remains int due to cast.

Use DecimalFormat with RoundingMode.HALF_EVEN to format the output.

Why wrong: Only formats output, calculation still imprecise.

Use Math.round(total * 100) / 100.0 to round to two decimals.

Why wrong: Double rounding may still have errors.

Cast the result to float and then back to double to round.

Why wrong: Loses precision.

The default configuration logs all messages at FINEST level

Why wrong: Default level is INFO, not FINEST.

All loggers automatically forward messages to the root logger

Why wrong: Forwarding is to parent logger, not necessarily root.

Change the while(true) loop to a for loop that iterates a fixed number of times.

Why wrong: Fixed iteration does not allow infinite processing.

Add a Thread.sleep(100) inside the loop to reduce polling frequency.

Why wrong: Sleep introduces latency and may not eliminate busy-waiting.

Use a do-while loop with a Thread.yield() call to give other threads CPU time.

Why wrong: yield() may not reduce CPU usage significantly.

5.0

Why wrong: Incorrect.

5

Why wrong: Incorrect.

Runtime error

Why wrong: Compilation error.

The method returns a double[] but should return double[][].

Why wrong: Return type is correct.

The rows have different numbers of columns.

Why wrong: That is handled correctly by the inner loop.

The outer loop uses data[i].length instead of data.length.

Why wrong: Uses data.length correctly.

Java Applets

Why wrong: Applets are client-side and deprecated.

Java EE with EJB

Why wrong: EJB is a heavyweight specification, not optimal for lightweight microservices.

Java RMI

Why wrong: RMI is for remote method calls, not for REST-based microservices.

Overloading a method with different parameter lists

Why wrong: Overloading is compile-time polymorphism, but runtime polymorphism is typically emphasized.

Using static methods

Why wrong: Static methods are not polymorphic; they are resolved at compile time.

Overriding a method in a subclass

Why wrong: Overriding is part of polymorphism, but using an interface reference is a clearer demonstration of polymorphic behavior.

Using final methods

Why wrong: Final methods prevent overriding, which is not polymorphism.

Shape cannot have a constructor

Why wrong: Abstract classes can have constructors, invoked via super().

Shape s = new Shape(); is valid

Why wrong: Cannot instantiate abstract classes.

draw() must be public in Circle

Why wrong: The overriding method can have the same or broader access; not necessarily public.

int e = 10.0;

Why wrong: Incorrect: 10.0 is a double literal, and assigning to int requires a cast.

int c = 0b2;

Why wrong: Incorrect: binary literal can only contain 0 and 1; '2' is invalid.

If the method modifies elements of the array, the caller does not see the changes.

Why wrong: Changes to elements are visible to the caller because they share the same array object.

If the method assigns a new array to the parameter, the caller's variable is updated.

Why wrong: Only the local reference is changed; caller's variable still points to original array.

int x = 2.0;

Why wrong: Double cannot be assigned to int without cast.

int x = 0xG;

Why wrong: G is not hex digit.

The method is declared as final

Why wrong: Final prevents overriding, not access from other packages.

The method is not static

Why wrong: Static is unrelated to access control; the issue is class visibility.

The class is abstract

Why wrong: Abstract classes can still be public; abstract does not restrict access.

It works only with primitive types

Why wrong: Strings are allowed since Java 7, not only primitives.

It causes a compilation error because strings are not supported

Why wrong: Strings are supported in switch from Java 7 onward.

It requires a default case

Why wrong: Default case is optional.

Use modulo: if (x % 2 == 1 && y % 2 == 1) { ... }

Why wrong: Modulo works to check if both are odd, but the requirement is about bitmasking using the & operator; this changes the approach entirely.

Use bitwise OR: if (x | y == 1) { ... }

Why wrong: Bitwise OR does not check that both bits are set; it checks if at least one is set. Also, the same precedence issue applies.

Use logical AND: if (x && y == 1) { ... }

Why wrong: && is a logical operator and requires boolean operands; x is an integer, so this will not compile.

void

Why wrong: void is not a data type; it indicates no return.

String

Why wrong: String is a reference type, not primitive.

String objects can be modified after creation

Why wrong: False; Strings are immutable.

String objects can be changed by calling methods

Why wrong: False; methods return new Strings, not modify original.

Exception

Why wrong: No exception; the array indices are valid.

1

Why wrong: The original value is overwritten.

0

Why wrong: No change to 0.

String

Why wrong: Class type.

array

Why wrong: Reference type.