Java Generics - Generic Classes, Wildcards and Type Erasure

1. What are Generics?

Generics, introduced in Java 5, allow you to write classes, interfaces, and methods that work with any type while providing compile-time type safety. Before generics, developers used raw types — collections and containers operated on Object, requiring explicit casts everywhere.

The Problem Before Generics

// Pre-generics: raw type List stores Object
List names = new ArrayList();
names.add("Alice");
names.add("Bob");
names.add(42);          // accidentally added an Integer — no compile error!

// Explicit cast needed — fails at RUNTIME if type is wrong
String first = (String) names.get(2);  // ClassCastException at runtime!

The Solution: Generics

// With generics: compiler enforces type correctness
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
// names.add(42);  // COMPILE ERROR — Integer is not a String

String first = names.get(0);  // no cast needed, always safe

2. Generic Classes

A generic class declares one or more type parameters in angle brackets after the class name. By convention, T stands for "Type". The type parameter acts as a placeholder that gets replaced with a real type when the class is instantiated.

// Generic class with type parameter T
public class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Box[" + value + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>("Hello Generics");
        Box<Integer> intBox   = new Box<>(100);

        System.out.println(stringBox.getValue());       // no cast needed
        System.out.println(intBox.getValue() * 2);

        // stringBox.setValue(123);  // COMPILE ERROR — must be String
    }
}

3. Generic Methods

A method can declare its own type parameters, independent of any class-level type parameters. The type parameter list appears before the return type.

public class GenericUtils {

    // T is the method's own type parameter
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    // Returns the larger of two Comparable values
    public static <T extends Comparable<T>> T max(T a, T b) {
        return (a.compareTo(b) >= 0) ? a : b;
    }

    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3, 4, 5};
        String[]  strs = {"banana", "apple", "cherry"};

        printArray(nums);  // T inferred as Integer
        printArray(strs);  // T inferred as String

        System.out.println(max(10, 20));         // 20
        System.out.println(max("cat", "dog"));   // dog
    }
}

4. Generic Interfaces

Interfaces can also be parameterized with type parameters. Implementing classes either provide a concrete type or pass the type parameter through.

// Generic interface with two type parameters
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

// Concrete implementation
public class OrderedPair<K, V> implements Pair<K, V> {
    private final K key;
    private final V value;

    public OrderedPair(K key, V value) {
        this.key   = key;
        this.value = value;
    }

    @Override public K getKey()   { return key;   }
    @Override public V getValue() { return value; }

    @Override
    public String toString() {
        return "(" + key + ", " + value + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> p1 = new OrderedPair<>("Alice", 30);
        Pair<String, String>  p2 = new OrderedPair<>("country", "Java");
        System.out.println(p1);
        System.out.println(p2);
    }
}

5. Bounded Type Parameters

Bounds restrict the types that can be used as type arguments. Use extends for upper bounds (works for both classes and interfaces).

Upper Bound: <T extends Number>

Restricts T to Number or any of its subclasses (Integer, Double, etc.), allowing access to Number's methods.

public class Stats<T extends Number> {
    private T[] data;

    public Stats(T[] data) { this.data = data; }

    public double average() {
        double sum = 0;
        for (T val : data) {
            sum += val.doubleValue();  // doubleValue() is from Number
        }
        return sum / data.length;
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] ints    = {2, 4, 6, 8, 10};
        Double[]  doubles = {1.5, 2.5, 3.5};

        System.out.println(new Stats<>(ints).average());    // 6.0
        System.out.println(new Stats<>(doubles).average()); // 2.5

        // Stats<String> s = new Stats<>(...); // COMPILE ERROR
    }
}

Multiple Bounds

A type parameter can have multiple bounds using &. The class bound (if any) must come first.

// T must extend Comparable AND implement Serializable
public <T extends Comparable<T> & java.io.Serializable> T clamp(T val, T min, T max) {
    if (val.compareTo(min) < 0) return min;
    if (val.compareTo(max) > 0) return max;
    return val;
}

6. Wildcards

The wildcard ? represents an unknown type. It is used in method parameters (not class declarations) to increase flexibility when you need to accept a range of parameterized types.

Unbounded Wildcard

public static void printList(List<?> list) {
    for (Object item : list) {
        System.out.print(item + " ");
    }
    System.out.println();
}

printList(List.of(1, 2, 3));
printList(List.of("a", "b", "c"));

Upper Bounded Wildcard

// Accepts List<Integer>, List<Double>, List<Number>, etc.
public static double sumOfList(List<? extends Number> list) {
    double sum = 0;
    for (Number n : list) sum += n.doubleValue();
    return sum;
}

System.out.println(sumOfList(List.of(1, 2, 3)));          // 6.0
System.out.println(sumOfList(List.of(1.5, 2.5, 3.0)));    // 7.0

Lower Bounded Wildcard

// Accepts List<Integer>, List<Number>, List<Object>
public static void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 5; i++) list.add(i);
}

List<Number> numbers = new ArrayList<>();
addNumbers(numbers);
System.out.println(numbers);

7. Type Erasure

Java generics are a compile-time mechanism only. The Java compiler uses type information to perform type checks and insert casts, then erases all type parameters from the bytecode. At runtime, a List<String> and a List<Integer> are both just List.

// Source code (what you write)
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);

// After type erasure (what the JVM sees)
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);  // compiler inserts this cast

Implications of type erasure:

• You cannot use instanceof with a parameterized type: obj instanceof List<String> is a compile error.
• You cannot create instances of a type parameter: new T() is not allowed.
• You cannot create generic arrays: new T[10] is not allowed directly.
• Static fields of a generic class cannot use the type parameter.

// This is legal — checks erased type
if (list instanceof List<?>) { ... }

// This is NOT legal — type erased at runtime
// if (list instanceof List<String>) { ... }  // COMPILE ERROR

8. Generic Collections

The Java Collections Framework was retrofitted with generics in Java 5. Always use parameterized collections — never use raw types in new code.

import java.util.*;

public class GenericCollections {
    public static void main(String[] args) {
        // Typed List — compiler prevents adding wrong types
        List<String> languages = new ArrayList<>();
        languages.add("Java");
        languages.add("Kotlin");
        languages.add("Scala");
        // languages.add(42);  // COMPILE ERROR

        for (String lang : languages) {
            System.out.println(lang.toUpperCase());  // no cast needed
        }

        // Typed Map
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 95);
        scores.put("Bob", 87);

        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

9. Multiple Type Parameters

A generic class or method can declare multiple type parameters, separated by commas. The standard library's Map.Entry<K, V> is a classic example.

// Generic Pair class with two type parameters
public class Pair<K, V> {
    private final K key;
    private final V value;

    public Pair(K key, V value) {
        this.key   = key;
        this.value = value;
    }

    public K getKey()   { return key;   }
    public V getValue() { return value; }

    public static <K, V> Pair<K, V> of(K k, V v) {
        return new Pair<>(k, v);
    }

    @Override
    public String toString() {
        return key + " -> " + value;
    }
}

public class Main {
    public static void main(String[] args) {
        Pair<String, Integer>  nameAge   = Pair.of("Alice", 30);
        Pair<String, Boolean>  feature   = Pair.of("darkMode", true);
        Pair<Integer, Double>  ratio     = Pair.of(1, 1.618);

        System.out.println(nameAge);
        System.out.println(feature);
        System.out.println(ratio);

        // Map.Entry is Java's built-in two-parameter generic
        Map<String, List<Integer>> groupedScores = new HashMap<>();
        groupedScores.put("math", List.of(90, 85, 92));
        for (Map.Entry<String, List<Integer>> e : groupedScores.entrySet()) {
            System.out.println(e.getKey() + ": " + e.getValue());
        }
    }
}

10. Common Conventions

Java uses single uppercase letters as type parameter names by convention. Following these conventions makes generic code instantly recognizable to other Java developers.

// Convention examples from the standard library
interface Comparable<T>          // T = Type
interface Collection<E>          // E = Element
interface Map<K, V>              // K = Key, V = Value
interface Function<T, R>         // T = input Type, R = Return type
interface BiFunction<T, U, R>    // T, U = inputs, R = return