Understanding Java Generics: Type Erasure, Bridge Methods, and Practical Examples

The author notes that the article was written while on a business trip with a hot laptop keyboard, and that the code formatting has been corrected.

Most programming languages support generics, a language mechanism that allows types to be parameterized. In Java, generics are essential for developers, especially beginners, as they introduce a new level of abstraction beyond basic syntax.

What Is a Generic?

In Java, generics are represented by the <> symbols. A generic type does not have a fixed concrete type; it can be Integer , Long , or any user‑defined class.

Generics enable classes and interfaces to become parameters when defining them. Similar to method parameters, type parameters let you reuse the same code with different inputs, but the inputs are types rather than values.

For example, the most common generic class in the Java Collections Framework is ArrayList :

public class ArrayList
extends AbstractList
implements List
, RandomAccess, Cloneable, java.io.Serializable {
    // ...code
}

A more complex example shows a method with multiple generic type parameters:

public static <T extends Number & Comparable<T>, U extends List<T>, R extends T> R complexMethod(U list, T element) {
    // implementation
}

In this example, the method receives two parameters U list and T element , and the return type is declared as <T extends Number & Comparable<T>, U extends List<T>, R extends T> .

Why Use T, U, R, etc.?

Common generic type names follow a convention:

E – element (e.g., collection element)

K – key (used in key‑value pairs)

V – value (used in key‑value pairs)

N – number

T – type (the most frequently used)

Benefits of Generics

1. Compile‑time type checking: the compiler can detect type‑safety violations before runtime.

2. Reusable algorithms: developers can write generic algorithms that work with any compatible type while remaining type‑safe and readable.

3. Eliminate unnecessary casts. For instance, a method that compares two Number objects can be written as:

public static <T extends Number> Boolean compare(T first, T second) {
    double firstValue = first.doubleValue();
    double secondValue = second.doubleValue();
    return firstValue > secondValue;
}

Without generics, you would need explicit casts:

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

With generics, the cast is unnecessary:

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);

Type Erasure

Java implements generics through type erasure: generic type information exists only at compile time and is replaced with Object (or the first bound) in the generated bytecode.

During compilation, the compiler replaces each type parameter with its first bound if it is bounded, otherwise with Object .

Example of a bounded type parameter:

interface Displayable {
    void display();
}

public class Result<T extends Number & Displayable> {
    private T value;
    public Result(T value) { this.value = value; }
    public T getValue() { return value; }
    public void show() { value.display(); }
}

After erasure, it becomes:

public class Result {
    private Number value;
    public Result(Number value) { this.value = value; }
    public Number getValue() { return value; }
}

For an unbounded type parameter:

public static <T> int count(T[] anArray, T elem) {
    int cnt = 0;
    for (T e : anArray)
        if (e.equals(elem)) ++cnt;
    return cnt;
}

After erasure:

public static int count(Object[] anArray, Object elem) {
    int cnt = 0;
    for (Object e : anArray)
        if (e.equals(elem)) ++cnt;
    return cnt;
}

Bridge Methods

Consider the following generic class hierarchy:

public class Node<T> {
    public T data;
    public Node(T data) { this.data = data; }
    public void setData(T data) { this.data = data; }
}

public class SubNode extends Node
{
    public SubNode(Integer data) { super(data); }
    public void setData(Integer data) { super.setData(data); }
    public static void main(String[] args) {
        SubNode subNode = new SubNode(8);
        Node node = subNode;
        node.setData("Hello"); // Compiles, throws ClassCastException at runtime
        Integer x = subNode.data;
    }
}

After type erasure, the compiler generates a bridge method in SubNode to preserve polymorphic behavior:

public class Node {
    public Object data;
    public Node(Object data) { this.data = data; }
    public void setData(Object data) { this.data = data; }
}

public class SubNode extends Node {
    public SubNode(Integer data) { super(data); }
    /** Bridge method */
    public void setData(Object data) { setData((Integer) data); }
    public void setData(Integer data) { super.setData(data); }
}

The bridge method casts the Object argument back to Integer , which causes the ClassCastException when node.setData("Hello") is invoked.

Conclusion

Type erasure enables Java to support generics while keeping backward compatibility, allowing developers to write type‑safe, reusable code without sacrificing runtime performance.