How do you declare a generic class or method with multiple type parameters, and how are they bound to actual types?

## Declaring multiple type parameters A generic type or method can take more than one placeholder. You list them comma-separated inside the angle brackets: ```java class Pair<K, V> { // two type parameters private final K key; private final V value; Pair(K key, V value) { this.key = key; this.value = value; } K getKey() { return key; } V getValue() { return value; } } ``` When you instantiate it, you supply one actual type per parameter, positionally: ```java Pair<String, Integer> p = new Pair<>("age", 42); // K is bound to String, V is bound to Integer ``` The parameters are **independent**: `Pair<String,String>`, `Pair<Long,User>` etc. are all valid. The first argument binds to the first parameter, the second to the second — order is positional, exactly like method arguments. ## Generic methods with multiple parameters For a method, the type-parameter list comes **before the return type**: ```java static <T, R> R convert(T input, Function<T, R> mapper) { return mapper.apply(input); } ``` Here `<T, R>` introduces two parameters used in the signature. Callers normally don't specify them — the compiler **infers** them from the arguments (`convert("5", Integer::parseInt)` infers T=String, R=Integer). You *can* supply them explicitly with the rarely-used 'type witness' syntax: `Util.<String,Integer>convert(...)`. ## Parameters can depend on each other and have bounds A later type parameter can refer to an earlier one, and any of them can be bounded with `extends`: ```java class SortedPair<K extends Comparable<K>, V> { ... } // K must be comparable to itself static <T, U extends T> void copy(List<T> dst, List<U> src) { ... } // U is a subtype of T ``` This is how you express relationships between the types. `K extends Comparable<K>` is the classic 'recursive' bound meaning 'K can be compared to other Ks'. ## Naming Use the conventional letters: `K,V` for key/value, `T,U,R` (or `T,S,U`) when the roles are generic, with `R` typically the return type. The standard library follows this: `Map<K,V>`, `Map.Entry<K,V>`, `BiFunction<T,U,R>`. ## Runtime: independent erasure Each type parameter is **erased** independently at compile time. At runtime `Pair<String,Integer>` and `Pair<Long,User>` are both just `Pair`; the type arguments are not available via `getClass()`. That's why you can't, for example, do `new K()` or `instanceof V` — the actual types are gone. The compile-time binding is what gives you safety: you can't put an Integer where a String key is expected. ## Common pitfalls - Mixing up positional order (`Pair<V,K>` vs `Pair<K,V>`) — the names are documentation; position is what binds. - Forgetting the method's `<T,R>` must come *before* the return type, not after the method name. - Expecting the actual types at runtime — they're erased.