Generics in Java

Before Java 5, collections stored everything as Object. You could put any type into any collection — but when you took something out, you had to cast it yourself. One wrong cast meant a crash at runtime.

Generics solve this by letting you declare what type a collection holds. The compiler checks types at compile time, so mistakes are caught before the program even runs.

The Problem Without Generics

Run this example to see its output.

The compiler shows no error. The program compiles. It crashes at runtime when it tries to cast 42 to String.

With Generics — Type Safety at Compile Time

Run this example to see its output.

Line by line:

• List<String> — the <String> is the type parameter. It tells Java: this list holds only Strings.
• names.add(42) — compile error immediately. No chance of a runtime crash.
• name.toUpperCase() — no cast needed. Java already knows name is a String.

The type parameter is like a placeholder. List<String> means "a List where E = String everywhere."

Generic Class

You can write your own generic class using a type parameter name (conventionally T):

Run this example to see its output.

Line by line:

• class Box<T> — T is a placeholder for any type.
• private T value; — the field's type is whatever T turns out to be.
• Box<String> — T becomes String. getValue() returns String.
• Box<Integer> — T becomes Integer. getValue() returns Integer.
• Primitives (int, double) cannot be type parameters — use wrapper classes (Integer, Double).

Generic Method

A method can have its own type parameter, independent of the class:

Run this example to see its output.

<T> before the return type declares T as this method's type parameter. Java infers the actual type from what you pass.

Bounded Type Parameters

Sometimes you want T to be only a specific kind of type — a Number, or a Comparable. Use extends to set an upper bound:

Run this example to see its output.

<T extends Number> means T can be Integer, Double, Long, Float — any subclass of Number. This lets the method call element.doubleValue() which all Numbers support.

Wildcards — ?

A wildcard ? means "any type." Used when reading from a collection when you do not care about the exact type.

Run this example to see its output.

List<? extends Number> means "a list of Number or any subclass" — List<Integer>, List<Double> etc. You can read from it but not add to it (because the exact type is unknown).

Common Mistake 1: Using Raw Types

Always specify the type parameter. Raw types exist only for backward compatibility.

Common Mistake 2: Using Primitives as Type Parameters

Common Mistake 3: Assuming Generic Type Is Available at Runtime

Java erases type parameters at runtime (type erasure). At runtime, List<String> and List<Integer> are both just List. This means:

You cannot do if (list instanceof List<String>) at runtime. The <String> is gone. This is fine for most use cases, but important to know for advanced reflection.

Practice Task

Task: Write a generic class Pair<A, B> that holds two values of potentially different types. It should have:

• A constructor Pair(A first, B second)
• Getters getFirst() and getSecond()
• A toString() that returns (first, second)

In main, create:

1. Pair<String, Integer> for a name and age
2. Pair<Integer, Boolean> for a roll number and pass/fail status

Also write a generic method swap(Pair<A, B> pair) that returns a new Pair<B, A> with values swapped.

Hint: The swap method return type is Pair<B, A>. Create new Pair<>(pair.getSecond(), pair.getFirst()).

Solution:

Run this example to see its output.

What to observe: Pair<String, Integer> and Pair<Integer, String> are treated as completely different types by the compiler. Trying to assign one to the other gives a compile error. swap() creates a genuinely different typed pair — not just swapping field values in place.