Generics in Java – Type-Safe Classes and Methods

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

public class WhyGenerics {
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static void main(String[] args) {
        // Without generics (raw type): anything goes in, casts needed, errors at run time
        List raw = new ArrayList();
        raw.add("Java");
        raw.add(42);                                // compiles
        try {
            for (Object o : raw) {
                String s = (String) o;              // ClassCastException on 42
                System.out.println("raw: " + s.toUpperCase());
            }
        } catch (ClassCastException e) {
            System.out.println("raw: ClassCastException at run time");
        }

        // With generics: the compiler enforces the element type, no casts
        List<String> names = new ArrayList<>();
        names.add("Java");
        // names.add(42);                           // compile error
        for (String s : names) System.out.println("generic: " + s.toUpperCase());
    }
}

public class GenericClass {
    // A generic class with one type parameter T
    static class Box<T> {
        private T value;
        Box(T value) { this.value = value; }
        T get() { return value; }
        void set(T value) { this.value = value; }
        boolean isEmpty() { return value == null; }
    }

    // Two type parameters
    record Pair<K, V>(K key, V value) {
        <R> Pair<K, R> withValue(R newValue) { return new Pair<>(key, newValue); }
    }

    public static void main(String[] args) {
        Box<String> name = new Box<>("Asha");
        Box<Integer> age = new Box<>(29);
        String n = name.get();                      // no cast
        int a = age.get();                          // auto-unboxing
        System.out.println(n + " is " + a);

        Pair<String, Integer> score = new Pair<>("Ravi", 87);
        Pair<String, String> grade = score.withValue("A");
        System.out.println(score + " -> " + grade);
    }
}

import java.util.*;

public class GenericMethods {
    // Generic method: <T> before the return type
    static <T> T firstOrDefault(List<T> list, T fallback) {
        return list.isEmpty() ? fallback : list.get(0);
    }

    // Bounded type parameter: T must be Comparable to itself
    static <T extends Comparable<T>> T max(List<T> items) {
        T best = items.get(0);
        for (T item : items) if (item.compareTo(best) > 0) best = item;
        return best;
    }

    // Multiple bounds: a Number that is also Comparable
    static <T extends Number & Comparable<T>> double sumAbove(List<T> nums, T limit) {
        double sum = 0;
        for (T n : nums) if (n.compareTo(limit) > 0) sum += n.doubleValue();
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(firstOrDefault(List.of("kafka", "spring"), "none"));
        System.out.println(firstOrDefault(List.<String>of(), "none"));
        System.out.println(max(List.of(4, 19, 7)));
        System.out.println(max(List.of("pear", "apple", "zucchini")));
        System.out.println(sumAbove(List.of(5, 12, 30, 8), 10));
        System.out.println(Collections.<Integer>emptyList());     // explicit type argument
    }
}

import java.util.*;

public class Wildcards {
    // Upper bounded: read Numbers from any list of Number subtypes (producer)
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // Lower bounded: write Integers into any list that can hold them (consumer)
    static void addSquares(List<? super Integer> target, int count) {
        for (int i = 1; i <= count; i++) target.add(i * i);
    }

    // Unbounded: works with any element type when only Object methods are needed
    static void printAll(Collection<?> items) {
        System.out.println("size " + items.size() + ": " + items);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        List<Double> doubles = List.of(1.5, 2.5);
        System.out.println("total ints    = " + total(ints));
        System.out.println("total doubles = " + total(doubles));

        List<Number> numbers = new ArrayList<>();
        List<Object> objects = new ArrayList<>();
        addSquares(numbers, 3);
        addSquares(objects, 2);
        printAll(numbers);
        printAll(objects);
        printAll(Set.of("x"));

        // List<Number> n = ints;     // compile error: List<Integer> is NOT a List<Number>
    }
}

import java.util.*;

public class TypeErasure {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        List<Integer> numbers = new ArrayList<>();
        // Type arguments are erased at run time: both are just ArrayList
        System.out.println("Same runtime class: " + (strings.getClass() == numbers.getClass()));
        System.out.println("Runtime class:      " + strings.getClass().getName());

        // Things erasure forbids (compile errors):
        // new T();                     cannot instantiate a type parameter
        // new List<String>[10];        no generic array creation
        // obj instanceof List<String>  type arguments not available at run time
        // List<int>                    primitives not allowed; use List<Integer>
    }
}