Select Two (Multi-Select) Questions

Interfaces can be instantiated.

Why wrong: Interfaces cannot be instantiated.

Interfaces can contain constructors.

Why wrong: Interfaces cannot have constructors.

Interfaces cannot have default methods.

Why wrong: Default methods are allowed since Java 8.

The continue statement can be used to exit a loop entirely.

Why wrong: continue does not exit; it skips iteration.

The break statement cannot be used outside a loop.

Why wrong: break can be used in switch outside loop.

a == b

Why wrong: 5==10 false.

a >= b

Why wrong: 5>=10 false.

The method can reassign the original array variable to a new array.

Why wrong: Only the copy of the reference is changed.

The method must return the array to reflect any changes.

Why wrong: Changes to elements are visible without returning.

The method cannot determine the size of the array.

Why wrong: The length field is accessible.

Overloaded methods must have the same number of parameters.

Why wrong: They can have different numbers.

Overloaded methods must have different return types.

Why wrong: Return type is not used for overloading.

Overloaded methods can have different names.

Why wrong: Must have the same name.

A try block must be followed by either a catch or finally.

Why wrong: Try can be followed by catch and/or finally, but finally is optional if catch is present.

The finally block executes only if an exception is thrown.

Why wrong: Finally executes whether exception occurs or not.

The finally block cannot contain a return statement.

Why wrong: It can contain a return; but it is not recommended.

ArrayIndexOutOfBoundsException

Why wrong: It is a RuntimeException (unchecked).

NullPointerException

Why wrong: It is a RuntimeException (unchecked).

class

Why wrong: Invalid. Reserved word.

2ndValue

Why wrong: Invalid. Starts with digit.

my-var

Why wrong: Invalid. Hyphen not allowed.

When an array is passed to a method, changes to the array elements inside the method are not reflected in the caller.

Why wrong: Changes to array elements modify the same array object, so they are reflected.

When an array is reassigned inside a method, the original array in the caller is also reassigned.

Why wrong: Reassigning the parameter only changes the local reference, not the caller's reference.

When a String is passed to a method, the method can modify the original String.

Why wrong: Strings are immutable; any modification creates a new String object.

The size of an array can change after creation.

Why wrong: Arrays have a fixed length; cannot be resized.

The length of an array must be specified at compile time with a constant expression.

Why wrong: Length can be specified with a variable (e.g., new int[n]), determined at runtime.

public void reset(int[] a) { a = new int[10]; }

Why wrong: Creates a new array local to the method; original unchanged.

public void swap(int[] a) { int[] temp = a; a = new int[1]; a[0] = temp[0]; }

Why wrong: Reassigns the reference; original array unchanged.

public void setFirst(int[][] a) { a = new int[1][1]; a[0][0] = 5; }

Why wrong: Reassigns the reference, not modifying original.

int[] arr = new int[5]{1, 2, 3, 4, 5};

Why wrong: You cannot specify both the size and the initializer; the size is inferred from the initializer.

int[5] arr;

Why wrong: Invalid syntax; the size cannot be specified on the left side of the variable.

int arr = new int[5];

Why wrong: The variable type must be int[] (array), not int.

Passing an array is the same as passing each element individually.

Why wrong: Passing an array passes a reference; passing each element individually would create copies of element values.

The method can change the size of the original array.

Why wrong: Array size is immutable once created; the method cannot change it.

If the method assigns a new array to the parameter, the original reference is updated outside the method.

Why wrong: Assigning a new array to the parameter only changes the local copy of the reference; the caller's reference remains unchanged.

The Arrays class provides a method to sort only arrays of primitive types.

Why wrong: sort() works on both primitive and object arrays.

The Arrays class provides a method to perform binary search on any array.

Why wrong: binarySearch requires a sorted array; 'any array' is not accurate.

The Arrays class provides a method to deep copy an array.

Why wrong: Arrays.copyOf() performs shallow copy, not deep copy.

A custom exception class must directly extend Throwable.

Why wrong: Custom exceptions typically extend Exception or RuntimeException, which indirectly extend Throwable.

A custom exception cannot have constructors that call super.

Why wrong: Custom exceptions commonly have constructors that call super() with a message or cause.

class

Why wrong: 'class' is a reserved keyword.

my-var

Why wrong: Hyphen is not allowed in identifiers.

2ndVar

Why wrong: Cannot start with a digit.

2ndValue

Why wrong: Cannot start with digit.

my-var

Why wrong: Hyphen is not allowed.

long

Why wrong: long is not allowed; only int and smaller integer types.

boolean

Why wrong: boolean is not allowed in switch.

break can be used without any enclosing loop

Why wrong: break must be inside a loop or switch statement.

break is used to skip to next iteration

Why wrong: continue is used to skip to the next iteration.

break exits the current loop iteration

Why wrong: break exits the entire loop, not just the current iteration.

The break statement is mandatory at the end of each case.

Why wrong: Break is optional; fall-through is possible.

Case labels can be runtime expressions.

Why wrong: Case labels must be compile-time constants.

It can be used with long variables.

Why wrong: long is not allowed in switch.