Generic Classes and Generic Interfaces0%

Generic Methods and Bounded Type Parameters (<T extends Number>)

Generic Classes and Generic Interfaces

Advanced14 min read•Updated: 2025-01-15

📦 Generic Classes and Generic Interfaces

Introduction

Beyond using built-in generic collections like List<T> and Map<K, V>, Java enables developers to design custom generic classes and interfaces. A generic type is a class or interface that is parameterized over types, allowing you to write reusable algorithms and data structures that work across multiple data models with 100% type safety.

🏷️ Standard Type Parameter Naming Conventions

By Java language convention, single uppercase letters represent type parameters:

T: General Type
E: Element (extensively used in Collections)
K: Key (used in Maps)
V: Value (used in Maps)
N: Number
R: Return type / Result

💻 1. Defining a Generic Class

Let's build a type-safe generic container Container<T> and a multi-type Pair<K, V>:

1package com.mskinstitute.generics;
2 
3// Single-parameter generic class
4public class Container<T> {
5    private T item;
6 
7    public Container(T item) {
8        this.item = item;
9    }
10 
11    public T getItem() {
12        return item;
13    }
14 
15    public void setItem(T item) {
16        this.item = item;
17    }
18}

Multi-Type Parameter Class (`Pair<K, V>`):

1public class Pair<K, V> {
  private final K key;
  private final V value;
4 
  public Pair(K key, V value) {
      this.key = key;
      this.value = value;
  }
9 
  public K getKey() { return key; }
  public V getValue() { return value; }
12 
  @Override
  public String toString() {
      return "Pair[" + key + " => " + value + "]";
  }
17}

🔌 2. Defining Generic Interfaces

In enterprise Java architectures, generic interfaces are the foundation of the Repository Pattern:

1package com.mskinstitute.generics;
2 
3import java.util.List;
4import java.util.Optional;
5 
6// Generic Interface
7public interface Repository<T, ID> {
8    void save(T entity);
9    Optional<T> findById(ID id);
10    List<T> findAll();
11    boolean deleteById(ID id);
12}

Implementing a Generic Interface with a Concrete Entity:

1public class StudentRepository implements Repository<Student, Long> {
  private final java.util.Map<Long, Student> database = new java.util.HashMap<>();
3 
  @Override
  public void save(Student student) {
      database.put(student.id(), student);
  }
8 
  @Override
  public Optional<Student> findById(Long id) {
      return Optional.ofNullable(database.get(id));
  }
13 
  @Override
  public List<Student> findAll() {
      return new java.util.ArrayList<>(database.values());
  }
18 
  @Override
  public boolean deleteById(Long id) {
      return database.remove(id) != null;
  }
23}

📊 Summary Comparison

Aspect	Concrete Class	Generic Class (`Class<T>`)
Data Scope	Fixed to one type (e.g. `StringBox`)	Flexible for any type (`Box<Student>`, `Box<Integer>`)
Code Duplication	High (must write `IntBox`, `DoubleBox`)	Zero (one unified implementation)
Type Safety	Safe for its dedicated type	Fully type-safe for all parameterizations

Next Lesson

Generic Methods and Bounded Type Parameters (<T extends Number>)

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
The Need for Generics: Compile-Time Type Safety and Elimination of Casts	Generic Methods and Bounded Type Parameters (<T extends Number>)

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Introduction

💻 1. Defining a Generic Class

Let's build a type-safe generic container Container<T> and a multi-type Pair<K, V>:

1package com.mskinstitute.generics;
2 
3// Single-parameter generic class
4public class Container<T> {
5    private T item;
6 
7    public Container(T item) {
8        this.item = item;
9    }
10 
11    public T getItem() {
12        return item;
13    }
14 
15    public void setItem(T item) {
16        this.item = item;
17    }
18}

Multi-Type Parameter Class (Pair<K, V>):

1public class Pair<K, V> {
  private final K key;
  private final V value;
4 
  public Pair(K key, V value) {
      this.key = key;
      this.value = value;
  }
9 
  public K getKey() { return key; }
  public V getValue() { return value; }
12 
  @Override
  public String toString() {
      return "Pair[" + key + " => " + value + "]";
  }
17}

🔌 2. Defining Generic Interfaces

In enterprise Java architectures, generic interfaces are the foundation of the Repository Pattern:

1package com.mskinstitute.generics;
2 
3import java.util.List;
4import java.util.Optional;
5 
6// Generic Interface
7public interface Repository<T, ID> {
8    void save(T entity);
9    Optional<T> findById(ID id);
10    List<T> findAll();
11    boolean deleteById(ID id);
12}

Implementing a Generic Interface with a Concrete Entity:

1public class StudentRepository implements Repository<Student, Long> {
  private final java.util.Map<Long, Student> database = new java.util.HashMap<>();
3 
  @Override
  public void save(Student student) {
      database.put(student.id(), student);
  }
8 
  @Override
  public Optional<Student> findById(Long id) {
      return Optional.ofNullable(database.get(id));
  }
13 
  @Override
  public List<Student> findAll() {
      return new java.util.ArrayList<>(database.values());
  }
18 
  @Override
  public boolean deleteById(Long id) {
      return database.remove(id) != null;
  }
23}

📊 Summary Comparison

Aspect	Concrete Class	Generic Class (`Class<T>`)
Data Scope	Fixed to one type (e.g. `StringBox`)	Flexible for any type (`Box<Student>`, `Box<Integer>`)
Code Duplication	High (must write `IntBox`, `DoubleBox`)	Zero (one unified implementation)
Type Safety	Safe for its dedicated type	Fully type-safe for all parameterizations

Previous Lesson

Next Lesson

The Need for Generics: Compile-Time Type Safety and Elimination of Casts

Generic Methods and Bounded Type Parameters (<T extends Number>)

📦 Generic Classes and Generic Interfaces

Introduction

🏷️ Standard Type Parameter Naming Conventions

💻 1. Defining a Generic Class

Multi-Type Parameter Class (Pair<K, V>):

🔌 2. Defining Generic Interfaces

Implementing a Generic Interface with a Concrete Entity:

📊 Summary Comparison

Generic Methods and Bounded Type Parameters (<T extends Number>)

Related Lessons

Practice Quiz

Loading Page Content...

📦 Generic Classes and Generic Interfaces

Introduction

🏷️ Standard Type Parameter Naming Conventions

💻 1. Defining a Generic Class

Multi-Type Parameter Class (Pair<K, V>):

🔌 2. Defining Generic Interfaces

Implementing a Generic Interface with a Concrete Entity:

📊 Summary Comparison

Generic Methods and Bounded Type Parameters (<T extends Number>)

Related Lessons

Practice Quiz

Multi-Type Parameter Class (`Pair<K, V>`):

Multi-Type Parameter Class (`Pair<K, V>`):