Create Generic Method in Java

Java is an extremely popular object-oriented programming language for creating different apps. Java's ability to write generic methods is one of its most potent features. Any technique that can be used with several object types is referred to as generic. Developers can design reusable code thanks to this practical technique.

With the help of sample programs, we will go over how to write a generic method in Java in this tutorial. A few key ideas about generic methods will also be covered.

Creating a Generic Method in Java

The angle bracket syntax is required to declare a type parameter when writing a generic method in Java. A placeholder for the real type that will be supplied to the method at runtime is the type argument.

Syntax for Declaring a Generic Method:

public <T> void methodName(T parameter) {
    // method implementation
}

The <T> in the syntax above denotes that a type parameter with the name T is being declared. The method does not return any value, as indicated by the void keyword. The method parameter that accepts a generic type T is designated by the name of the method, which is methodName().

As an illustration, consider the following generic procedure that outputs an array of objects:

GenericMethod1.java

public class GenericMethod1{
    public static void main(String[] args) {
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        String[] stringArray = { "Hello", "World", "!" };
        System.out.print("Integer Array: ");
        printArray(intArray);
        System.out.print("String Array: ");
        printArray(stringArray);
    }
    public static <T> void printArray(T[] arr) {
        for (T element : arr) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

Output:

Integer Array: 1 2 3 4 5 
String Array: Hello World !

The generic method printArray, which accepts an array of type T, has been declared in the example above. The method prints each entry to the terminal after iterating through the array using a for-each loop.

Let's examine how we may use several array types to call this generic method:

GenericMethod2.java

public class GenericMethod2{
public static void main(String[] args) {
    Integer[] intArray = { 1, 2, 3, 4, 5 };
    Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    String[] stringArray = { "hello", "world", "java", "generic", "method" };
    System.out.println("Integer array:");
    printArray(intArray);
    System.out.println("Double array:");
    printArray(doubleArray);
    System.out.println("String array:");
    printArray(stringArray);
}
}

Output:

Integer array:
1 2 3 4 5 
Double array:
1.1 2.2 3.3 4.4 5.5 
String array:
hello world java generic method

As you can see, the printArray() method is able to work with different types of arrays using the same implementation.

Generic Method with Multiple Type Parameters

In some cases, we may need to declare multiple type parameters in a generic method. We can do this by using a comma-separated list of type parameters in the angle brackets.

Here is an example of a generic method that takes two type parameters and returns a boolean value:

public static <T, U> boolean isEqual(T arg1, U arg2) {
    return arg1.equals(arg2);
}

In the above example, we have declared two type parameters T and U. The method takes two arguments of type T and U and checks if they are equal using the equals() method. The method returns a boolean value indicating whether the arguments are equal or not.

Let's see how we can call this generic method with different types of arguments:

GenericMethod3.java

public class GenericMethod3 {
    public static void main(String[] args) {
        System.out.println(isEqual(10, 10)); // true
        System.out.println(isEqual("hello", "world")); // false
        System.out.println(isEqual(3.14, 3.14)); // true
    }
    public static <T> boolean isEqual(T obj1, T obj2) {
        return obj1.equals(obj2);
    }
}
}

Output:

true
false
true

In the above example, we have called the isEqual method with three different sets of arguments - two integers, two strings, and two doubles. The method is able to handle all these types of arguments using the same implementation.

Wildcard Type Parameters

When passing an object to a generic method, there are times when we may not be certain of its exact type. When this occurs, we can accept any type of the object by using the type arguments with wildcards.

As an illustration, consider the following generic procedure, which accepts an array of any kind of the object and returns the array's first element:

public static <T> T getFirstElement(T[] arr) {
    if (arr != null && arr.length > 0) {
        return arr[0];
    }
    return null;
}

In the above example, we have declared a generic method getFirstElement that takes an array of any type of object T. The method returns the first element of the array, which is of type T.

Let's see how we can call this method with different types of arrays:

GenericMethod4.java

Public class GenericMethod4{
public static void main(String[] args) {
    Integer[] intArray = { 1, 2, 3, 4, 5 };
    Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    String[] stringArray = { "hello", "world", "java", "generic", "method" };
    System.out.println("First element of Integer array: " + getFirstElement(intArray));
    System.out.println("First element of Double array: " + getFirstElement(doubleArray));
    System.out.println("First element of String array: " + getFirstElement(stringArray));
}
}

Output:

First element of Integer array: 1
First element of Double array: 1.1
First element of String array: hello

In the above example, we have called the getFirstElement method with three different types of arrays - Integer, Double, and String. The method is able to handle all these types of arrays using the same implementation.

Type Erasure

One important concept to keep in mind when working with generic methods in Java is type erasure. Type erasure is the process by which the generic type information is removed at compile time and replaced with the actual type.

For example, consider the following generic method:

public static <T> void printType(T arg) {
    System.out.println(arg.getClass());
}

In the above example, we have declared a generic method printType that takes an argument of type T. The method prints the class of the argument to the console using the getClass() method.

Now, let's see how we can call this method with different types of arguments:

GenericMethod5.java

public class GenericMethod5 {
    public static void main(String[] args) {
        printType(10);
        printType("hello");
        printType(3.14);
    }
    public static <T> void printType(T obj) {
        System.out.println(obj.getClass().getSimpleName());
    }
}

Output:

Integer
String
Double

In the above example, we have called the printType method with three different types of arguments - an integer, a string, and a double.

This is because the actual types of the arguments are determined at compile time and the generic type information is erased.

One consequence of type erasure is that we cannot use certain operations that rely on the actual type of the generic type parameter. For example, we cannot create new objects of type T or call methods that are not defined in the Object class.

Here is an example that illustrates this:

public static <T> void printType(T arg) {
    T newObject = new T(); // Compile-time error
    arg.someMethod(); // Compile-time error
}

In the above example, we have tried to create a new object of type T and call a method someMethod() on the argument of type T. However, both of these operations result in a compile-time error because the actual type of T is not known at compile time due to type erasure. we can also use bounded type parameters. Bounded type parameters allow us to specify a upper or lower bound for the type parameter, which restricts the types of objects that can be used with the method.

For example, we can define a generic method that only works with objects that implement the Comparable interface, which provides a way to compare objects of the same type. Here is an example:

GenericMethod6.java

public class GenericMethod6 {
    public static void main(String[] args) {
        System.out.println(isGreaterThan(10, 5)); // true
        System.out.println(isGreaterThan("hello", "world")); // false
        System.out.println(isGreaterThan(3.14, 2.5)); // true
    }
    public static <T extends Comparable<T>> boolean isGreaterThan(T arg1, T arg2) {
        return arg1.compareTo(arg2) > 0;
    }
}

Output:

true
false
true

To ensure that the type parameter T implements the Comparable interface, we utilised a bounded type parameter > in the example above. Bounded type parameters allow us to create more type-safe generic methods that offer greater assurances regarding the kinds of objects that can be used with them.

In conclusion, Java's generic methods give programmers a strong technique to design code that can work with various object types without creating extraneous code. We can create a single implementation of a method that applies to all object types by using type parameters. We learned how to declare generic methods in Java, how to utilise wildcard type parameters to accept any kind of object, and how type erasure influences the behaviour of generic methods in this post. Generic methods have also been used in a few instances, as well. All things considered, generic methods are a valuable tool in the toolbox of the Java programmer, and it is crucial to know how to utilise them properly in order to develop clear and maintainable code.

Next TopicDifference between super and super() in Java with Examples

← prev next →