All 15 Generics questions
More in Generics
How would you implement a generic Stack<T> class from scratch, demonstrating how a self-contained generic data structure is typically structured? What is a raw type in Java, and why does the compiler still permit using them (with an unchecked warning) despite generics having been available since Java 5? How would you use a Class<T> token parameter to work around type erasure when a generic method genuinely needs runtime access to the actual type argument, such as for deserialization or reflection-based instantiation? How would you write a generic interface (like a custom Repository<T, ID> pattern common in data-access layers) and implement it for a specific entity type? How would you implement a generic class with multiple type parameters and bounded type parameters (like <T extends Comparable<T>>), and what does this specific bound enable? How do generics interact with arrays, and why does the JDK itself sometimes use an unsafe cast (like in ArrayList's internal implementation) to work around the inability to create generic arrays directly? How does generic method overload resolution interact with type erasure to sometimes produce a compile error for seemingly valid overloads (like two methods differing only by their generic type parameter)? How would you implement a generic builder pattern with a self-referential generic type parameter (the 'curiously recurring generic pattern', <T extends Builder<T>>) to support fluent method chaining that correctly returns the actual subclass type in an inheritance hierarchy? How does variance (covariance, contravariance, invariance) apply differently to Java arrays versus Java generics, and what practical safety trade-off does this design difference represent? How would you implement a generic pair/tuple utility method that returns different concrete types depending on the number of elements, and how does target-type inference help the compiler choose the correct generic instantiation from context alone?
Advertisement
Java › Generics

How do bounded wildcards (? extends T and ? super T) work, and what does the PECS (Producer Extends, Consumer Super) mnemonic mean for choosing between them?

Advanced

Answer

? extends T (an upper-bounded wildcard) means the parameterized type is T or some unknown subtype of T, letting you safely READ elements as T (since whatever the actual type is, it's guaranteed to be a T or subtype) but not safely WRITE to it (since the compiler can't verify what you're adding matches the actual unknown specific subtype); ? super T (a lower-bounded wildcard) means the parameterized type is T or some unknown supertype of T, letting you safely WRITE elements of type T into it (since any supertype of T can safely accept a T) but reads only guarantee an Object -- PECS captures this: use extends when a structure is a PRODUCER you only read from, use super when it's a CONSUMER you only write to.
// PECS in action: copying from a producer (extends) to a consumer (super)
public static <T> void copy(List<? extends T> source, List<? super T> destination) {
    for (T item : source) {  // safe to READ as T from the producer
        destination.add(item);  // safe to WRITE T into the consumer
    }
}

List<Integer> ints = List.of(1, 2, 3);
List<Number> numbers = new ArrayList<>();
copy(ints, numbers);  // works: List<Integer> extends Number-compatible, List<Number> accepts Integer
Real-world example The JDK's own Collections.copy(List<? super T> dest, List<? extends T> src) method signature is a canonical real-world application of PECS, precisely allowing a List<Object> destination to receive elements copied from a List<String> source, a combination that wouldn't be possible without these bounded wildcards given generics' invariance.

Common follow-ups: Why can't you call add() on a List<? extends T> reference, even though the underlying list clearly supports adding elements of its actual concrete type?;How does PECS relate to the broader concept of covariance and contravariance in type systems?

Collections Framework;OOP & Classes
All 15 Generics questions