All Java

1. What does this print?

class Employee {
    String describe() { return "Employee"; }
}

class Manager extends Employee {
    String describe() { return super.describe() + " + Manager"; }
}

public class Demo {
    public static void main(String[] args) {
        System.out.println(new Manager().describe());
    }
}

Employee + Manager

Manager

Employee

Compile error -- super.describe() can't be called from an overriding method.

2. Which of the following lambda expressions fails to compile?

`a, b -> a + b`

`(a, b) -> a + b`

`x -> x * 2`

`() -> 42`

3. Why does extending `Throwable` directly (instead of `Exception` or `RuntimeException`) count as a common mistake?

It makes the exception automatically checked.

It prevents the exception from carrying a message.

Throwable cannot be extended at all.

It bypasses the checked/unchecked distinction entirely, and is almost never what you actually want.

4. What does this print?

import java.util.OptionalDouble;
import java.util.stream.IntStream;

public class Demo {
    public static void main(String[] args) {
        IntStream empty = IntStream.of();
        System.out.println(empty.sum());
        OptionalDouble avg = IntStream.of().average();
        System.out.println(avg.isPresent());
    }
}

0 true

It throws NoSuchElementException on sum().

0 false

Compile error -- IntStream.of() needs at least one argument.

5. Where does a generic method's type parameter appear in its declaration?

In angle brackets, right before the return type.

In angle brackets, right after the method name.

It must match a type parameter already declared on the enclosing class.

At the end of the parameter list, after the last parameter.

6. What happens when this code is compiled?

interface Greeter {
    void greet();
}

class QuietGreeter implements Greeter {
    protected void greet() { System.out.println("hi"); }
}

It fails to compile -- an overriding method can never be less accessible than the interface method it implements.

It compiles and prints "hi".

It compiles but throws IllegalAccessException at runtime.

It compiles because protected is a stricter, more valid choice for an interface method.

7. What does this print?

List<Integer> list = new ArrayList<>(List.of(10, 20, 30, 40));
list.remove(2);
System.out.println(list);

[10, 20, 40]

[10, 20, 30, 40]

Compile error -- the call is ambiguous.

[20, 30, 40]

8. What does this print?

import java.util.function.Predicate;

public class Demo {
    public static void main(String[] args) {
        Predicate<String> isLong = s -> s.length() > 3;
        Predicate<String> startsWithA = s -> s.startsWith("A");
        Predicate<String> combined = isLong.and(startsWithA);
        System.out.println(combined.test("Anna"));
        System.out.println(combined.test("Al"));
    }
}

true false

false true

true true

false false

9. Which class is recommended for building strings piece by piece in a loop?

String

StringBuffer

StringBuilder

StringJoiner

10. Why can a broad `catch (Exception e)` block that does nothing meaningful be dangerous?

It prevents the program from compiling.

It automatically rethrows the exception after logging it.

It silently swallows every checked and unchecked exception, making debugging nearly impossible.

It also swallows every Error, since Exception includes Error.

11. Which of the following are best practices when working with arrays?

Always use Arrays.toString() to print an array's contents.

Use == to compare two arrays for equality.

Use Arrays.equals() to compare two arrays' contents.

Print an array directly with System.out.println().

12. What happens when this code is compiled?

class NumericBox<T extends Number> {
    private T value;
    void set(T value) { this.value = value; }
}

public class Demo {
    public static void main(String[] args) {
        NumericBox<String> box = new NumericBox<>();
    }
}

It fails to compile -- String doesn't satisfy the bound T extends Number.

It compiles because NumericBox never actually stores anything.

It compiles but throws ClassCastException when set(...) is called.

It compiles, treating String as a boxed numeric type.

13. What will be the output of the following code?

Scanner scanner = new Scanner(System.in);
int number = scanner.nextInt();
String line = scanner.nextLine();
System.out.println(line);

The integer value entered

An empty string

A prompt for the next input

An error message

14. What does the Path.of(...) method do?

Creates a new file at the given location

Checks if a file exists at the given location

Reads a file at the given location

Creates an object that represents a file location

15. What exception might be thrown when using Scanner to read from a file?

NoSuchElementException

InputMismatchException

FileNotFoundException

IOException

16. What is the relationship between `UnaryOperator<T>` and `Function<T, T>`?

Function<T, T> extends UnaryOperator<T>.

UnaryOperator<T> can only be used with primitive types, never with objects.

UnaryOperator<T> extends Function<T, T> -- it exists purely for readability, to express that input and output share the same type.

UnaryOperator<T> is a completely unrelated interface with a different abstract method signature.

17. What does this print?

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Demo {
    public static void main(String[] args) {
        List<Integer> list = IntStream.rangeClosed(1, 3)
                .boxed()
                .collect(Collectors.toList());
        System.out.println(list);
    }
}

[1, 2, 3]

Compile error -- IntStream can't be collected into a List<Integer>.

[1, 2, 3, 4]

6

18. What type does `scores` have in `var scores = List.of(90, 85, 78);`?

var itself, a genuinely untyped variable that accepts any assignment later.

List<int[]>, since var treats numeric literals as an array.

List<Integer>, deduced entirely from List.of(...)'s arguments.

List<Object>, since var always widens to the most general type.

19. A `List<String>` is declared, and code tries to call `.add(42)` on it. Which of the following are true? (Select all that apply)

The call compiles, and the mistake would only surface later as a ClassCastException.

add() on any generic collection always accepts a plain Object regardless of the declared type argument.

The call fails to compile, since 42 doesn't match the element type String.

This is exactly the kind of mistake generics are designed to catch at compile time.

20. By default, what happens if you call Files.writeString(path, content) on a file that already exists?

The new content is appended to the end of the existing content.

The file's entire existing content is overwritten with the new content.

An exception is thrown because the file already exists.

The call is ignored and the original content is preserved.

Test Your Knowledge