Generics

🔍 What Is It?

Generic Class:

public class Box<T> {
    private T value;
    public Box(T value) { this.value = value; }
    public T get() { return value; }
}
Box<String> stringBox = new Box<>("hello");
Box<Integer> intBox = new Box<>(42);

Generic Method:

public <T> List<T> repeat(T item, int times) {
    List<T> result = new ArrayList<>();
    for (int i = 0; i < times; i++) result.add(item);
    return result;
}

Bounded Type Parameters:

• →<T extends Comparable<T>> — T must implement Comparable
• →<T extends Number & Serializable> — T must extend Number AND implement Serializable
• →<? extends Animal> — wildcard: any Animal subtype (read-only)
• →<? super Dog> — wildcard: Dog or any supertype (write-only)

Type Erasure:

Generics are a compile-time feature only. At runtime, List<String> and List<Integer> are both just List. Type information is erased. This is why you cannot do: new T() or T.class.

PECS Rule (Producer Extends, Consumer Super):

• →Use <? extends T> when you read from a collection (producer)
• →Use <? super T> when you write to a collection (consumer)

🎯 Why Do We Need It?

Before generics (Java 1.4):

List names = new ArrayList();
names.add("Alice");
names.add(42);  // accidentally added wrong type!
String name = (String) names.get(0);  // cast required
String bad = (String) names.get(1);   // ClassCastException at runtime!

With generics:

List<String> names = new ArrayList<>();
names.add("Alice");
names.add(42);  // COMPILE ERROR — caught at compile time!
String name = names.get(0);  // no cast needed

Generics move type errors from runtime to compile time — much better.

🏗️ What Happens in Real Projects?

Generics are everywhere in enterprise Java:

• →All collections: List<Order>, Map<String, User>, Set<Permission>
• →Repository pattern: Repository<T, ID>
• →Service responses: ApiResponse<T>
• →Result types: Optional<T>, CompletableFuture<T>
• →Spring's ResponseEntity<T>, Page<T>

⚙️ How It Works

Type Erasure in Detail:

The compiler replaces generic types with their bounds (or Object if unbounded):

// Source code
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);

// After erasure (what JVM sees)
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);  // compiler inserts cast

This is why:

• →Cannot create generic arrays: new T[10] is illegal
• →Cannot use instanceof with generics: list instanceof List<String> is illegal
• →Cannot get the generic type at runtime without passing Class<T>

💻 Example

Generics in Enterprise Code — Practical generic patterns for reusable, type-safe enterprise components.

// Generic base repository — reusable for any entity
public interface Repository<T, ID> {
    Optional<T> findById(ID id);
    List<T> findAll();
    T save(T entity);
    void deleteById(ID id);
    boolean existsById(ID id);
}

// Concrete implementation
public class UserRepository implements Repository<User, Long> {
    @Override
    public Optional<User> findById(Long id) {
        return db.query("SELECT * FROM users WHERE id = ?", id)
                 .map(this::mapToUser)
                 .findFirst();
    }
    // ... other methods
}

// Generic API response wrapper
public class ApiResponse<T> {
    private final T data;
    private final String message;
    private final boolean success;
    
    private ApiResponse(T data, String message, boolean success) {
        this.data = data;
        this.message = message;
        this.success = success;
    }
    
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(data, "OK", true);
    }
    
    public static <T> ApiResponse<T> error(String message) {
        return new ApiResponse<>(null, message, false);
    }
    
    // Getters
    public T getData() { return data; }
    public String getMessage() { return message; }
    public boolean isSuccess() { return success; }
}

// Usage
ApiResponse<User> response = ApiResponse.success(user);
ApiResponse<List<Order>> listResponse = ApiResponse.success(orders);

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits