Java Generics: Type Safety and Reusability

Generics mean parameterized types. The idea is to allow type (Integer, String, etc., and user-defined types) to be a parameter to methods, classes, and interfaces. This enables you to write a single class or method that can work with different types of data while maintaining strict type safety.

1. The "Why": Before vs. After Generics

To understand the power of Generics, we must look at the "Dark Ages" of Java 1.4 and earlier.

Before Generics (Unsafe)

List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0);

Requires manual casting. No protection against adding an Integer to the same list.

With Generics (Type-Safe)

List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0);

No casting required. Compiler blocks any attempt to add non-String objects.

2. Generic Classes and Interfaces

You can create your own classes that handle any data type by using a Type Parameter (usually denoted by a single capital letter like T, E, or K).

            // A simple Generic Box class

            public class Box<T> {

              private T content;

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

              public T get() { return content; }

            }

3. Bounded Type Parameters

Sometimes you don't want to accept any type; you want to limit the types to a specific family (e.g., only Numbers). This is called a Bounded Type.

public <T extends Number> void process(T num) { ... }

This method will accept Integer, Double, or Float, but will reject String at compile time.

4. Wildcards: The Flexible ? Symbol

Wildcards represent an unknown type. They are essential when writing methods that operate on collections of different related types.

Type	Syntax	Meaning
Upper Bounded	`? extends T`	Accepts T or any subclass of T (Best for Reading).
Lower Bounded	`? super T`	Accepts T or any superclass of T (Best for Writing).
Unbounded	`?`	Accepts any type.

5. Type Erasure: The Hidden Reality

It is crucial to understand that Generics in Java are a Compile-time feature. To maintain backward compatibility with older Java versions, the Java compiler uses a process called Type Erasure.

The compiler replaces all type parameters with their bounds (or Object if unbounded).
The compiler inserts necessary casts.
The Result: At runtime, a List<String> and a List<Integer> are exactly the same class: ArrayList.class.

6. Restrictions of Generics

Because of Type Erasure, there are things you simply cannot do with Generics:

No Primitives: You cannot use List<int>. You must use List<Integer>.
No Instance Creation: You cannot do T obj = new T(); because T is erased at runtime.
No Static Fields: You cannot have a static field of type T.
No Arrays of Generics: List<Integer>[] array = new ArrayList<Integer>[10]; is illegal.

7. Mastery Code Example: Generic Utility Method

This method swaps two elements in an array of any type. This is the pinnacle of code reusability.

            public class AlgoUtils {

              // Generic Method Syntax

              public static <T> void swap(T[] array, int i, int j) {

                T temp = array[i];

                array[i] = array[j];

                array[j] = temp;

              }

              public static void main(String[] args) {

                String[] names = {"Alice", "Bob"};

                swap(names, 0, 1); // Works for Strings

                Integer[] nums = {10, 20};

                swap(nums, 0, 1); // Works for Integers

              }

            }

8. Interview Preparation: The Generics Q&A

Q: What is the PECS principle?
A: Producer Extends, Consumer Super. If you are reading from a collection, use ? extends T. If you are adding to a collection, use ? super T.

Q: Can you explain Type Erasure in one sentence?
A: It is the process where the compiler removes all generic type information and replaces it with raw types and casts to ensure compatibility with pre-generic JVMs.

Q: Why can't we use primitives as type parameters?
A: Generics are erased to Object, and in Java, primitives (like int) do not inherit from Object. This is why we use Wrapper classes.

Final Verdict

Generics are the reason modern Java is robust and clean. By enabling type safety at compile time, they eliminate a whole class of runtime errors. While Type Erasure imposes some limits, the ability to write reusable, type-safe logic for classes and methods is one of the most important skills a Java developer can master.

Next: Comparable vs. Comparator →