Generic methods

Written Explanation

Where <T> goes

A generic method lists its type parameters in angle brackets before the return type:

static <T> T first(List<T> list) {
    return list.get(0);
}

Read it left to right: "for some type T, a static method that takes a List<T> and returns a T". The first <T> declares the parameter. The T after it is the return type, and the T in List<T> is a use. Forgetting the first <T> is the classic error: the compiler then looks for a class called T.

The Oracle tutorial states the rule plainly: the type parameter section goes before the method's return type. It works the same for static and non-static methods, and also for constructors.

The compiler works out T

You do not write the type when you call the method:

String s = first(List.of("a", "b"));   // T is String
Integer n = first(List.of(10, 20));    // T is Integer

This is type inference. The compiler looks at the argument List<String> and concludes T = String, so the result is a String with no cast. The same method served two types and stayed type safe.

If you ever need to say it explicitly, the type goes before the method name: Utils.<String>first(list). This is rarely necessary, but it is useful when inference cannot decide, for example when passing an empty collection with nothing to learn from.

One method, two parameters

Several parameters are separated by commas, as with classes:

static <A, B> Pair<B, A> swap(Pair<A, B> p) {
    return new Pair<>(p.getSecond(), p.getFirst());
}

Given a Pair<String, Integer>, the compiler infers A = String, B = Integer, and the result type is Pair<Integer, String>. The signature itself tells you that the types swap places. That is documentation the compiler checks.

Methods in generic classes

A static method cannot use the class's T, because static members belong to the class itself rather than to any one Box<String> or Box<Integer>. A static factory method in a generic class therefore declares its own parameter:

public class Pair<A, B> {
    // ...
    public static <X, Y> Pair<X, Y> of(X first, Y second) {
        return new Pair<>(first, second);
    }
}

The names X and Y here are independent of the class's A and B. Using the same letters would still work, but would shadow the class parameters and confuse readers; picking different letters for a static method makes the independence obvious. In general, a method's type parameter exists only inside that method, while a class's parameter exists across the whole class.

The same method for many types

Where would you need this? Anywhere the logic does not depend on the element type. Counting how many times a value appears in a list needs only equals:

static <T> int countOccurrences(List<T> list, T target) {
    int count = 0;
    for (T item : list) {
        if (item.equals(target)) {
            count++;
        }
    }
    return count;
}

Note that the same T ties both parameters: the target must have the same type as the list's elements. countOccurrences(tags, "java") works for a List<String>. You cannot call methods other than those every object has (equals, toString, hashCode), because T could be anything. Giving T more abilities is the topic of lesson 4.

What you cannot do with T

Because Java checks generics at compile time and later removes the type information (type erasure), a type parameter has restrictions. The two that matter now:

• You cannot create an object of type T. new T() does not compile. The compiler says unexpected type; required: class; found: type parameter T. If a method needs a new object, take it as a parameter, or receive it from the caller.
• A generic method can take T[], but only an array of reference types. swapInArray(T[] array, int i, int j) works for String[], but not for int[], because int is not a reference type.