Generics: interview questions & scenarios

Model answer

Generics let you express type relationships that javac can check. List<String> says this list is meant to contain strings, so list.add(42) is rejected where the bug is written instead of failing later when somebody reads the value as a String.

Raw types are the old pre-Java 5 form: List instead of List<String>. Java keeps them for migration compatibility, but a raw type turns off generic checking for that use and produces unchecked warnings. The warning matters because heap pollution can sit quietly inside a collection until a compiler-inserted cast fails on a later read.

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addWrong(List raw) {
        raw.add(404);                    // unchecked warning with -Xlint:unchecked
    }

    public static void main(String[] args) {
        List<String> statuses = new ArrayList<>();
        statuses.add("PAID");
        addWrong(statuses);

        for (String status : statuses) { // ClassCastException on 404
            System.out.println(status.toLowerCase());
        }
    }
}

Prefer List<?> when the element type is unknown but you still want type checking. Use raw types only at old API boundaries, and keep any @SuppressWarnings("unchecked") as narrow as possible.

Model answer

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> ints = new ArrayList<>(List.of(1, 2));
        // List<Number> numbers = ints;       // compile-time error
        List<? extends Number> readable = ints;
        System.out.println(readable.get(0));

        String[] strings = {"paid"};
        Object[] objects = strings;
        try {
            objects[0] = 42;
        } catch (ArrayStoreException ex) {
            System.out.println(ex.getClass().getSimpleName());
        }
    }
}

It prints:

1
ArrayStoreException

Generic types are invariant. If Java allowed List<Integer> to be assigned to List<Number>, the List<Number> reference could add a Double, corrupting a list that promised integers. Java rejects that at compile time.

Arrays are covariant for older language reasons. A String[] can be viewed as an Object[], but the array keeps its runtime component type. When you store an Integer, the runtime checks the component type and throws ArrayStoreException.