> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java Type Parameter A type parameter is a placeholder identifier used in the declaration of generic classes, interfaces, and methods to represent a specific object type that will be provided at instantiation or invocation. It allows the definition of parameterized types, enforcing compile-time type safety while deferring the specification of the concrete type to the caller. ## Syntax and Declaration Type parameters are declared within angle brackets (`< >`). For classes and interfaces, the type parameter declaration immediately follows the type identifier. For methods, the type parameter declaration must be placed *before* the method's return type. A declaration can contain one or multiple type parameters separated by commas. ```java theme={"dark"} // Class declaration with a single type parameter public class Container { private T item; } // Interface declaration with multiple type parameters public interface Mapper { V map(K key); } // Method declaration with a type parameter before the return type public void processElement(E element) { // Method body } ``` ## Type Parameter vs. Type Argument It is critical to distinguish between a type parameter and a type argument: * **Type Parameter:** The placeholder variable defined in the generic declaration (e.g., the `T` in `public class Box`). * **Type Argument:** The concrete reference type provided by the caller to replace the type parameter (e.g., the `String` in `Box box = new Box<>();`). **Primitive Type Restriction:** Type arguments must be reference types. Primitive types (e.g., `int`, `double`, `char`) cannot be used as type arguments. To parameterize a generic type with a primitive value, its corresponding wrapper class (e.g., `Integer`, `Double`, `Character`) must be specified instead. ## Bounded Type Parameters By default, a type parameter can accept any reference type (equivalent to extending `java.lang.Object`). Bounds restrict the set of types that can be passed as type arguments. **Upper Bounds** The `extends` keyword is used to restrict a type parameter to a specific class or interface, and any of its subclasses or subinterfaces. Note that in the context of type parameters, `extends` is used for both classes and interfaces. ```java theme={"dark"} // T must be Number or a subclass of Number public class MathOperation { // ... } ``` **Multiple Bounds** A type parameter can be constrained by multiple bounds using the ampersand (`&`) operator. If one of the bounds is a class, it must be specified first in the bound list. A type parameter can have at most one class bound, but multiple interface bounds. ```java theme={"dark"} // T must extend the Entity class AND implement the Serializable interface public class Repository { // ... } ``` ## Standard Naming Conventions By convention, type parameters are single, uppercase letters. This distinguishes them from standard Java class and interface names. The standard conventions are: * **`E`** - Element (used extensively by the Java Collections Framework) * **`K`** - Key * **`N`** - Number * **`T`** - Type * **`V`** - Value * **`S`, `U`, `V`** - 2nd, 3rd, 4th types ## Type Erasure Java implements generics via a mechanism called type erasure. During compilation, the Java compiler enforces type constraints and then erases the type parameters. * Unbounded type parameters (e.g., ``) are replaced with `Object`. * Bounded type parameters (e.g., ``) are replaced with their first bound (in this case, `Number`). Because of type erasure, type parameters do not exist at runtime. This means you cannot perform runtime type checks against a type parameter (e.g., `if (obj instanceof T)` is illegal) or instantiate a type parameter directly (e.g., `new T()` is illegal).

Tired of Poor Java Skills? Fix That With Deep Grasping! Learn More