Generics in Java: A Comprehensive Guide

Generics in Java are a powerful feature introduced in Java 5 that allow developers to write reusable and type-safe code. While primarily used in collections, their applications extend far beyond. Generics enable you to specify types at compile-time, reducing runtime errors and enhancing code readability.

Key Concepts of Generics

1. Type Safety

   Generics ensure that only the specified type of data can be added to a collection or used in a method, preventing runtime ClassCastException.

2. Code Reusability

   A single generic class, method, or interface can work with various types of data, reducing redundancy and promoting code reuse.

How Generics Work

1. Generic Classes > Generic classes allow you to define a class that works with any data type. Here's an example:

class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello");
        System.out.println(stringBox.getItem());

        Box<Integer> intBox = new Box<>();
        intBox.setItem(123);
        System.out.println(intBox.getItem());
    }
}

1. Generic Methods > Generic methods allow type parameters to be used in method definitions.

class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"A", "B", "C"};
        Util.printArray(intArray);
        Util.printArray(strArray);
    }
}

1. Bounded Type Parameters > Type parameters can be constrained using extends or super.
2. Upper Bound (extends): Ensures the type is a subclass of the specified type.

class MathUtils {
    public static <T extends Number> double square(T number) {
        return number.doubleValue() * number.doubleValue();
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(5));    // Integer
        System.out.println(MathUtils.square(5.5)); // Double
    }
}

• Lower Bound (super): Ensures the type is a superclass of the specified type.

1. Wildcards > Wildcards (?) represent an unknown type and offer flexibility when working with generics.
2. Unbounded Wildcard:

public static void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

• Upper Bounded Wildcard:

public static void printNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

• Lower Bounded Wildcard:

public static void addNumbers(List<? super Integer> list) {
    list.add(10); // Only Integer or its subclass can be added
}

Generics and Collections

The Java Collections Framework heavily relies on generics to provide type safety.

• Example: Using Generics with Lists

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

• Example: Using Generics with Maps

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");

        for (Integer key : map.keySet()) {
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }
    }
}

Advantages of Generics

1. Type Safety:

   Prevents runtime errors by catching type mismatches at compile time.

2. Code Reusability:

   Allows writing flexible, reusable code for any type.

3. Performance:

   Reduces runtime overhead by eliminating the need for explicit typecasting.

Limitations of Generics

1. Type Erasure:

   Generics are implemented using type erasure, so the type information is not available at runtime.

2. Primitive Types Not Allowed:

   Generics work only with objects. Use wrapper classes like Integer for int.

3. No Static Members:

   Generic classes cannot define static fields or methods using the type parameter.

Conclusion

Generics in Java are essential for writing robust, maintainable, and efficient code. By leveraging type safety and code reusability, developers can handle data more effectively. Whether you're working with collections or creating custom classes, mastering generics is crucial for advanced Java development.