Skip to main content

Generic Methods in Java

  • Generic methods are methods that introduce their own type parameters, allowing them to be independent of any generic type parameters declared by the class in which they reside.

  • This makes them extremely versatile, enabling you to write methods that can operate on objects of various types while maintaining type safety.

Defining a Generic Method​

  • To define a generic method, you use a type parameter in angle brackets (<>) before the return type of the method.

  • This type parameter can be used in the method's parameters, return type, and within the method body.

Syntax​

public <T> ReturnType methodName(T parameter) {
    // Method body where T can be used as a type
}

  • public is the access modifier.

  • <T> is the type parameter declaration.

  • ReturnType is the return type of the method.

  • methodName is the name of the method.

  • T parameter is a parameter of type T.

Example of a Generic Method​

Let's create a simple generic method called printValue that prints the value of any type:

public class Main {
    // Generic method to print any type of value
    public static <T> void printValue(T value) {
        System.out.println("Value: " + value);
    }

    public static void main(String[] args) {
        // Using the generic method with different types
        printValue(42); // Outputs: Value: 42
        printValue("Hello, Generics!"); // Outputs: Value: Hello, Generics!
        printValue(3.14); // Outputs: Value: 3.14
    }
}

Explanation​

  • Generic Method Definition: public static <T> void printValue(T value) defines a generic method printValue with a type parameter T.

  • Method Body: The method prints the value passed to it.

  • Using the Generic Method:

  1. printValue(42); calls the method with an Integer.

  2. printValue("Hello, Generics!"); calls the method with a String.

  3. printValue(3.14); calls the method with a Double.

Generic Methods in Generic Classes​

You can also define generic methods within generic classes. In such cases, the method's type parameter can be different from the class's type parameter.

class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }

    // Generic method to compare values
    public <U> boolean isEqual(Box<U> otherBox) {
        return this.value.equals(otherBox.getValue());
    }
}

public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setValue(42);

        Box<String> stringBox = new Box<>();
        stringBox.setValue("Hello");

        System.out.println("Are the boxes equal? " + intBox.isEqual(stringBox)); // Outputs: false
    }
}

Explanation​

  • Generic Class Definition: class Box<T> defines a generic class Box with a type parameter T.

  • Generic Method: public <U> boolean isEqual(Box<U> otherBox) defines a generic method isEqual with a type parameter U.

  • Method Body: The method compares the value of the current box with the value of another box.

Summary​

  • Generic methods in Java are powerful tools that provide type safety, code reusability, flexibility, and compile-time checking.

  • By defining methods with type parameters, you can create methods that operate on various data types while ensuring type safety and eliminating the need for casting.

Understanding generic methods is essential for writing modern, efficient Java applications.