All 15 Generics questions
More in Generics
What problem do generics solve compared to using raw types (like a pre-Java-5 List without a type parameter), and how do they improve compile-time type safety? What is type erasure, and how does it explain why generic type information is unavailable at runtime (e.g., why you can't do `if (obj instanceof List<String>)`)? What is an unbounded wildcard (List<?>), and when is it more appropriate to use than a bounded generic method with a type parameter <T>? How would you implement a generic Stack<T> class from scratch, demonstrating how a self-contained generic data structure is typically structured? What is a raw type in Java, and why does the compiler still permit using them (with an unchecked warning) despite generics having been available since Java 5? How would you use a Class<T> token parameter to work around type erasure when a generic method genuinely needs runtime access to the actual type argument, such as for deserialization or reflection-based instantiation? How would you write a generic interface (like a custom Repository<T, ID> pattern common in data-access layers) and implement it for a specific entity type? How do bounded wildcards (? extends T and ? super T) work, and what does the PECS (Producer Extends, Consumer Super) mnemonic mean for choosing between them? How would you implement a generic class with multiple type parameters and bounded type parameters (like <T extends Comparable<T>>), and what does this specific bound enable? How do generics interact with arrays, and why does the JDK itself sometimes use an unsafe cast (like in ArrayList's internal implementation) to work around the inability to create generic arrays directly?
Advertisement
Back to results for “Streams & Lambdas”
Java › Generics

How do you write a generic method (as opposed to a generic class), and how does the compiler infer the type parameter from the arguments passed at a call site?

Intermediate

Answer

A generic method declares its own type parameter(s) in angle brackets immediately before the return type (independent of whether the enclosing class itself is generic), and the compiler performs type inference at each call site, examining the actual argument types passed to determine what the type parameter should be, without requiring you to explicitly specify it (though you can, via ClassName.<Type>methodName(...) syntax, in rare cases where inference is ambiguous or insufficient).
public class Utils {
    public static <T> T firstNonNull(T a, T b) {
        return a != null ? a : b;
    }
}

String result = Utils.firstNonNull(null, "default");  // T inferred as String from the arguments
Integer num = Utils.firstNonNull(5, 10);               // T inferred as Integer

// Explicit type witness syntax, rarely needed but available
String explicit = Utils.<String>firstNonNull(null, "default");
Real-world example A generic utility method like Collections.emptyList() infers its type parameter entirely from the context where its return value is assigned or used (like List<String> empty = Collections.emptyList()), letting the same single generic method definition serve every possible element type without any explicit type argument needed at typical call sites.

Common follow-ups: What happens when the compiler cannot unambiguously infer a generic method's type parameter from context, and how do you resolve it?;How does target-type inference (introduced/refined in later Java versions) improve on earlier, more limited inference in certain scenarios?

Functional Interfaces & Method References;Streams & Lambdas
All 15 Generics questions