الفئات العامة

Written Explanation

From Object to a type parameter

Here is the pre-generics way to write a box that holds one value:

class Box {
    private Object value;
    Box(Object value) { this.value = value; }
    Object get() { return value; }
}

Anything fits, and every reader needs a cast. The generic version adds one thing: a type parameter after the class name.

public class Box<T> {
    private T value;

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

    public T get() {
        return value;
    }

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

<T> declares T as a placeholder for a type. Inside the class, T is used where a type is expected: a field, a constructor parameter, a method parameter, a return type. Nobody knows yet what T will be. The user of the class decides.

Using it: type arguments

Box<String> b = new Box<>("hi");
String s = b.get();          // no cast
Box<Integer> n = new Box<>(7);
int doubled = n.get() * 2;

The vocabulary matters, because error messages use it. In Box<T>, T is the type parameter. In Box<String>, String is the type argument. Writing Box<String> is called a generic type invocation, and the compiler then treats every T in the class as String for that variable.

The <> on the right side is the diamond. It tells the compiler to work out the type arguments from the left side or from the constructor arguments, so you do not repeat yourself. Since Java 7, new Box<>("hi") means the same as new Box<String>("hi").

Names of type parameters

Any identifier works, but the convention is a single uppercase letter. The Oracle tutorial lists the common ones: T for type, E for element (used throughout the Collections Framework), K for key, V for value, N for number. Following the convention lets readers recognize the role at a glance: Map<K, V> needs no explanation.

More than one type parameter

Separate the parameters with commas:

public class Pair<A, B> {
    private final A first;
    private final B second;

    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }

    public A getFirst() { return first; }
    public B getSecond() { return second; }
}

Pair<String, Integer> has a String first and an Integer second. getFirst() returns String and getSecond() returns Integer, with no casts. The two parameters are independent: A and B may be the same type or different types.

Only reference types

A type argument must be a class, interface, or array type, a reference type. The eight primitive types (int, double, boolean, ...) are not allowed:

Box<int> a = new Box<>(1);       // does not compile
Box<Integer> a = new Box<>(1);   // fine

Use the wrapper class instead (Integer, Double, Boolean). Java converts between int and Integer automatically (autoboxing), so new Box<>(1) and int x = box.get() still read naturally. Two consequences to remember: a wrapper can be null, and boxing has a small cost. For everyday backend code that cost is not a concern.

A box of strings is not a box of objects

Since String is an Object, you might expect this to work:

Box<String> b = new Box<>("x");
Box<Object> c = b;   // does not compile

It does not. Generic types are not related just because their type arguments are related. The reason is safety: if the assignment were allowed, you could call c.set(42) and put an Integer into a box that b still believes holds only strings. Then the read String s = b.get() would break, which is exactly the problem generics exist to prevent. Lesson 5 shows how wildcards give you controlled flexibility here.