Wildcards: `extends` and `super`

The answer is the wildcard, written ?. It means “some type I am not naming”.

? extends when you read

static double sum(List<? extends Number> nums) {
    double total = 0;
    for (Number n : nums) total += n.doubleValue();
    return total;
}

sum(List.of(1, 2, 3));        // 6.0
sum(List.of(1.5, 2.5));       // 4.0

List<? extends Number> means “a list of some one type, and that type is a Number or below”. A List<Integer> fits. So does a List<Double>.

Reading is safe. Whatever the real list holds, every element is at least a Number, so n.doubleValue() always works.

Writing is not:

List<? extends Animal> list = dogs;
list.add(new Dog());       // ERROR

The compiler does not know whether the real list is a List<Dog> or a List<Cat>. Adding a Dog would be wrong in the second case, so it refuses everything.

? super when you write

static void addDogs(List<? super Dog> list) {
    list.add(new Dog());
    list.add(new Dog());
}

addDogs(new ArrayList<Dog>());       // works
addDogs(new ArrayList<Animal>());    // works
addDogs(new ArrayList<Object>());    // works

List<? super Dog> means “a list of some type that is a Dog or above”. A list of Dogs, Animals or Objects all qualify.

Writing is safe here. Whatever the real list holds, a Dog is acceptable, because the list’s type is Dog or something more general.

Reading gives you very little:

List<? super Dog> list = animals;
Object o = list.get(0);      // Object is all you get
Dog d = list.get(0);         // ERROR

The list might really hold Object. The only thing everything is, is an Object.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. A `Dog` is an `Animal`. Why is a `List<Dog>` not a `List<Animal>`?

   Show the answer

   Because if it were, you could break the list of Dogs.

   Imagine it were allowed. You write List<Animal> animals = dogs;. Now animals and dogs point at the same list. Then somebody writes animals.add(new Cat()), which is perfectly legal for a list of Animals.

   Now the list that everybody believes holds only Dogs has a Cat in it. The next line to read a Dog out of it fails.

   Java stops the first line so the last one can never happen. Generics are invariant: List<Dog> and List<Animal> have no relationship at all, even though Dog and Animal do.

2. Why can you read from a `List<? extends Animal>` but not add to it?

   Show the answer

   Reading is safe. Whatever the real list holds, every element is at least an Animal. So Animal a = list.get(0) always works.

   Writing is not. The list might really be a List<Dog>, or a List<Cat>. The compiler does not know which. Adding a Dog would be wrong if it is really a list of Cats, so it refuses everything.

   The error message is odd and worth recognising: D cannot be converted to CAP#1. CAP#1 is the compiler's name for "the one specific type this really is, which I cannot see".

   So ? extends gives you a list you can read from. That is all, and it is often all you need.

3. State the PECS rule and explain what it is short for.

   Show the answer

   Producer extends, Consumer super.

   If the parameter produces values for you, you are reading from it, so use ? extends.

   If the parameter consumes values you give it, you are writing into it, so use ? super.

   You can see both halves in one real signature: Collections.copy(List<? super T> dest, List<? extends T> src). The source produces, so it is extends. The destination consumes, so it is super.

   If you neither read nor write, and only want any list at all, use plain List<?>.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises100 pointsabout 100 minutes

import java.util.*;

class Animal { public String toString() { return "Animal"; } }
class Dog extends Animal { public String toString() { return "Dog"; } }
class Cat extends Animal { public String toString() { return "Cat"; } }

public class Invariant {
    public static void main(String[] args) {
        Dog d = new Dog();
        Animal a = d;                       // fine. Why?

        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());

        // List<Animal> animals = dogs;     // uncomment: read the error
        // animals.add(new Cat());          // this is what it prevents
        // Dog first = dogs.get(1);         // and this is what would break

        // TODO: write the three lines out as a comment explaining the danger
    }
}

import java.util.*;

public class Reading {
    // This compiles. Now try to call it.
    static double sumStrict(List<Number> nums) {
        double t = 0; for (Number n : nums) t += n.doubleValue(); return t;
    }

    // TODO: sumAny(...) that accepts List<Integer>, List<Double>, List<Long>

    public static void main(String[] args) {
        // System.out.println(sumStrict(List.of(1, 2, 3)));      // uncomment: error
        // TODO: call your sumAny with three different list types
        // TODO: try to add to the wildcard list inside the method. Read the error.
    }
}

import java.util.*;

class Animal { public String toString() { return getClass().getSimpleName(); } }
class Dog extends Animal { }
class Puppy extends Dog { }

public class Writing {
    // TODO: addThreeDogs(...) that works on List<Dog>, List<Animal> AND List<Object>

    // TODO: copy(dest, src) with the PECS signature. Both halves in one method.

    public static void main(String[] args) {
        // TODO: call addThreeDogs with all three list types
        // TODO: read from a ? super Dog list and see what type you get back
        // TODO: use your copy() to move a List<Dog> into a List<Animal>
    }
}

import java.util.*;

public class RegistryApi {
    static class Unit { String name; double readiness;
        Unit(String n, double r) { name = n; readiness = r; }
        public String toString() { return name; } }
    static class AirUnit extends Unit { AirUnit(String n, double r) { super(n, r); } }

    // Choose the signature for each. Write your reason as a comment.
    //
    // 1. averageReadiness(...)   reads every unit, returns a double
    // 2. addStandardUnits(...)   adds three new Unit objects to a list
    // 3. countAll(...)           returns the size of any list at all
    // 4. moveAll(dest, src)      moves everything from one list to another
    // 5. firstOrNull(...)        returns the first element, keeping its exact type

    public static void main(String[] args) {
        List<AirUnit> air = new ArrayList<>(List.of(new AirUnit("Falcon", 91)));
        List<Unit> all = new ArrayList<>();
        // TODO: call all five and show each accepts what it should
    }
}