Generics in Java

Generics let classes, interfaces, and methods operate on a type that is specified as a parameter, rather than being hardcoded or left as raw Object. Introduced in Java 5, generics moved a whole category of bugs from runtime to compile time: without them, a collection could accept any type of object, and pulling the wrong type back out failed only when you tried to use it, often far from where the mistake was made.

Why it matters

Every collection you declare uses generics, and so do most modern Java APIs. They move a whole class of errors from runtime, where they appear as ClassCastException in production, to compile time, where they appear as a red line in the editor. Reading signatures that contain <T>, ? extends and ? super is a required skill for using the standard library and Spring.

Why Generics Prevent ClassCastException

Before generics, List stored plain Object references, so code had to cast every element retrieved from it. If the wrong type had been inserted somewhere, that cast failed at runtime with ClassCastException, often in a completely different part of the program. With List<String>, the compiler enforces at every call site that only Strings can be added, and no cast is needed on retrieval — the error is caught immediately, at compile time, instead of surfacing later as a runtime crash.

Type Erasure

Generic type information exists only at compile time; the compiler checks it, then "erases" it, replacing type parameters with Object (or their bound) in the compiled bytecode. This is why you cannot do new T[10], cannot use instanceof against a generic type parameter directly, and why List<String> and List<Integer> share exactly one .class file at runtime. Type erasure was a deliberate design choice for backward compatibility with pre-generics Java bytecode.

Bounded Type Parameters

A bounded type parameter restricts what types can be substituted. <T extends Number> means T must be Number or one of its subclasses (Integer, Double, and so on), which allows the generic code to call Number's methods (like doubleValue()) on values of type T — something plain <T> would not allow, since an unbounded T is treated as Object.

Wildcards: ? extends and ? super

Wildcards describe an unknown type in a context where you don't need to name it exactly. List<? extends Number> ("upper bounded") accepts a list of Number or any subtype, and is safe to read from (you can only add null to it, per the "Get and Put Principle"). List<? super Integer> ("lower bounded") accepts a list of Integer or any supertype, and is safe to write Integer values into. This distinction is often remembered as PECS: "Producer Extends, Consumer Super."

• <T extends Number> — bounded type parameter, restricts T to Number and its subtypes.
• List<? extends Number> — upper bounded wildcard, safe to read, unsafe to add to.
• List<? super Integer> — lower bounded wildcard, safe to write Integer into.

Example

import java.util.List;

public class GenericsDemo {

    // Bounded type parameter: T must be a Number or subtype
    static double sumAll(List<? extends Number> numbers) {
        double total = 0;
        for (Number n : numbers) {
            total += n.doubleValue(); // safe: T extends Number guarantees this method exists
        }
        return total;
    }

    static <T extends Comparable<T>> T max(T a, T b) {
        return a.compareTo(b) >= 0 ? a : b;
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        List<Double> doubles = List.of(1.5, 2.5);

        System.out.println("Sum of ints: " + sumAll(ints));
        System.out.println("Sum of doubles: " + sumAll(doubles));
        System.out.println("Max: " + max(10, 25));
    }
}

Sum of ints: 6.0
Sum of doubles: 4.0
Max: 25

Exercise

Write a generic method max that returns the largest element of a list. It should work for any type that can be compared with itself, such as Integer and String.

Expected output: 9 then pear

import java.util.List;

public class GenericMax {

    // TODO: declare a generic method max that takes a List<T> and returns a T,
    //       where T is limited to types that implement Comparable<T>

    public static void main(String[] args) {
        System.out.println(max(List.of(3, 9, 4)));
        System.out.println(max(List.of("apple", "pear", "fig")));
    }
}

import java.util.List;

public class GenericMax {

    static <T extends Comparable<T>> T max(List<T> items) {
        T best = items.get(0);
        for (T item : items) {
            if (item.compareTo(best) > 0) {
                best = item;
            }
        }
        return best;
    }

    public static void main(String[] args) {
        System.out.println(max(List.of(3, 9, 4)));                // 9
        System.out.println(max(List.of("apple", "pear", "fig"))); // pear
    }
}

Quick quiz

Interview questions