Java Generics Best Practices

To make the most of Java generics and ensure effective usage, consider the following best practices:

If you don’t have a medium membership, you can use this link to reach the article without a paywall.

Be explicit

Provide explicit type parameters whenever possible to enhance code readability and maintainability. Avoid relying on raw types or the compiler’s type inference alone.

Generic Class with Explicit Type Parameter

Let’s create a generic class called Box that can hold any type of object. By providing an explicit type parameter, we make it clear what type the Box will contain.

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

// Usage of the generic class with explicit type parameter
Box<String> stringBox = new Box<>("Hello, World!");
Box<Integer> integerBox = new Box<>(42);

In the example above, we explicitly specify the type parameter when creating instances of the Box class. This enhances code readability and makes it evident what type of data the Box will contain.

Generic Method with Explicit Type Parameter

Let’s create a generic method called printArray, which prints the elements of an array of any type. By providing an explicit type parameter, we ensure that the method works with a specific type.

public class GenericExample {

    // Generic method with explicit type parameter
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Usage of the generic method with explicit type parameter
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"apple", "banana", "cherry"};

        System.out.print("Integer Array: ");
        printArray(intArray);

        System.out.print("String Array: ");
        printArray(stringArray);
    }
}

In the example above, we explicitly specify the type parameter <T> in the printArray method. This ensures that the method can work with arrays of any type while still being type-safe.

Use bounded type parameters

Utilize bounded type parameters to enforce constraints on the allowed types. By specifying an upper bound for a type parameter, you can ensure that only compatible types can be used.

Bounded Type Parameter in Generic Class

Suppose we want to create a generic class that operates on numeric data types only. We can use bounded type parameters to ensure that only classes that extend the Number class (or implement it) can be used as the type argument.

public class MathOperation<T extends Number> {
    private T operand1;
    private T operand2;

    public MathOperation(T operand1, T operand2) {
        this.operand1 = operand1;
        this.operand2 = operand2;
    }

    public double add() {
        return operand1.doubleValue() + operand2.doubleValue();
    }

    public double multiply() {
        return operand1.doubleValue() * operand2.doubleValue();
    }
}

// Usage of the generic class with bounded type parameter
MathOperation<Integer> intMath = new MathOperation<>(5, 10);
System.out.println("Addition: " + intMath.add()); // Output: Addition: 15.0
System.out.println("Multiplication: " + intMath.multiply()); // Output: Multiplication: 50.0

// This will cause a compilation error because String doesn't extend Number
MathOperation<String> stringMath = new MathOperation<>("Hello", "World");

In the example, we use the bounded type parameter <T extends Number> to enforce that T can only be a subtype of Number. This ensures that we can safely use numeric operations inside the MathOperation class.

Bounded Type Parameter in Methods

Let’s create a generic method that sum all the given arguments, but we want to restrict it to work only with lists of objects that extends the Number class to be able to convert given arguments to double. We can achieve this using bounded type parameter.

import java.util.Arrays;

public class MathOperationExample {

    // Generic method with bounded wildcard
    public static <T extends Number> double sumAsDouble(T... args) {
        if (args == null || args.length == 0) {
            throw new IllegalArgumentException("Args is empty or null");
        }

        return Arrays.stream(args).mapToDouble(Number::doubleValue).sum();
    }

    public static void main(String[] args) {

        // Usage of the generic class with bounded type parameter
        MathOperation<Integer> intMath = new MathOperation<>(5, 10);
        System.out.println("Addition: " + intMath.add()); // Output: Addition: 15.0
        System.out.println("Multiplication: " + intMath.multiply()); // Output: Multiplication: 50.0

        // Below comment outed code will cause a compilation error because String doesn't extend Number
        // MathOperation<String> stringMath = new MathOperation<>("Hello", "World");

        double sum = sumAsDouble(Integer.valueOf(5), Double.valueOf(6.3));
        System.out.println("Sum of 5 and 6.3 : " + sum ); // Output: Sum of 5 and 6.3 : 11.3
        // Below comment outed code will cause a compilation error because String doesn't extend Number
        //double sumError = sumAsDouble(Integer.valueOf(5), Double.valueOf(6.3), String.valueOf(1));
    }
}

In the example above, the method sumAsDouble uses a bounded type parameter<T extends Number>. This ensures that the method can only be called with a list of elements that extend the Number abstract class. It guarantees that the elements in the list can be converted to double values and, therefore, all values can be summed.

Avoid raw types

Minimize the usage of raw types, as they bypass type safety checks and can lead to potential runtime errors. Migrate from raw types to generics whenever feasible.

Raw types are generic types without type arguments, and they bypass the type safety checks provided by generics. Let’s see an example to illustrate the importance of avoiding raw types:

import java.util.ArrayList;
import java.util.List;

public class RawTypeExample {

    public static void main(String[] args) {
        // Creating a raw type (avoid this)
        List rawList = new ArrayList();
        rawList.add("Hello");    // String element
        rawList.add(42);         // Integer element

        // Getting elements from the raw list without type safety
        String strElement = (String) rawList.get(0);
        Integer intElement = (Integer) rawList.get(1);

        System.out.println("String Element: " + strElement);
        System.out.println("Integer Element: " + intElement);

        // This line of code will cause a RunTimeException
        Integer intError = (Integer) rawList.get(0);
    }
}

In this example, we create a raw type List without specifying its type argument. Consequently, we can add elements of different types (String and Integer) to the list without any compiler warnings. However, when retrieving elements from the list, we must cast them explicitly to their respective types.

The use of raw types can lead to runtime errors if the types are not correctly cast, or if different types are added and retrieved from the list, resulting in ClassCastException at runtime.

Utilize wildcards

Employ wildcards (?) when the exact type is not known or when dealing with unknown or heterogeneous types. Wildcards provide flexibility while still maintaining type safety.

Upper-Bounded Wildcard (? extends T)

Suppose we have a method that calculates the sum of numbers in a list, but we want to restrict it to work with lists of a specific type or its subclasses. We can use an upper-bounded wildcard.

import java.util.List;

public class WildcardUpperBoundedExample {

    // Method that calculates the sum of numbers in a list (upper-bounded wildcard)
    public static double sumOfList(List<? extends Number> list) {
        double sum = 0.0;
        for (Number num : list) {
            sum += num.doubleValue();
        }
        return sum;
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        double intSum = sumOfList(intList);
        System.out.println("Sum of Integers: " + intSum); // Output: Sum of Integers: 6.0

        List<Double> doubleList = List.of(1.5, 2.5, 3.5);
        double doubleSum = sumOfList(doubleList);
        System.out.println("Sum of Doubles: " + doubleSum); // Output: Sum of Doubles: 7.5

        // This will cause a compilation error since String is not a subclass of Number
        // List<String> stringList = List.of("one", "two", "three");
        // double stringSum = sumOfList(stringList);
    }
}

In this example, the method sumOfList accepts a list of any type that extends Number (or is a subclass of Number). This allows us to work with both Integer and Double lists, as they are both subclasses of Number. However, trying to use a List<String> will result in a compilation error because String is not a subclass of Number.

Lower-Bounded Wildcard (? super T)

Let’s consider a scenario where we want to implement a method that adds elements to a list, but we want to ensure that we can add elements of a specific type or its superclasses. We can use a lower-bounded wildcard for this.

import java.util.ArrayList;
import java.util.List;

public class WildcardLowerBoundedExample {

    // Method that adds elements to a list (lower-bounded wildcard)
    public static void addElements(List<? super Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        addElements(numberList);
        System.out.println("Number List: " + numberList); // Output: Number List: [1, 2, 3]

        List<Object> objectList = new ArrayList<>();
        addElements(objectList);
        System.out.println("Object List: " + objectList); // Output: Object List: [1, 2, 3]

        // This will cause a compilation error since String is not a superclass of Integer
        // List<String> stringList = new ArrayList<>();
        // addElements(stringList);
    }
}

In this example, the method addElements accepts a list of any type that is a superclass of Integer. This allows us to work with both List<Number> and List<Object>, as they are both superclasses of Integer. However, attempting to use a List<String> will result in a compilation error since String is not a superclass of Integer.

Follow naming conventions

Use meaningful names for type parameters to enhance code readability and understandability. Use single uppercase letters (e.g., T, E, K, V) to represent type parameters.

By using meaningful names like T, E, K, or V for type parameters, you improve the code's readability and make it easier for others to understand the purpose of those generic types. If you used obscure or non-standard names for type parameters, it would make the code less intuitive and more difficult to comprehend.

Leverage generic methods

Take advantage of generic methods to write reusable code that can work with multiple types. This can reduce code duplication and improve code organization. By creating generic methods, you can reduce code duplication, improve code organization, and promote a more flexible and maintainable codebase.

Consider generic interfaces and abstract classes

Use generic interfaces and abstract classes to define common behavior for multiple related types. This promotes code reusability and facilitates abstraction.

// Generic interface to represent a shape
interface Shape<T> {
    double calculateArea();
    double calculatePerimeter();
    T getShapeInfo();
}

// class to implement the Shape interface for rectangles
class Rectangle<T extends Number> implements Shape<T> {
    private T length;
    private T width;

    public Rectangle(T length, T width) {
        this.length = length;
        this.width = width;
    }

    public double calculateArea() {
        return length.doubleValue() * width.doubleValue();
    }

    public double calculatePerimeter() {
        return 2 * (length.doubleValue() + width.doubleValue());
    }

    public T getShapeInfo() {
        return length;
    }
}

// class to implement the Shape interface for circles
class Circle<T extends Number> implements Shape<T> {
    private T radius;

    public Circle(T radius) {
        this.radius = radius;
    }

    public double calculateArea() {
        return Math.PI * radius.doubleValue() * radius.doubleValue();
    }

    public double calculatePerimeter() {
        return 2 * Math.PI * radius.doubleValue();
    }

    public T getShapeInfo() {
        return radius;
    }
}

public class GenericShapesExample {
    public static void main(String[] args) {
        // Creating a rectangle and a circle
        Shape<Integer> rectangle = new Rectangle<>(5, 3);
        Shape<Double> circle = new Circle<>(2.5);

        // Calculating and displaying their areas and perimeters
        System.out.println("Rectangle Area: " + rectangle.calculateArea()); // Output: Rectangle Area: 15.0
        System.out.println("Rectangle Perimeter: " + rectangle.calculatePerimeter()); // Output: Rectangle Perimeter: 16.0
        System.out.println("Circle Area: " + circle.calculateArea()); // Output: Circle Area: 19.634954084936208
        System.out.println("Circle Perimeter: " + circle.calculatePerimeter()); // Output: Circle Perimeter: 15.707963267948966
    }
}

In this example, we define a generic interface called Shape, which represents common behavior for shapes. We then create two classes, Rectangle and Circle, that implement the Shape interface for rectangles and circles, respectively.

By using generic interfaces and classes, we create a generic framework for shapes, allowing us to define specific implementations for different types while still benefiting from the common behavior defined in the interface.

This approach promotes code reusability, as the common behavior is defined once in the generic interface, and then specific implementations can be created for various types. It also facilitates abstraction, as we can work with shapes in a generic manner without knowing the specific implementation details of each shape. This makes the code more flexible, maintainable, and extensible.

Use parameterized collections

Prefer parameterized collections (e.g., List<T>, Map<K, V>) over raw types when working with collections. Parameterized collections provide compile-time type safety and readability.

Avoid unnecessary type casting

Leverage the type information provided by generics to minimize the need for explicit type casting. Let the compiler enforce type correctness wherever possible.

The use of generics allows us to define a single method that works with different types without sacrificing type safety or needing to perform manual type casting. The compiler enforces type correctness, and any attempt to pass a list of non-numeric elements (e.g., List<String>) would result in a compilation error, when the parameter is defined like this List<? extends Number>.

Document and communicate

Document the rationale behind design decisions related to generics. Explain the expected types and constraints to facilitate understanding and collaboration among developers.

/**
 * A generic container class that holds elements of type T.
 *
 * @param <T> The type of elements held by the container.
 */
public class Container<T> {
    // ...
}

By documenting the rationale behind your generics design decisions, you not only facilitate understanding and collaboration but also empower other developers to make informed decisions and contribute to the codebase with confidence. Additionally, clear documentation helps future maintainers grasp the intended behavior and constraints of your generic implementations, which can save valuable time and effort when troubleshooting or extending the code in the future.

Embracing these best practices ensures that generics, a fundamental feature of Java, are wielded effectively, leading to more efficient and dependable software development.

👏 Thank You for Reading!

👨‍💼 I appreciate your time and hope you found this story insightful. If you enjoyed it, don’t forget to show your appreciation by clapping 👏 for the hard work!

📰 Keep the Knowledge Flowing by Sharing the Article!

✍ Feel free to share your feedback or opinions about the story. Your input helps me improve and create more valuable content for you.

✌ Stay Connected! 🚀 For more engaging articles, make sure to follow me on social media:

• Twitter
• Instagram

🔍 Explore More! 📖 Dive into a treasure trove of knowledge at Codimis. There’s always more to learn, and we’re here to help you on your journey of discovery.