Java Generic Methods

Why a generic method?

Imagine a utility method that prints every element of an array. Write it for one type and you need a copy for every other type.

static void printStrings(String[] arr) { ... }
static void printIntegers(Integer[] arr) { ... }
static void printDoubles(Double[] arr) { ... }   // and on and on

The bodies are identical. Only the parameter type changes. A generic method fixes that:

• You do not want a whole generic class. You want one method that works for any array type.
• A generic method gets its own type parameter, separate from any class.
• One method body then serves every type. Full type safety. No casting.

The generic method syntax

A generic method declares its own type parameter in angle brackets, placed before the return type. Here is the smallest one, which prints any array.

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

Reading it left to right:

• <T> right before void declares the type parameter for this method.
• void is the return type, as usual. The <T> sits in front of it.
• T[] array means “an array of any type”.
• Inside the loop, item is a T, so each element is that same type.
• The <T> belongs to the method, not the class. The class can stay normal.

Using a generic method

You call a generic method like any normal method. Java figures out the type from the argument you pass. Here we call printArray with two different array types.

public class Main {

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

    public static void main(String[] args) {
        String[] names = {"Alex", "Riya"};
        Integer[] numbers = {10, 20, 30};

        printArray(names);     // T becomes String
        printArray(numbers);   // T becomes Integer
    }
}

Notice what we did not do:

• No type in the call. No Main.<String>printArray(...) needed.
• No casting.
• No second method.

Java works out the type each time from the argument. This is called type inference. It sees String[], so T is String. It sees Integer[], so T is Integer. One method body handled both.

Alex
Riya
10
20
30

You can pass the type explicitly if you ever need to, like Main.<String>printArray(names). But you almost never do. Inference handles it for you.

A generic method that returns a type

A generic method can also return the type parameter, so the output type adapts to the input. Here is one that returns the first element of any array.

public class Main {

    static <T> T getFirst(T[] array) {
        return array[0];   // returns whatever type the array holds
    }

    public static void main(String[] args) {
        String[] names = {"Alex", "Riya"};
        Integer[] numbers = {10, 20};

        String firstName = getFirst(names);    // returns a String
        int firstNumber = getFirst(numbers);   // returns an Integer
        System.out.println(firstName);
        System.out.println(firstNumber);
    }
}

The signature static <T> T getFirst(T[] array) has two T markers doing different jobs:

• The first <T> (before the return type) declares the type parameter.
• The second T (the return type) says the method gives back a value of that same type.
• So a String array returns a String, an Integer array returns an Integer. No casting.

Alex
10

Multiple type parameters

A method can declare several type parameters, separated by commas. Here is one that takes two values of different types and prints them as a pair.

public class Main {

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

    public static void main(String[] args) {
        printPair("age", 30);          // K is String, V is Integer
        printPair(1, "first place");   // K is Integer, V is String
    }
}

The declaration <K, V> introduces two independent type parameters:

• K and V are just a convention for “key” and “value”. You could name them anything.
• Each one is inferred separately from its matching argument.
• The first call sets K to String and V to Integer. The second call flips them.
• Use multiple type parameters when a method must keep two unrelated types straight at once.

age = 30
1 = first place

Bounded type parameters

So far T could be anything. But some methods only make sense for types that can do a certain thing. A max method must compare its values, and a plain T cannot promise compareTo. A bounded type parameter solves this. You add extends to say “T must implement Comparable”, which unlocks the comparison. Here is a generic max method.

public class Main {

    static <T extends Comparable<T>> T max(T a, T b) {
        // a.compareTo(b) is allowed because T is Comparable
        return (a.compareTo(b) >= 0) ? a : b;
    }

    public static void main(String[] args) {
        System.out.println(max(10, 25));         // Integers
        System.out.println(max("apple", "box")); // Strings, compared alphabetically
    }
}

The signature <T extends Comparable<T>> breaks down like this:

• T extends Comparable<T> means “T can be any type, as long as it implements Comparable<T>”.
• That promise lets the compiler allow a.compareTo(b) inside the method.
• compareTo returns a number: negative if a is smaller, zero if equal, positive if larger.
• So a.compareTo(b) >= 0 is true when a is greater than or equal to b, and we return the bigger one.
• In generics you write extends even for an interface like Comparable, never implements.

25
box

Integer and String both implement Comparable, so both calls work. A non-comparable type would be stopped at compile time.

Wildcards: the ? symbol

You will sometimes see a ? in generic code, like List<?>. This is a wildcard, and it means “some unknown type”. Use it when a method accepts a collection of any type but never names that type. There are three forms. First, the import these examples use.

import java.util.List;

static void printSize(List<?> list) {
    System.out.println("Size: " + list.size());   // works for a list of anything
}

public class Main {

    static double sum(List<? extends Number> numbers) {
        double total = 0;
        for (Number n : numbers) {          // each item is safely a Number
            total += n.doubleValue();        // read it as a double
        }
        return total;
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        List<Double> doubles = List.of(1.5, 2.5);

        System.out.println(sum(ints));      // accepts List<Integer>
        System.out.println(sum(doubles));   // accepts List<Double>
    }
}

6.0
4.0

Generic method vs generic class

Which do you pick? It comes down to what needs to vary by type.

• Use a generic class when the type belongs to the whole object and many methods share it, like a Box<T> that stores and returns a T. The class remembers the type across calls.
• Use a generic method when only one operation is generic and nothing is stored between calls, like printArray, max, or sum.
• Rule of thumb: if the type would be a field of the object, make the class generic. If it lives only for one call, make the method generic.

Common Mistakes

A few generic-method slip-ups to watch for.

Forgetting the <T> before the return type. Then the compiler thinks T is a real class it cannot find.

// ❌ Wrong: T is never declared, so the compiler does not know what T is
static T getFirst(T[] array) {
    return array[0];
}

// ✅ Correct: declare <T> before the return type
static <T> T getFirst(T[] array) {
    return array[0];
}

Trying to add to a List<? extends T>. That wildcard is for reading, not adding. The element type is unknown, so the compiler blocks additions.

// ❌ Wrong: cannot add to a list of an unknown subtype of Number
static void addOne(List<? extends Number> list) {
    list.add(1);   // compile error: the real type is unknown
}

// ✅ Correct: read from ? extends, and use a concrete or ? super list to write
static void addOne(List<? super Integer> list) {
    list.add(1);   // fine: the list accepts Integer
}

Confusing a generic method with a generic class. A generic method has its own type parameter and lives fine in a normal class. The class need not be generic.

Writing the type at the call unnecessarily. Java infers it from the arguments, so printArray(names) is enough. Main.<String>printArray(names) just adds noise.

Best Practices

Habits for writing clean generic methods.

• Reach for a generic method when only a method needs to be generic. No need to make the whole class generic.
• Put <T> before the return type. That is the required and only spot for a method’s type parameter.
• Let Java infer the type. Call the method normally and let the compiler work out the type from the arguments.
• Add a bound when you need an ability. Use <T extends Comparable<T>> when the method must compare, sort, or otherwise rely on what the type can do.
• Follow PECS for wildcards. Use ? extends for parameters you read from, and ? super for parameters you write into.
• Give type parameters meaningful single letters. T for a general type, K and V for key and value, E for element. It is a convention every Java reader knows.

What You’ve Learned

Great, that completes the Generics module. Let’s recap generic methods.

• ✅ A generic method has its own type parameter, so a single method works with any type.
• ✅ The type parameter <T> goes before the return type, like static <T> void printArray(...).
• ✅ Java infers the type from the arguments, so you call it like any normal method.
• ✅ A generic method can return the type parameter, adapting its return type to the input.
• ✅ You can declare multiple type parameters like <K, V>, and add a bound like <T extends Comparable<T>> to unlock abilities.
• ✅ A wildcard ? means “some unknown type”; use ? extends for reading and ? super for writing, the PECS idea.

What’s Next?

You have a solid grip on generic methods now. Next we go deeper into the wildcard syntax you just met, the ? symbol, and learn exactly when to reach for upper and lower bounds. Let’s continue with wildcards.

Java Generics Wildcards