Advanced Generics: Wildcards & Type Erasure

import java.util.List;

public class Main {
    // BOUNDED type parameter: T must be a Number (or a subtype of it).
    // Inside the method you may call any Number method, e.g. doubleValue().
    static <T extends Number> double sumAll(List<T> items) {
        double total = 0;
        for (T n : items) total += n.doubleValue();   // legal: T IS-A Number
        return total;
    }

    // RECURSIVE bound: "T must be comparable to itself".
    // This guarantees a.compareTo(b) is type-safe for any T we pass in.
    static <T extends Comparable<T>> T maxOf(T a, T b) {
        return a.compareTo(b) >= 0 ? a : b;            // returns the larger one
    }

    public static void main(String[] args) {
        // sumAll accepts any List of Number subtypes
        System.out.println("sum ints:    " + sumAll(List.of(1, 2, 3)));      // 6.0
        System.out.println("sum doubles: " + sumAll(List.of(1.5, 2.5)));     // 4.0

        // maxOf works for anything Comparable: Integer, String, ...
        System.out.println("max int:    " + maxOf(7, 3));                    // 7
        System.out.println("max string: " + maxOf("apple", "banana"));       // banana
    }
}

sum ints:    6.0
sum doubles: 4.0
max int:    7
max string: banana

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

public class Main {
    // PRODUCER: the list gives values OUT, so use ? extends Number ("extends").
    // You can read a Number from it; you may NOT add to it.
    static double sum(List<? extends Number> producer) {
        double total = 0;
        for (Number n : producer) total += n.doubleValue();
        return total;
    }

    // CONSUMER: the list takes values IN, so use ? super Integer ("super").
    // You can add Integers; reading back only guarantees Object.
    static void fill(List<? super Integer> consumer, int from, int to) {
        for (int i = from; i <= to; i++) consumer.add(i);
    }

    // PECS in one method: copy FROM a producer INTO a consumer.
    static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (T item : src) dest.add(item);
    }

    public static void main(String[] args) {
        // sum reads from any List of Number subtypes (producer)
        System.out.println("sum(ints):    " + sum(List.of(1, 2, 3)));     // 6.0
        System.out.println("sum(doubles): " + sum(List.of(1.5, 2.5)));    // 4.0

        // fill writes Integers into a List<Number> (consumer)
        List<Number> nums = new ArrayList<>();
        fill(nums, 1, 4);
        System.out.println("after fill:   " + nums);                      // [1, 2, 3, 4]

        // copy uses BOTH: T is inferred as Integer from the arguments
        List<Integer> src = List.of(10, 20, 30);
        List<Object> dst = new ArrayList<>(List.of("seed"));
        copy(dst, src);
        System.out.println("after copy:   " + dst);                       // [seed, 10, 20, 30]
    }
}

sum(ints):    6.0
sum(doubles): 4.0
after fill:   [1, 2, 3, 4]
after copy:   [seed, 10, 20, 30]

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

public class Main {
    // PROBLEM: you cannot write "new T()" or "new T[n]" — T is erased at runtime.
    // WORKAROUND: pass a Class<T> "type token" so the runtime knows the real type.
    static <T> T firstOrNull(List<?> list, Class<T> type) {
        if (list.isEmpty()) return null;
        Object first = list.get(0);
        // type.isInstance(...) is the erasure-safe way to check the type
        return type.isInstance(first) ? type.cast(first) : null;
    }

    // Generic varargs cause "heap pollution" warnings. @SafeVarargs says
    // "I only READ the array, I never store an incompatible value into it."
    @SafeVarargs
    static <T> List<T> listOf(T... items) {
        return new ArrayList<>(List.of(items));   // safe: we only read 'items'
    }

    public static void main(String[] args) {
        // List<String> and List<Integer> share ONE runtime class (erasure):
        boolean sameClass = List.of("a").getClass() == List.of(1).getClass();
        System.out.println("same runtime class? " + sameClass);   // true

        // Class<T> token lets us recover type safety at runtime:
        List<String> words = List.of("hello", "world");
        String w = firstOrNull(words, String.class);
        System.out.println("firstOrNull:        " + w);           // hello

        // @SafeVarargs builder, type inferred as Integer:
        System.out.println("listOf:             " + listOf(1, 2, 3));  // [1, 2, 3]
    }
}

same runtime class? true
firstOrNull:        hello
listOf:             [1, 2, 3]

import java.util.List;

public class Main {
    // 🎯 YOUR TURN — fill in the blanks marked with ___

    // 1) Bound T so you can call .doubleValue() on each element.
    //    👉 replace ___ with the bound: extends Number
    static <T ___> double average(List<T> items) {
        double total = 0;
        for (T n : items) total += n.doubleValue();
        return total / items.size();
    }

    // 2) Write a recursive bound so a.compareTo(b) is type-safe.
    //    👉 replace ___ with: extends Comparable<T>
    static <T ___> T smaller(T a, T b) {
        return a.compareTo(b) <= 0 ? a : b;   // return the SMALLER one
    }

    public static void main(String[] args) {
        System.out.println(average(List.of(2, 4, 6)));        // 4.0
        System.out.println(smaller("pear", "apple"));         // apple
    }

    // ✅ Expected output:
    // 4.0
    // apple
}

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

public class Main {
    // 🎯 YOUR TURN — fill in the blanks marked with ___

    // 1) This method only READS from the list (a producer).
    //    👉 replace ___ with the producer wildcard: ? extends Number
    static double total(List<___> producer) {
        double sum = 0;
        for (Number n : producer) sum += n.doubleValue();
        return sum;
    }

    // 2) This method only WRITES to the list (a consumer).
    //    👉 replace ___ with the consumer wildcard: ? super Integer
    static void addOneToFive(List<___> consumer) {
        for (int i = 1; i <= 5; i++) consumer.add(i);
    }

    public static void main(String[] args) {
        System.out.println("total: " + total(List.of(1.0, 2.0, 3.0)));   // total: 6.0

        List<Number> sink = new ArrayList<>();
        addOneToFive(sink);
        System.out.println("filled: " + sink);                           // filled: [1, 2, 3, 4, 5]
    }

    // ✅ Expected output:
    // total: 6.0
    // filled: [1, 2, 3, 4, 5]
}

import java.util.List;

public class Main {
    // 🎯 MINI-CHALLENGE: a generic, null-safe "max" finder
    //
    // 1. Write a generic method  <T extends Comparable<T>> T maxOf(List<T> list)
    //    that returns the largest element in the list.
    // 2. Start "max" as list.get(0), then loop and keep the bigger element
    //    using  item.compareTo(max) > 0.
    // 3. In main(), call it on List.of(3, 9, 2, 7) and on List.of("kiwi","fig","pear").
    //
    // ✅ Expected output:
    // 9
    // pear

    // your code here
}