> ## 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 Upper Bounded Wildcard An upper bounded wildcard restricts the unknown type in a generic instantiation to be a specific type or any of its subtypes. It establishes covariance in Java's generic type system, allowing a generic type to accept a parameterized type that is a descendant of a defined upper bound. ## Syntax The upper bounded wildcard is declared using the `?` character, followed by the `extends` keyword, and the bounding class or interface. ```java theme={"dark"} ``` ## Type System Mechanics By default, Java generics are **invariant**. For example, `List` is not a subtype of `List`, even though `Integer` is a subtype of `Number`. Applying an upper bounded wildcard makes the generic type **covariant**. This means `List`, `List`, and `List` are all valid subtypes of `List`. ```java theme={"dark"} List integers = new ArrayList<>(); List doubles = new ArrayList<>(); // Covariant assignments List numbers1 = integers; List numbers2 = doubles; ``` ## Read and Write Constraints The primary technical implication of using an upper bounded wildcard dictates how the compiler handles read and write operations on the generic structure. ### Read Operations (Safe) When retrieving an element from a structure defined with an upper bounded wildcard, the compiler guarantees that the object will be an instance of the upper bound type (or a subtype thereof). Therefore, it is strictly type-safe to read the element as the upper bound type. ```java theme={"dark"} List boundedList = getSomeNumberList(); // The compiler guarantees the returned element is at least a Number Number num = boundedList.get(0); ``` ### Write Operations (Prohibited) Writing to a structure defined with an upper bounded wildcard is strictly prohibited by the compiler, with the sole exception of the `null` literal. Because the wildcard represents an *unknown* specific subtype of the bound, the compiler cannot verify type safety at compile time. If `List` is currently pointing to a `List`, allowing the addition of a `Double` would cause heap pollution. To prevent this, the compiler disables all parameterized insertions. ```java theme={"dark"} List intList = new ArrayList<>(); List boundedList = intList; // Compilation Errors: The compiler does not know the exact subtype // boundedList.add(Integer.valueOf(1)); // ERROR // boundedList.add(Double.valueOf(1.0)); // ERROR // boundedList.add(new Object()); // ERROR // Permitted, as null belongs to any reference type boundedList.add(null); ``` ## Interface vs. Class Bounds The `extends` keyword in an upper bounded wildcard applies universally to both classes and interfaces. There is no `implements` keyword used in wildcard bounds. ```java theme={"dark"} // Valid whether Runnable is an interface or a class List tasks; ``` *Note: Unlike generic type parameters (e.g., ``), wildcards do not support multiple bounds. Syntax like `` is invalid in Java.*

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