Understanding Java Generics: History, Features, and the PECS Principle

Background

Before generics, Java code had to use Object and explicit casts, which was unsafe. Arrays were covariant, adding further runtime risks. Java 5 introduced generics to provide compile‑time type safety while preserving backward compatibility, which imposed certain restrictions.

Advantages of Generics

Improved readability

Compile‑time type safety

Raw‑type Example

import java.util.ArrayList;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // forced cast
        String res = (String) list.get(0);
        // unsafe operation
        list.add(new Date());
    }
}

Because the compiler cannot check element types, a ClassCastException may occur at runtime.

Type Parameters

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> objects = new ArrayList<>();
        objects.add("Hello");
        // compile‑time error for incompatible type
        // objects.add(new Date());
    }
}

The compiler enforces that only String values can be added and get() returns a String without a cast.

Generic Class

public class Animal<T> {
    private String name;
    private T mouth;
    public T getMouth() { return mouth; }
}

A generic class can declare multiple type variables:

public class Animal<T, U> {
    private String name;
    private T mouth;
    private U eyes;
    public T getMouth() { return mouth; }
}

Generic Method

public class Animal<T, U> {
    private T value;
    public static <T> T get(T... a) { return a[a.length - 1]; }
    public T getFirst() { return value; }
}

Type Erasure

The JVM does not retain generic type information. After compilation, all type parameters are replaced by their upper bounds (or Object if unbounded), producing raw types in the bytecode. This design maintains compatibility with pre‑generic class files.

Consequences of erasure:

Type parameters cannot be primitive types.

Runtime type checks can only be performed on raw types.

Generic arrays cannot be instantiated because they would become Object[], leading to unsafe casts.

Compiler‑Inserted Casts

public class Main {
    public static void main(String[] args) {
        Animal<Integer, Double> pair = new Animal<>();
        Integer first = pair.getFirst(); // compiler inserts cast from Object to Integer
    }
}

The compiler inserts a cast after erasure to preserve the declared generic type.

Bridge Methods

When a generic superclass method is overridden, the compiler generates a bridge method in the subclass that delegates to the original method, preserving polymorphism despite erasure. This also applies when a subclass overrides a method with a covariant return type.

Summary of Core Points

The JVM has no generic types, only ordinary classes and methods.

All type parameters are replaced by their bounded types.

Bridge methods are synthesized to maintain overriding.

When necessary, the compiler inserts casts to preserve type safety.

Variance and Arrays

Three variance rules:

Covariance : f(Dog) is a subtype of f(Animal).

Contravariance : f(Dog) is a supertype of f(Animal).

Invariance : no subtype relationship.

Generics are invariant by default to ensure type safety, whereas arrays are covariant, which can cause ArrayStoreException at runtime (as noted in *Effective Java*).

PECS Principle

To enable covariance, use an upper‑bounded wildcard ? extends T (read‑only). To enable contravariance, use a lower‑bounded wildcard ? super T (write‑only). The mnemonic “Producer extends, Consumer super” guides the choice.

List<? extends Car> electricVehicles = ...; // read‑only
List<? super Car> dieselVehicles = ...; // write‑only

Only the add method uses the generic type parameter; methods such as contains and remove remain non‑generic to avoid compile‑time errors after applying an upper bound.

PECS in Practice

The Collections.copy method demonstrates PECS: the source list is a producer ( ? extends E) and the destination list is a consumer ( ? super E).

Collections.copy(dest, src); // dest: ? super E, src: ? extends E

Illustrative Images

Type erasure illustration: