All 15 Generics questions
More in Generics
What is an unbounded wildcard (List<?>), and when is it more appropriate to use than a bounded generic method with a type parameter <T>? How would you implement a generic Stack<T> class from scratch, demonstrating how a self-contained generic data structure is typically structured? What is a raw type in Java, and why does the compiler still permit using them (with an unchecked warning) despite generics having been available since Java 5? How would you use a Class<T> token parameter to work around type erasure when a generic method genuinely needs runtime access to the actual type argument, such as for deserialization or reflection-based instantiation? How do bounded wildcards (? extends T and ? super T) work, and what does the PECS (Producer Extends, Consumer Super) mnemonic mean for choosing between them? How would you implement a generic class with multiple type parameters and bounded type parameters (like <T extends Comparable<T>>), and what does this specific bound enable? How do generics interact with arrays, and why does the JDK itself sometimes use an unsafe cast (like in ArrayList's internal implementation) to work around the inability to create generic arrays directly? How does generic method overload resolution interact with type erasure to sometimes produce a compile error for seemingly valid overloads (like two methods differing only by their generic type parameter)? How would you implement a generic builder pattern with a self-referential generic type parameter (the 'curiously recurring generic pattern', <T extends Builder<T>>) to support fluent method chaining that correctly returns the actual subclass type in an inheritance hierarchy? How does variance (covariance, contravariance, invariance) apply differently to Java arrays versus Java generics, and what practical safety trade-off does this design difference represent?
Advertisement
Java › Generics

How would you write a generic interface (like a custom Repository<T, ID> pattern common in data-access layers) and implement it for a specific entity type?

Intermediate

Answer

A generic interface declares its type parameters at the interface level (interface Repository<T, ID>), with method signatures throughout the interface using those parameters, letting a concrete implementing class specify the actual types when it implements the interface (class UserRepository implements Repository<User, Long>), giving every method in that specific implementation properly typed parameters and return values without needing casts, while the interface itself remains fully reusable across entirely different entity types.
public interface Repository<T, ID> {
    T findById(ID id);
    List<T> findAll();
    T save(T entity);
    void deleteById(ID id);
}

public class UserRepository implements Repository<User, Long> {
    public User findById(Long id) { /* ... */ return null; }
    public List<User> findAll() { /* ... */ return List.of(); }
    public User save(User user) { /* ... */ return user; }
    public void deleteById(Long id) { /* ... */ }
}
Real-world example A data-access layer defines a single generic Repository<T, ID> interface, implemented separately for UserRepository (Repository<User, Long>), ProductRepository (Repository<Product, String>), and every other entity type, giving each implementation fully type-safe, properly-typed methods without any code duplication in the shared interface contract itself.

Common follow-ups: How does Spring Data JPA build heavily on exactly this generic repository interface pattern to auto-generate implementations?;What's the benefit of parameterizing the ID type separately from the entity type T, rather than assuming a fixed ID type?

Interfaces & Abstract Classes;Design Patterns in Java
All 15 Generics questions