Generic Methods

Part of the Object Oriented Programming section of Coddy's Java journey. Lesson 55 of 87.

While generic classes make entire classes work with different types, sometimes you only need a single method to be generic. A generic method declares its own type parameter, independent of any class-level generics.

The type parameter appears before the return type in the method signature:

public class Utility {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

String[] names = {"Alice", "Bob"};
Integer[] numbers = {1, 2, 3};

Utility.printArray(names);    // Works with String[]
Utility.printArray(numbers);  // Works with Integer[]

Notice the <T> placed between the modifiers and the return type. This declares T as a type parameter for this specific method. The compiler infers the actual type from the arguments you pass.

Generic methods can also return the generic type:

public static <T> T getFirst(T[] array) {
    if (array.length > 0) {
        return array[0];
    }
    return null;
}

String first = getFirst(new String[]{"a", "b"});  // Returns "a"

You can use multiple type parameters when needed:

public static <K, V> void printPair(K key, V value) {
    System.out.println(key + ": " + value);
}

printPair("Age", 25);        // String and Integer
printPair(1, "First");       // Integer and String

Generic methods are particularly useful in utility classes where you need flexible, reusable operations without creating a generic class.

Challenge

Easy

Let's build a utility toolkit that showcases the flexibility of generic methods. You'll create a class with reusable methods that work with any type, demonstrating how generic methods can exist independently of generic classes.

You'll organize your code across two files:

ArrayUtils.java: Create a utility class containing generic methods for working with arrays. Your class should have three static generic methods:
getLast - A generic method that takes an array of type T and returns the last element. If the array is empty, return null.

swap - A generic method that takes an array of type T and two integer indices, then swaps the elements at those positions. This method doesn't return anything.

printWithLabel - A generic method with two type parameters K and V. It takes a label of type K and a value of type V, then prints them in the format: [label]: [value]
Main.java: Put your generic methods to work! You'll receive four inputs: two words (Strings) and two numbers (integers).
First, create a String[] array containing both words. Use getLast to get the last element and print: Last word: [result]

Next, create an Integer[] array containing both numbers. Call swap to swap the elements at indices 0 and 1, then print: After swap: [first], [second]

Finally, demonstrate the two-parameter generic method by calling printWithLabel twice:
- Once with the first word as the label and the first number as the value
- Once with the first number as the label and the second word as the value

You will receive four inputs in order: first word, second word, first number, second number.

Notice how each method declares its own type parameter(s) with <T> or <K, V> before the return type. The compiler infers the actual types from the arguments you pass—no need to specify them explicitly when calling the methods!

Try it yourself

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Read inputs
        String firstWord = scanner.nextLine();
        String secondWord = scanner.nextLine();
        int firstNumber = scanner.nextInt();
        int secondNumber = scanner.nextInt();
        
        // TODO: Create a String[] array containing both words
        
        // TODO: Use ArrayUtils.getLast to get the last element
        // Print: "Last word: [result]"
        
        // TODO: Create an Integer[] array containing both numbers
        
        // TODO: Call ArrayUtils.swap to swap elements at indices 0 and 1
        // Print: "After swap: [first], [second]"
        
        // TODO: Call ArrayUtils.printWithLabel with firstWord as label and firstNumber as value
        
        // TODO: Call ArrayUtils.printWithLabel with firstNumber as label and secondWord as value
    }
}