Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)0%

Type Erasure and Bridge Methods Behind the Scenes

Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)

Advanced16 min read•Updated: 2025-01-15

❓ Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)

Introduction

In Java, arrays are covariant (i.e. Integer[] is an Object[]), but generic collections are invariant. For example, even though Integer is a subclass of Number, a List<Integer> is NOT a List<Number>.

To provide flexibility in API design while preserving complete type safety, Java provides Wildcards (?).

🚫 The Invariance Problem

Consider this method:

1void printNumbers(List<Number> list) { ... }
2 
3List<Integer> intList = Arrays.asList(1, 2, 3);
4// printNumbers(intList); 
5// ❌ COMPILE ERROR: List<Integer> cannot be passed to List<Number>!

If Java allowed this, you could write list.add(45.50); inside the method, which would illegally corrupt an Integer list with a Double!

🌐 1. Unbounded Wildcard (`<?>`)

Represents any arbitrary type:

1public static void printList(List<?> list) {
2    for (Object item : list) {
3        System.out.println(item);
4    }
5}

🔼 2. Upper Bounded Wildcard (`<? extends T>`)

Restricts the unknown type to be either type T or a subtype of T. Used when you want to read/produce values from a structure:

1public static double sumOfNumbers(List<? extends Number> numbers) {
  double sum = 0.0;
  for (Number n : numbers) {
      sum += n.doubleValue(); // ✅ Safe to read as Number
  }
  // numbers.add(10); // ❌ COMPILE ERROR: Cannot write into ? extends!
  return sum;
8}

🔽 3. Lower Bounded Wildcard (`<? super T>`)

Restricts the unknown type to be either type T or a supertype of T. Used when you want to write/consume values into a structure:

1public static void addIntegers(List<? super Integer> list) {
2    list.add(10); // ✅ Safe to add Integer or its subtypes
3    list.add(20);
4    list.add(30);
5    // Object obj = list.get(0); // Only safe to read as Object
6}

💡 The PECS Principle (Producer Extends, Consumer Super)

The golden rule of Java Generics coined by Joshua Bloch in Effective Java:

1┌──────────────────────────────────────────────────────────────┐
2│                    PECS PRINCIPLE                            │
3├──────────────────────────────────────────────────────────────┤
4│  PRODUCER  ─►  Use <? extends T>  (When reading data out)    │
5│  CONSUMER  ─►  Use <? super T>    (When writing data in)     │
6└──────────────────────────────────────────────────────────────┘

Example of PECS in `Collections.copy`:

1public static <T> void copy(List<? super T> dest, List<? extends T> src) {
2    for (int i = 0; i < src.size(); i++) {
3        dest.set(i, src.get(i));
4    }
5}

src produces items for the algorithm (? extends T).
dest consumes items from the algorithm (? super T).

Next Lesson

Type Erasure and Bridge Methods Behind the Scenes

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Generic Methods and Bounded Type Parameters (<T extends Number>)	Type Erasure and Bridge Methods Behind the Scenes

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Type Erasure and Bridge Methods Behind the Scenes

Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)

Advanced16 min read•Updated: 2025-01-15

Study Materials

❓ Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)

Introduction

To provide flexibility in API design while preserving complete type safety, Java provides Wildcards (?).

🚫 The Invariance Problem

Consider this method:

1void printNumbers(List<Number> list) { ... }
2 
3List<Integer> intList = Arrays.asList(1, 2, 3);
4// printNumbers(intList); 
5// ❌ COMPILE ERROR: List<Integer> cannot be passed to List<Number>!

If Java allowed this, you could write list.add(45.50); inside the method, which would illegally corrupt an Integer list with a Double!

🌐 1. Unbounded Wildcard (`<?>`)

Represents any arbitrary type:

1public static void printList(List<?> list) {
2    for (Object item : list) {
3        System.out.println(item);
4    }
5}

🔼 2. Upper Bounded Wildcard (`<? extends T>`)

Restricts the unknown type to be either type T or a subtype of T. Used when you want to read/produce values from a structure:

1public static double sumOfNumbers(List<? extends Number> numbers) {
  double sum = 0.0;
  for (Number n : numbers) {
      sum += n.doubleValue(); // ✅ Safe to read as Number
  }
  // numbers.add(10); // ❌ COMPILE ERROR: Cannot write into ? extends!
  return sum;
8}

🔽 3. Lower Bounded Wildcard (`<? super T>`)

Restricts the unknown type to be either type T or a supertype of T. Used when you want to write/consume values into a structure:

1public static void addIntegers(List<? super Integer> list) {
2    list.add(10); // ✅ Safe to add Integer or its subtypes
3    list.add(20);
4    list.add(30);
5    // Object obj = list.get(0); // Only safe to read as Object
6}

💡 The PECS Principle (Producer Extends, Consumer Super)

The golden rule of Java Generics coined by Joshua Bloch in Effective Java:

1┌──────────────────────────────────────────────────────────────┐
2│                    PECS PRINCIPLE                            │
3├──────────────────────────────────────────────────────────────┤
4│  PRODUCER  ─►  Use <? extends T>  (When reading data out)    │
5│  CONSUMER  ─►  Use <? super T>    (When writing data in)     │
6└──────────────────────────────────────────────────────────────┘

Example of PECS in `Collections.copy`:

1public static <T> void copy(List<? super T> dest, List<? extends T> src) {
2    for (int i = 0; i < src.size(); i++) {
3        dest.set(i, src.get(i));
4    }
5}

src produces items for the algorithm (? extends T).
dest consumes items from the algorithm (? super T).

Next Lesson

Type Erasure and Bridge Methods Behind the Scenes

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Generic Methods and Bounded Type Parameters (<T extends Number>)	Type Erasure and Bridge Methods Behind the Scenes

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

❓ Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)

Introduction

🚫 The Invariance Problem

🌐 1. Unbounded Wildcard (<?>)

🔼 2. Upper Bounded Wildcard (<? extends T>)

🔽 3. Lower Bounded Wildcard (<? super T>)

💡 The PECS Principle (Producer Extends, Consumer Super)

Example of PECS in Collections.copy:

Type Erasure and Bridge Methods Behind the Scenes

Related Lessons

Practice Quiz

Loading Page Content...

❓ Wildcards in Generics: Upper Bounded (? extends) and Lower Bounded (? super)

Introduction

🚫 The Invariance Problem

🌐 1. Unbounded Wildcard (<?>)

🔼 2. Upper Bounded Wildcard (<? extends T>)

🔽 3. Lower Bounded Wildcard (<? super T>)

💡 The PECS Principle (Producer Extends, Consumer Super)

Example of PECS in Collections.copy:

Type Erasure and Bridge Methods Behind the Scenes

Related Lessons

Practice Quiz

🌐 1. Unbounded Wildcard (`<?>`)

🔼 2. Upper Bounded Wildcard (`<? extends T>`)

🔽 3. Lower Bounded Wildcard (`<? super T>`)

Example of PECS in `Collections.copy`:

🌐 1. Unbounded Wildcard (`<?>`)

🔼 2. Upper Bounded Wildcard (`<? extends T>`)

🔽 3. Lower Bounded Wildcard (`<? super T>`)

Example of PECS in `Collections.copy`: