Java Generics: Type-Safe Classes and Methods

Why Generics Exist

A generic type lets you write code once and reuse it for many types without giving up type safety. Instead of writing a separate IntBox, StringBox, and UserBox, you write one Box<T> where T is a placeholder the caller fills in.

You have already used generics every time you wrote ArrayList<String> or a HashMap like HashMap<String, Integer>. The <...> part is a type argument. This page shows how to write your own.

The alternative - storing everything as Object - throws away type information and forces ugly, error-prone casts:

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

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // nothing stops this mistake

        String first = (String) raw.get(0); // every read needs a cast
        String oops = (String) raw.get(1);  // compiles, then crashes at runtime
        System.out.println(first + " " + oops);
    }
}

That cast on the last line throws a ClassCastException at runtime - the kind of exception generics are designed to make impossible.

A Generic Class

Declare a type parameter in angle brackets after the class name. By convention it is a single uppercase letter: T for "type", E for "element", K/V for key/value.

class Box<T> {
    private T value;

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

    T get() { return value; }
    void set(T value) { this.value = value; }
}

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // no cast - the compiler knows it's a String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // won't compile - Box<String> only accepts Strings
    }
}

Inside Box, every T becomes whatever the caller supplied. Box<String> is a box that only holds and returns String. The compiler rejects name.set(99) before the program ever runs.

The empty <> on the right (the diamond operator) lets the compiler infer the type argument from the left side, so you don't repeat <String> twice.

Generic Methods

A single method can have its own type parameter, independent of the class. Put the parameter <T> before the return type:

import java.util.List;

public class Main {

    // <T> declares the type parameter; T is the element type
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // T inferred as String
        Integer n = firstOrNull(nums);   // T inferred as Integer
        System.out.println(w + " " + n);
    }
}

You never pass T explicitly - the compiler infers it from the argument. Generic methods are how utilities like Collections.sort or List.of stay type-safe across any element type.

Bounded Type Parameters

Sometimes a generic type only makes sense for some types. extends constrains the parameter so you can call methods of the bound. Here T extends Number means T is Number or any subclass (Integer, Double, ...), so doubleValue() is available:

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // legal because T is at least a Number
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

Note that extends here means "is a subtype of", and it works for both classes and interfaces - <T extends Comparable<T>> is extremely common when you need to compare elements.

Wildcards: ? extends and ? super

A subtle gotcha: List<Integer> is not a List<Number>, even though Integer is a Number. Generics are invariant. Wildcards relax this when you only need to read or only need to write.

Use ? extends T for a producer you read from, and ? super T for a consumer you write to (the "PECS" rule - Producer Extends, Consumer Super):

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

public class Main {

    // reads Numbers out - accepts List<Integer>, List<Double>, etc.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // writes Integers in - accepts List<Integer>, List<Number>, List<Object>
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // works thanks to ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // works thanks to ? super
        System.out.println(bucket);
    }
}

A ? extends Number list lets you read elements as Number but not add to it (the compiler can't know the exact element type). A ? super Integer list lets you add Integers but reads come back as Object. Pick the wildcard that matches how the data flows.

Type Erasure and Its Limits

Generics are a compile-time feature. After compilation the type parameter is erased - at runtime Box<String> and Box<Integer> are both just Box. This keeps generics backward-compatible with old code, but it imposes real limits.

// None of these compile - the type parameter doesn't exist at runtime:
T value = new T();          // can't instantiate a type parameter
T[] array = new T[10];      // can't create a generic array
if (list instanceof List<String>) { } // can't test the type argument

Because the type is gone at runtime, you cannot ask "what was T?" through reflection, and you cannot overload methods that differ only by their generic argument (foo(List<String>) and foo(List<Integer>) erase to the same signature). When you genuinely need the type at runtime, pass a Class<T> token as a constructor or method parameter.

Next: Lambda Expressions

You saw that a generic method takes a type as a parameter. The next step is treating behavior as a parameter. Lambda expressions let you pass a chunk of code - a function - into a method, which is exactly how you'll sort, filter, and transform the generic collections you just learned to type safely.