Generics

Introduction

In the previous lessons, you learned about:

• Collections Framework
• Streams API
• Lambda Expressions
• Multithreading

Consider the following code:

ArrayList list = new ArrayList();

list.add("Java");

list.add(100);

list.add(true);

This code compiles successfully because the collection is using a raw type.

However, later:

String language = (String) list.get(1);

Output:

Exception in thread "main"
java.lang.ClassCastException

The problem is that the compiler cannot verify the type of elements stored in the collection.

Java solves this problem using Generics.

Generics provide compile-time type safety, eliminate unnecessary casting, and make code reusable.

Introduced in Java 5, Generics are one of the most important features used throughout the Java ecosystem.

Generics are extensively used in:

• Java Collections Framework
• Streams API
• Spring Boot
• Hibernate
• JPA
• Kafka
• REST APIs
• Microservices
• Java Concurrency APIs

Understanding Generics is essential for writing modern, type-safe Java applications.

In this lesson, you'll learn:

• What are Generics?
• Why Generics?
• Generic Classes
• Generic Methods
• Multiple Type Parameters
• Bounded Type Parameters
• Wildcards
• Upper Bounded Wildcards
• Lower Bounded Wildcards
• Type Erasure
• Generic Collections
• PECS Principle
• Best Practices
• Common Mistakes
• Hands-on Exercises
• Professional Interview Questions

What are Generics?

Generics allow classes, interfaces, and methods to operate on different data types while maintaining compile-time type safety.

Instead of writing:

ArrayList list =
        new ArrayList();

Write:

List<String> list =
        new ArrayList<>();

Now only String objects can be added.

Why Generics?

Without Generics:

List list =
        new ArrayList();

list.add("Java");

list.add(100);

Later:

String text =
        (String) list.get(1);

Runtime Error.

With Generics:

List<String> list =
        new ArrayList<>();

list.add("Java");

// Compilation Error
list.add(100);

The compiler catches the error before the program runs.

Benefits:

• Compile-time type safety
• No explicit casting
• Cleaner code
• Better IDE support
• Code reusability

Generic Class

Example:

class Box<T> {

    private T value;

    public void set(T value){

        this.value = value;

    }

    public T get(){

        return value;

    }

}

Using it:

Box<String> box =
        new Box<>();

box.set("Java");

System.out.println(box.get());

Output:

Java

Generic Class with Different Types

Box<Integer> numberBox =
        new Box<>();

numberBox.set(100);

Box<Double> decimalBox =
        new Box<>();

decimalBox.set(99.99);

The same class works with multiple data types.

Multiple Type Parameters

A class can have multiple generic types.

class Pair<K, V>{

    private K key;

    private V value;

    public Pair(K key, V value){

        this.key = key;
        this.value = value;

    }

    public K getKey(){

        return key;

    }

    public V getValue(){

        return value;

    }

}

Using it:

Pair<Integer,String> employee =

new Pair<>(101,"Rahul");

Generic Methods

Generics can also be applied to methods.

public static <T> void print(T value){

    System.out.println(value);

}

Calling:

print("Java");

print(100);

print(true);

Output:

Java
100
true

Generic Interfaces

Example:

interface Repository<T>{

    void save(T entity);

    T findById(int id);

}

Implementation:

class EmployeeRepository

implements Repository<Employee>{

    @Override
    public void save(Employee entity){

    }

    @Override
    public Employee findById(int id){

        return new Employee();

    }

}

Bounded Type Parameters

Sometimes we want to restrict generic types.

Example:

class Calculator<T extends Number>{

    public double square(T value){

        return value.doubleValue() *
               value.doubleValue();

    }

}

Allowed:

Calculator<Integer> c1 =
        new Calculator<>();

Calculator<Double> c2 =
        new Calculator<>();

Not Allowed:

Calculator<String> c3 =
        new Calculator<>();

Compilation Error.

Multiple Bounds

<T extends Number & Comparable<T>>

The type must:

• Extend Number
• Implement Comparable

Wildcards

Wildcard:

?

Represents an unknown type.

Example:

List<?> list;

Useful when the exact type is not important.

Upper Bounded Wildcards

List<? extends Number>

Accepts:

• Integer
• Double
• Float
• Long

Example:

public void printNumbers(

List<? extends Number> numbers){

    for(Number number : numbers){

        System.out.println(number);

    }

}

You can safely read from the list, but you cannot add arbitrary Number objects because the actual subtype is unknown.

Lower Bounded Wildcards

List<? super Integer>

Accepts:

• Integer
• Number
• Object

Example:

public void addNumbers(

List<? super Integer> list){

    list.add(10);

}

Lower-bounded wildcards are useful when adding elements.

PECS Principle

One of the most important interview topics.

PECS means:

Producer Extends

Consumer Super

Example:

List<? extends Number> producer;

List<? super Integer> consumer;

Type Erasure

Generics exist only at compile time.

Compiler:

List<String> names =
        new ArrayList<>();

Becomes (conceptually after compilation):

List names =
        new ArrayList();

The compiler inserts necessary casts where required.

Consequences:

• Generic type information is not available at runtime.
• You cannot create arrays of parameterized types.
• You cannot use instanceof with specific generic arguments.

Generic Collections

List<String> names =
        new ArrayList<>();

Set<Integer> marks =
        new HashSet<>();

Map<Integer,String> employees =
        new HashMap<>();

Generics make collections type-safe.

Diamond Operator

Java 7 introduced:

List<String> names =
        new ArrayList<>();

Instead of:

List<String> names =
        new ArrayList<String>();

The compiler infers the generic type.

Generic Arrays

This is invalid:

new T[10];

Reason:

Type erasure prevents creating arrays of a generic type parameter directly.

A common alternative is to use collections such as ArrayList<T>.

Real-World Example: Spring Repository

interface Repository<T>{

    void save(T entity);

}

Every Spring Data repository uses generics to work with different entity types while maintaining type safety.

Real-World Example: Generic Service

class Response<T>{

    private T data;

    public T getData(){

        return data;

    }

}

Using it:

Response<Employee> response =
        new Response<>();

Best Practices

Always Use Generics

Prefer:

List<String> list =
        new ArrayList<>();

Instead of raw collections.

Avoid Raw Types

Raw types bypass compile-time type checking and should generally be avoided.

Prefer Interfaces

List<Employee> employees =
        new ArrayList<>();

Rather than:

ArrayList<Employee> employees =
        new ArrayList<>();

Follow PECS

• Read → extends
• Write → super

Use Meaningful Type Names

Common conventions:

• T → Type
• E → Element
• K → Key
• V → Value
• R → Result

Common Mistakes

Using Raw Types

Raw collections lose type safety.

Confusing extends and super

Remember the PECS principle.

Assuming Generic Information Exists at Runtime

Type erasure removes generic type information during compilation.

Creating Generic Arrays

Prefer collections instead.

Excessive Wildcard Usage

Use wildcards only when flexibility is required. Otherwise, use concrete generic types.

Hands-on Exercise

Create a Java program that:

1. Creates a generic Box<T> class.
2. Creates a generic Pair<K,V> class.
3. Implements a generic Repository<T> interface.
4. Creates a generic method to print any object.
5. Creates a Calculator<T extends Number> class.
6. Demonstrates ? extends and ? super.
7. Applies the PECS principle with two methods.
8. Uses generics with List, Set, and Map.
9. Demonstrates the diamond operator.
10. Explains why generic arrays are not allowed.

Summary

Java Generics provide compile-time type safety, eliminate unnecessary casting, and enable reusable, flexible APIs. They form the foundation of the Java Collections Framework, Streams API, Spring Data repositories, and many enterprise libraries. Understanding bounded type parameters, wildcards, the PECS principle, and type erasure is essential for writing modern Java applications and succeeding in technical interviews.

Key Takeaways

• Generics provide compile-time type safety.
• Generic classes, methods, and interfaces increase code reusability.
• Bounded type parameters restrict allowable types.
• ? extends is used for producers (reading).
• ? super is used for consumers (writing).
• PECS stands for Producer Extends, Consumer Super.
• Type erasure removes generic type information at runtime.
• Prefer generic collections over raw collections.
• Use the diamond operator (<>) for cleaner code.

Professional Interview Questions