Generics in Java: Writing Flexible and Reusable Code

1. Introduction to Generics

Generics in Java allow you to write flexible, type-safe code that can work with any object type. It helps in writing reusable code and reduces the chances of runtime errors by catching issues at compile time. With generics, you can create classes, interfaces, and methods that operate on types specified by the user.

2. Why Use Generics?

Before Java introduced generics, collections and other classes used `Object` as their type, which meant developers had to manually cast objects, increasing the risk of `ClassCastException`. Generics eliminate this risk by providing compile-time type safety.

Example without generics: List list = new ArrayList();
list.add("Hello");
String str = (String) list.get(0); // Manual casting required

Example with generics: List<String> list = new ArrayList<>();
list.add("Hello");
String str = list.get(0); // No casting needed, type-safe

3. Generic Classes

A generic class can be defined with one or more type parameters. The type parameter allows the class to work with any object type, specified at the time of instantiation.

Example of a generic class: public class Box<T> {
    private T item;
    public void setItem(T item) {
        this.item = item;
    }
    public T getItem() {
        return item;
    }
}

Using the generic class: Box<String> stringBox = new Box<>();
stringBox.setItem("Hello Generics!");
System.out.println(stringBox.getItem()); // Outputs: Hello Generics!

4. Generic Methods

Methods can also be generic. A generic method can have its own type parameters, which makes the method more flexible and reusable.

Example of a generic method: public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

Using the generic method: Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C"};
printArray(intArray);
printArray(strArray);

5. Bounded Type Parameters

You can restrict the types that can be used with generics by using bounded type parameters. For example, you may want to allow only subclasses of `Number` as the type parameter.

Example of bounded type parameters: public class Calculator<T extends Number> {
    public double add(T num1, T num2) {
        return num1.doubleValue() + num2.doubleValue();
    }
}

Using the bounded generic class: Calculator<Integer> calc = new Calculator<>();
System.out.println(calc.add(10, 20)); // Outputs: 30.0

6. Wildcards in Generics

Wildcards are used when you want to allow a generic type to work with a range of types. Java provides three types of wildcards:

• Unbounded Wildcards (`?`): Represents any type.
• Upper Bounded Wildcards (`? extends T`): Represents a type that is a subtype of `T`.
• Lower Bounded Wildcards (`? super T`): Represents a type that is a supertype of `T`.

Example of wildcards: public void processList(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

7. Generics and Inheritance

Generics and inheritance can sometimes be tricky. For example, `List<Integer>` is not a subclass of `List<Object>`, even though `Integer` is a subclass of `Object`. This is because generics are invariant, meaning you cannot assign a `List<Integer>` to a `List<Object>`.

Example illustrating generics and inheritance: List<Integer> intList = new ArrayList<>();
// List<Object> objList = intList; // Compile-time error!

8. Type Erasure

Java implements generics using a feature called type erasure. This means that generic type information is only available at compile-time, and during runtime, it is replaced with `Object` (or the upper bound). This allows backward compatibility with older versions of Java but comes with some limitations.

Example of type erasure: public class Box<T> {
    private T item;
    public void setItem(T item) { this.item = item; }
    public T getItem() { return item; }
}

// At runtime, the generic type T is erased, and it's treated as Object.

9. Best Practices for Using Generics

• Use generics to ensure type safety and avoid casting.
• Favor bounded type parameters for flexibility when designing APIs.
• When working with collections, always use generics to avoid `ClassCastException`.
• Keep in mind the performance impact of boxing/unboxing when using primitive types with generics (e.g., `Integer` instead of `int`).