How to Declare a Generic Class in Java?

Introduction to Generics in Java

In Java, generics provide a way to write classes, interfaces, and methods with type parameters. This enables you to write more flexible, reusable, and type-safe code. A generic class allows you to define the class in such a way that it can operate on any type of object, which is provided when the class is instantiated. This eliminates the need for casting and improves the readability and safety of your code.

Generics were introduced in Java 5 with the aim of improving the language’s ability to work with various data types without compromising type safety. In this guide, we will explore how to declare a generic class in Java, understand its syntax, and use it effectively with various examples.

Declaring a Generic Class in Java

To declare a generic class in Java, you use angle brackets (< >) to specify the type parameter. The type parameter can be any valid identifier, but by convention, a single uppercase letter is used to denote the type. The type parameter can then be used throughout the class to represent a specific data type.

Syntax of a Generic Class

// Syntax of a generic class in Java
class ClassName<T> {
    private T value;

    public ClassName(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}
        

In the example above, <T> is a placeholder for the data type, and this type is specified when you create an object of the class. Let’s break it down:

• <T>: The type parameter, which will be replaced by a concrete type when an object is instantiated.
• ClassName<T>: The class name followed by the type parameter.
• value: A private field of type T (the generic type).
• Constructor: A constructor that takes an argument of type T to initialize the value field.
• Methods: The methods getValue() and setValue(T value) allow interaction with the generic type.

Now, let’s take a look at an example of how to use this generic class in a real Java application.

Code Example: Using a Generic Class

// Example of using a generic class
public class Main {
    public static void main(String[] args) {
        // Create a generic object with Integer type
        ClassName<Integer> integerObj = new ClassName<>(10);
        System.out.println("Integer Value: " + integerObj.getValue());

        // Create a generic object with String type
        ClassName<String> stringObj = new ClassName<>("Hello, Generics!");
        System.out.println("String Value: " + stringObj.getValue());
    }
}
        

In this example, we created two objects of the ClassName class:

• One with the Integer type, holding the value 10.
• One with the String type, holding the value “Hello, Generics!”.

This demonstrates how the same generic class can be used with different types, making it more reusable and type-safe.

Benefits of Using Generic Classes

Generics offer several key benefits to developers working with Java:

• Type Safety: Generics allow for compile-time type checking, which eliminates the risk of ClassCastException and improves the overall reliability of your program.
• Code Reusability: Instead of writing separate classes for different data types, you can create one generic class that works with any type.
• Elimination of Casting: With generics, you no longer need to cast objects when retrieving values, as the type is already known.
• Cleaner Code: Generics help in reducing boilerplate code and make the code more concise and readable.

Let’s explore some advanced features and constraints of generics in Java.

Advanced Generic Class Features

Generic Class with Multiple Type Parameters

A generic class in Java can have multiple type parameters. To declare a class with multiple generic types, you separate them with commas inside the angle brackets. Here’s how it works:

// Declaring a generic class with multiple type parameters
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;
    }
}
        

In this case, Pair<K, V> is a generic class that holds two values of types K and V.

Code Example: Using a Generic Class with Multiple Type Parameters

// Example of using a generic class with multiple type parameters
public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> pair = new Pair<>("Age", 25);
        System.out.println(pair.getKey() + ": " + pair.getValue());
    }
}
        

In this example, the Pair class stores a String as the key and an Integer as the value.

Using Bounded Type Parameters in Generics

Sometimes, you want to restrict the types that can be used with generics. This can be done by specifying a “bound” on the type parameter. You use the <T extends SomeClass> syntax to define an upper bound.

// Declaring a generic class with bounded type parameters
class Box<T extends Number> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}
        

In the example above, the Box<T> class can only accept types that are subclasses of Number, such as Integer, Double, etc.

Conclusion

Generics are a powerful feature in Java that enhances code reusability, type safety, and flexibility. By using generic classes, you can write more generic code that works with any data type while ensuring compile-time type checking. In this guide, we explored how to declare and use generic classes, advanced features like multiple type parameters, and how to restrict types using bounds. With these tools, you can write cleaner, more maintainable Java code.