Java Generics

• Java Generics enable type safety by ensuring that collections and methods operate on specific types, catching type errors at compile time.
• Generics allow classes, interfaces, and methods to be parameterized by type, offering greater flexibility and reusability.
• Generics were introduced in Java 5 to address the limitations of using Object for generic programming, which required explicit casting and was prone to runtime errors.
• Using generics reduces the need for casting and enhances type safety.

Type Parameters

• Type parameters are placeholders for actual types that will be specified when the generic class or method is used.
• Type parameters are typically represented by single, uppercase letters such as T, E, K, V, etc.
• T usually represents a generic type.
• E usually represents an element type in a collection.
• K usually represents a key type in a map.
• V usually represents a value type in a map.
• Multiple type parameters can be declared, such as class MyClass<K, V> { ... }.
• Type parameters are declared within angle brackets (<>) after the class or method name.

Bounded Types

• Bounded types restrict the types that can be used as type arguments, thereby enforcing type constraints.
• An upper bound is specified using the extends keyword, ensuring that the type argument is a subtype of the specified bound.
• For example, <T extends Number> means T must be Number or a subclass of Number.
• Multiple bounds can be specified using &, such as <T extends Number & MyInterface>, in which case T must implement all specified interfaces and be a subtype of the class (if any).
• A lower bound is specified using the super keyword, ensuring that the type argument is a supertype of the specified bound.
• For example, <T super Integer> indicates that T must be Integer or a superclass of Integer.
• Bounded types provide more control over the types that can be used with a generic class or method.

Wildcards

• Wildcards (?) represent unknown types and are useful when the exact type doesn't matter.
• Upper bounded wildcards (<? extends Type>) allow any subtype of Type.
• Lower bounded wildcards (<? super Type>) allow any supertype of Type.
• Unbounded wildcards (<?>) represent any type and are primarily useful when the method can work with any type.
• Wildcards enable more flexible and reusable generic code.
• Wildcards cannot be used when defining a generic class or interface; they are used when using (declaring a variable of) a generic class or interface.
• Using List<?> is different than List<Object>. A list of some specific type that is unknown is represented by the former, List<Object> means a list of Object.

Generic Methods

• Generic methods are methods that have type parameters.
• Type parameters for methods are declared before the return type.
• For example, public <T> void myMethod(T arg) { ... }.
• Generic methods can be defined inside generic or non-generic classes.
• Type inference is often used in generic methods, where the compiler infers the type argument based on the method's context.
• Static methods can also be generic.
• Generic methods allow writing type-safe code that operates on different types without casting.

Collections Framework

• The Java Collections Framework is a set of interfaces and classes that implement common collection data structures.
• Key interfaces include List, Set, Map, and Queue.
• Implementations include ArrayList, LinkedList, HashSet, TreeSet, HashMap, and TreeMap.
• Generics are heavily used in the Collections Framework to ensure type safety.
• For example, List<String> represents a list of strings, and Map<String, Integer> represents a map where keys are strings and values are integers.
• Using generics with collections eliminates the need for casting and reduces the risk of runtime ClassCastException errors.

Syntax

• Declaring a generic class: class MyClass<T> { ... }
• Creating an instance of a generic class: MyClass<String> myObject = new MyClass<>();
• Declaring a generic method: public <T> T myMethod(T arg) { ... }
• Using a bounded type: class MyClass<T extends Number> { ... }
• Using a wildcard: List<?> myList;
• Creating a generic interface: interface MyInterface<T> { ... }
• Implementing a generic interface: class MyClass<T> implements MyInterface<T> { ... }
• Invoking a generic method: String result = myObject.<String>myMethod("example"); (explicit type argument), or String result = myObject.myMethod("example"); (type inference).
• The diamond operator (<>) is used for type inference when creating instances, e.g., List<String> list = new ArrayList<>();

Benefits of Generics

• Enhanced type safety by catching type errors at compile time.
• Reduced need for explicit type casting, leading to cleaner code.
• Increased code reusability by writing generic algorithms that can be used with different types.
• Improved performance by avoiding runtime type checks.
• Making code easier to read and maintain due to explicit type information.
• Enables the creation of generic data structures and algorithms.