All Java

1. A method only ever WRITES elements into a `List<T>` parameter and never reads from it. According to PECS, which wildcard form should it use?

List<?> -- an unbounded wildcard, since the method never reads.

List<T> with no wildcard at all, since PECS never applies to write-only parameters.

List<? super T> -- it's a consumer, so super applies.

List<? extends T> -- it's a producer, so extends applies.

2. What will happen if you try to access an index that is out of bounds in an array?

It will return null.

It will throw an ArrayIndexOutOfBoundsException.

It will silently return a default value.

It will print an error message to the console.

3. According to the lesson, which type is the best fit for storing a timestamp (like "when did this event happen") in a database?

Instant (or a fixed-offset OffsetDateTime) -- it represents one unambiguous universal moment, independent of any time zone.

LocalDateTime, since it's the most commonly used java.time class.

ZonedDateTime, since it already carries a time zone.

Date, since it's guaranteed to be timezone-agnostic.

4. What does this print?

import java.util.Optional;

public class Demo {
    public static void main(String[] args) {
        Optional<Integer> num = Optional.of(4);
        Optional<Integer> filtered = num.filter(n -> n > 10);
        System.out.println(filtered.isPresent());
    }
}

It throws NoSuchElementException.

Compile error.

false

true

5. A method is written as `static T firstElement(List<T> list) { ... }`, without a `<T>` before the return type. What is the result?

It compiles, treating T as an alias for Object.

It compiles but throws an exception on the first call.

It fails to compile -- T is undeclared, since the <T> before the return type was omitted.

It compiles and behaves identically to static <T> T firstElement(List<T> list).

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

Integer a = 100; Integer b = 100; System.out.println(a == b);

true

false

NullPointerException

100

7. According to this lesson, why does `java.util.Stack`'s own javadoc recommend using `Deque`/`ArrayDeque` instead?

Because Stack extends Vector, inheriting unnecessary synchronization overhead and index-based methods that don't fit a stack.

Because Stack cannot be used with generics.

Because Stack doesn't support push()/pop() at all.

Because Stack has been formally deprecated and no longer compiles.

8. If a subclass constructor never explicitly calls `super(...)`, what does the compiler do?

It implicitly calls the superclass's no-argument constructor as the first statement.

It leaves the superclass completely uninitialized.

It calls the subclass's own no-argument constructor instead.

It causes a compile error in every case.

9. What will this code print?

LocalDate d1 = LocalDate.of(2026, 1, 31);
LocalDate d2 = d1.plusDays(1);
System.out.println(d1);

2026-01-31

2026-02-01

null

It throws an exception.

10. What does this print?

import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);
        System.out.println(nums.stream().allMatch(n -> n % 2 == 0));
        System.out.println(nums.stream().anyMatch(n -> n > 7));
        System.out.println(nums.stream().noneMatch(n -> n < 0));
    }
}

true true true

true false true

false true true

true true false

11. What are the two direct subclasses of `Throwable`?

Error and RuntimeException

CheckedException and UncheckedException

Exception and RuntimeException

Error and Exception

12. 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.

13. Which call to `toArray()` on a `List<String>` correctly produces a `String[]` rather than an `Object[]`?

list.toArray(new String[0])

list.toArray()

(String[]) list.toArray()

list.toArray(Object.class)

14. 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.

15. Why should you avoid persisting the ordinal() value as permanent data in a database?

Because ordinal() is only valid within the same JVM session.

Because ordinal() throws an exception when persisted.

Because ordinal() is not Serializable.

If the order of constants changes or a new constant is inserted, ordinal values silently shift, corrupting the meaning of previously stored data.

16. What access modifier can an enum constructor have?

Only private or package-private (default).

public

protected

public or protected, depending on the use case.

17. Which statement correctly distinguishes compile-time polymorphism from runtime polymorphism?

Compile-time polymorphism (overloading) is resolved by argument types at compile time; runtime polymorphism (overriding) is resolved by the object's actual type at runtime.

Compile-time polymorphism is resolved by the object's actual type; runtime polymorphism is resolved by argument types.

Both are resolved entirely at runtime, just through different mechanisms.

Both are resolved entirely at compile time, just through different mechanisms.

18. Which statement correctly distinguishes `Consumer<T>` from `Supplier<T>`?

Consumer's accept(T) takes a value and performs a side effect, returning nothing; Supplier's get() takes no input and produces a value.

Consumer produces a value with no input; Supplier takes a value and performs a side effect.

Both take a value and return a transformed value.

Consumer and Supplier are interchangeable, differing only in name.

19. A method accepts a `List<?>` parameter and calls `.size()` on it, then tries `.add("new element")` on the same parameter. What happens?

The add(...) call fails to compile, since the compiler has no way to know the list's real element type.

Both calls compile -- List<?> behaves exactly like List<Object> for writing.

Both calls fail to compile, since size() also requires a known element type.

The add(...) call compiles but silently does nothing at runtime.

20. What does this print?

Map<String, Integer> map = new TreeMap<>();
map.put("banana", 2);
map.put("apple", 1);
map.put("cherry", 3);
System.out.println(map.keySet());

[cherry, banana, apple]

An unpredictable order that can vary between runs.

[apple, banana, cherry]

[banana, apple, cherry]

Test Your Knowledge