Generic Classes and Methods

We have used the standard generic types (List<E>, Map<K,V>, Set<E>). It is time to write our own. Designing a generic class is one of the most underrated skills in Java — it is what separates a library you can use anywhere from one you have to copy-paste and edit.

A first generic class: a typed box

The traditional "hello world" of generics is a Box<T> — a container of exactly one element of some type T. Compare the untyped and typed versions.

Three things to notice in the typed Box:

• The type parameter <T> appears immediately after the class name. From inside the class, T is just a placeholder type — wherever you would write String or Customer, you can write T.
• put and get use T. The compiler now enforces that whatever put accepts is whatever get returns.
• The diamond <> on new Box<>() lets the compiler infer String from the variable's declared type.

Naming conventions

By convention, single uppercase letters name type parameters:

These are conventions, not rules — the compiler will accept any identifier — but every Java reader is wired to expect them, so straying is gratuitous noise.

Multiple type parameters

A generic class can take more than one type parameter. The classic example is Pair<A, B>:

Each occurrence is checked independently — putting a String where a B is expected only works if B = String for that particular instance.

Generic methods (independent of the class)

A method can have its own type parameters, independent of the enclosing class. The type parameter declaration goes before the return type:

public static <T> T identity(T x) { return x; }

Generic methods are how the standard library writes things like Collections.emptyList() or Map.of(k, v). You usually do not have to specify the type parameter at the call site — the compiler infers it.

A multi-file generic class: a stack

This is the classic generic class to write next. Stack<E> is a typed LIFO container — push, pop, peek, size.

Compare this to the JDK's legacy Stack: ours is generic from line one, has no thread-safety penalty, and does not leak random Vector methods into its public API. This is what programming to interfaces

• generics buys you.

A generic class with a constraint: numeric averages

Sometimes a type parameter must support some operation. For example, a generic average method needs the elements to be Numbers. That is what bounded type parameters are for, in their simplest form:

We will go far deeper into bounds and wildcards in the next chapter. For now, the syntax <T extends Number> says "any T that is a Number."

Constraints can also be on interfaces

extends works for interfaces too. A common case is requiring the type to be Comparable:

You can also combine constraints with &: <T extends Number & Comparable<T>> means "any T that is both a Number and Comparable<T>."

Practice

ada / 36
36 / ada

Test your understanding