Producer extend Consumer super

pecs.java

import java.util.ArrayList;
import java.util.List;

class Scratch {

    class Shark {
        private final String name = "Sharkie";
        public String getName() { return name; }
    }// A
    class HammerShark extends Shark{
        public String getName() { return "Hammerhead " + super.getName(); }
    }// B
    class DeadHammerShark extends HammerShark{
        public String getName() { return "Dead Hammerhead "; }
    }// C

    public static void main(String[] args) {
        new Scratch().run();
    }
    public void run() {

        final ArrayList<Shark> sharks = new ArrayList<>();
        final ArrayList<HammerShark> hSharks = new ArrayList<>();
        final ArrayList<DeadHammerShark> dhSharks = new ArrayList<>();

        // consumer super
        // contravariance - more specific s -> h, more input, add less types
        // why is `? extends` it called lower bound?

        putIn(sharks);                              // lower bound, ≥ ok
        ///putIn(hSharks);                          // error
        //putIn(dhSharks)                           // error

        putInh(sharks);                              // ok
        putInh(hSharks);                             // lower bound, ≥ ok
        //putInh(dhSharks)                           // error


        // Producer extends
        // why is `? super` it called upper bound?

        dhSharks.add(new DeadHammerShark());// fyi extends applies in the function
        // sayName(sharks);    // error
        sayNamehs(hSharks);    // upper bound, ≤ ok
        sayNamehs(dhSharks);   // ok

        //sayNameDhs(sharks);   // error
        //sayNameDhs(hSharks);  // error
        sayNameDhs(dhSharks);   // upper bound, ≤ ok
    }

    // consumer function param
    void putIn(List<? super Shark> sharks) {  // putIn is function sub-type of putInh (has all of putInh behaviors)
        sharks.add(new Shark());            // ≥ ok
        sharks.add(new HammerShark());      // ok
        sharks.add(new DeadHammerShark());  // ok

        System.out.println("Sharks");
        System.out.println(sharks);

        // final HammerShark object = sharks.get(0);
        final Object object = sharks.get(0); // only Object read
        // for debug, consumer should not produce. Don't use wildcard if both read & write
    }

    void putInh(List<? super HammerShark> sharks) {
        // sharks.add(new Shark());         // error, because super is function scoped, it may contain Shark objs already
        sharks.add(new HammerShark());      // ≥ ok
        sharks.add(new DeadHammerShark());  // ok

       // contravariance with super

        System.out.println("H.Sharks");
        System.out.println(sharks);
    }

    // producer
    void sayNamehs(List<? extends HammerShark> sharks) {
        System.out.println("pH.Sharks");
        final Shark shark = sharks.get(0);
        final HammerShark hammerShark = sharks.get(0);

        // sharks.add(new Shark()); cannot add anything
    }

    void sayNameDhs(List<? extends DeadHammerShark> sharks) { // is function sub-type of sayNamehs (has all sayName behaviors)
        final Shark shark = sharks.get(0);
        final HammerShark hammerShark = sharks.get(0);
        final DeadHammerShark dhammerShark = sharks.get(0);

        // can contain up till extended type - covariance
    }
}