Answer Generics add compile-time type checking and eliminate many runtime cast problems. Before generics (pre-Java 5), collections stored Object and required explicit casting — error-prone and unsafe. Benefits ● Type Safety: prevents insertion of wrong types into collections (compile-time error). ● No explicit casting on retrieval: cleaner and safer code. ● Self-documenting APIs: List says what the list contains. ● Reusable code: collections and utility methods can operate on different types. Example ``` List names = new ArrayList<>(); names.add("Alice"); ``` // names.add(1); // compile-time error String first = names.get(0); // no cast needed Generics advanced concepts ● Type erasure: generics are implemented with erasure; runtime does not retain generic type parameters. ● Wildcards (?):? extends T (producer),? super T (consumer) — PECS rule: Producer Extends, Consumer Super. ● Bounded type parameters: e.g., to restrict allowable types. ``` import java.util.*; public class ListExample { public static void main(String[] args) { List names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); names.add("Charlie"); ``` // names.add(123); // ❌ Compile-time error: only Strings allowed ``` System.out.println("List of Names:"); for (String name: names) { System.out.println(name); } ``` String first = names.get(0); // ✅ No cast needed ``` System.out.println("First name: " + first); } } ``` Output List of Names: Alice Bob Charlie First name: Alice Mentor tip: prefer generics everywhere for collections and utility APIs; be mindful of wildcard variance when designing APIs. ``` import java.util.*; ``` // Generic class example ``` class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } ``` // Generic method example ``` class Util { public static void printList(List list) { for (T item: list) { System.out.println(item); } } } public class GenericsExample { public static void main(String[] args) { ``` // Example 1: Using generics with a collection ``` List names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); ``` // names.add(1); // ❌ Compile-time error — type safety enforced String first = names.get(0); // ✅ No casting needed ``` System.out.println("First name: " + first); ``` // Example 2: Using a generic class ``` Box intBox = new Box<>(); intBox.set(100); System.out.println("Box contains: " + intBox.get()); Box strBox = new Box<>(); strBox.set("Hello Generics"); System.out.println("Box contains: " + strBox.get()); ``` // Example 3: Using a generic method ``` List numbers = Arrays.asList(10, 20, 30); System.out.println("Printing names:"); Util.printList(names); System.out.println("Printing numbers:"); Util.printList(numbers); } } ``` Explanation: 1. Generic Collection: ○ List ensures only String objects can be added. ○ Eliminates the need for casting when retrieving elements. 2. Generic Class: ○ Box can hold any type (String, Integer, etc.) without rewriting the class. 3. Generic Method: ○ before the return type defines a method that can work with any type. First name: Alice Box contains: 100 Box contains: Hello Generics Printing names: Alice Bob Printing numbers:

General