Creating a Custom Generic Class in Java

In Java, a class is a blueprint for creating objects. It defines the properties and behaviors of an object. A generic class is a class that can work with any type of data. In this article, we will explore how to create a custom generic class in Java.

Creating a Generic Class

To create a generic class, we use the syntax:

class ClassName<T> {
    // class members
}

Here, T is a type parameter that can be replaced by any type when an instance of the class is created. We can use any identifier instead of T, but it is a convention to use T for type parameters.

Let's create a generic class named Box that can hold any type of object.

class Box<T> {
    private T object;
    public void setObject(T object) {
        this.object = object;
    }
    public T getObject() {
        return object;
    }
}

In this example, we have defined a generic class named Box that has a type parameter T. The class has two methods, setObject and getObject, that set and get the value of the object stored in the Box object.

Using a Generic Class

To use a generic class, we need to create an instance of the class by specifying the type parameter. Here is an example:

Box<String> box = new Box<String>();
box.setObject("Hello, world!");
String message = box.getObject();
System.out.println(message);

In this example, we have created an instance of the Box class with the type parameter String. We have set the value of the Box object to "Hello, world!" and retrieved it using the getObject method.

Generic Class Constraints

Java allows us to impose constraints on the type parameter of a generic class. We can specify that the type parameter should extend a particular class or implement a particular interface. This is called a bounded type parameter.

Here's an example of a generic class with a bounded type parameter:

class Box<T extends Number> {
    private T object;

    public void setObject(T object) {
        this.object = object;
    }

    public T getObject() {
        return object;
    }
}

In this example, we have imposed a constraint on the type parameter T. We have specified that T should be a subclass of the Number class. This means that T can be any of the following classes: Byte, Short, Integer, Long, Float, or Double.

Advantages of Generic Classes

Generic classes have several advantages. They provide type safety, which means that the compiler can detect type mismatches at compile-time. This helps to avoid runtime errors that can be difficult to debug.

Generic classes also improve code reuse. By creating a generic class, we can write code that works with any type of data. This can reduce code duplication and make the code easier to maintain. Creating a custom generic class in Java is a powerful tool that allows us to write flexible and reusable code. By using generic classes, we can create classes that work with any type of data, providing type safety and improving code reuse.

Here's an example program that demonstrates creating a generic class in Java:

Main.java

public class Main {
    public static void main(String[] args) {
        // create a Box object for String type
        Box<String> stringBox = new Box<>();
        stringBox.setObject("Hello, world!");
        String str = stringBox.getObject();
        System.out.println("String box value: " + str);
        // create a Box object for Integer type
        Box<Integer> integerBox = new Box<>();
        integerBox.setObject(42);
        int i = integerBox.getObject();
        System.out.println("Integer box value: " + i);
    }
}
class Box<T> {
    private T object;
    public void setObject(T object) {
        this.object = object;
    }
    public T getObject() {
        return object;
    }
}

Output:

String box value: Hello, world!
Integer box value: 42

In this program, we have created a generic class Box that can hold any type of data. We have then created two instances of Box class, one for String type and another for Integer type. We have set and retrieved the values stored in the Box objects using the setObject and getObject methods respectively. Finally, we have printed the values to the console.

Conclusion

Creating a custom generic class in Java allows us to write flexible and reusable code that can work with any type of data. We can impose constraints on the type parameter and use type inference to simplify the code. However, we should be aware of type erasure and how it affects the bytecode.

Next TopicGeneric Queue Java

← prev next →