Generic Interface

A Java generic interface is an interface that declares one or more formal type parameters within angle brackets (<>) immediately following the interface name. These type parameters act as placeholders for concrete reference types that are specified when the interface is implemented or extended, enabling type-safe API contracts without binding the interface declarations to specific data types.

Syntax Declaration

Type parameters are declared in a comma-separated list. By convention, single uppercase letters (e.g., T, E, K, V) are used.

public interface InterfaceName<T1, T2> {
    T1 execute(T2 param);
    void update(T1 param);
}

Implementation Mechanics

When a class or another interface inherits from a generic interface, the compiler requires resolution of the type parameters. There are three primary mechanisms to handle this resolution:

1. Defining a Concrete Type Argument

The implementing class specifies an exact reference type for the interface’s type parameter. The implementing class itself does not need to be generic.

public interface Processor<T> {
    T process(T input);
}

// The type parameter T is explicitly resolved to String
public class StringProcessor implements Processor<String> {
    @Override
    public String process(String input) {
        return input.toUpperCase();
    }
}

2. Propagating the Type Parameter

The implementing class remains generic and passes its own formal type parameter up to the interface. The type parameter names do not need to match, but the type hierarchy must align.

public interface Container<E> {
    void add(E item);
}

// The class propagates its type parameter T to the interface's parameter E
public class GenericContainer<T> implements Container<T> {
    @Override
    public void add(T item) {
        // Implementation details
    }
}

3. Partial Resolution in Extension

An interface can extend a generic interface by resolving some type parameters while propagating others.

import java.util.List;

public interface BaseRepository<T, ID> {
    T findById(ID id);
}

// Propagates T, but fixes ID to Long
public interface EntityRepository<T> extends BaseRepository<T, Long> {
    List<T> findAll();
}

Type Parameter Bounding

Generic interfaces support bounded type parameters to restrict the types that can be passed as arguments. This guarantees that the type argument exposes specific methods.

Single Bound: Restricts the type to a specific class or interface hierarchy.

public interface NumericOperation<T extends Number> {
    double compute(T value);
}

Multiple Bounds: Restricts the type to be a subtype of multiple types. In Java, a multiple bound can contain at most one class, which must be listed first, followed by any number of interfaces.

public interface ComplexOperation<T extends Number & Comparable<T>> {
    int compareAndCompute(T v1, T v2);
}

Method-Level Generics within Generic Interfaces

A generic interface can declare generic methods that introduce their own independent type parameters. The method’s type parameter scope is strictly local to that method.

public interface Mapper<T> {
    // T is scoped to the interface instance
    // R is scoped to the method invocation
    <R> R map(T source, Class<R> targetType);
}

Static Context Restrictions

Type parameters declared at the interface level are scoped to the instances of the classes that implement the interface. Because static members belong to the interface type itself rather than any specific instance, static contexts cannot reference the interface’s type parameters.

• Static Fields: All fields in an interface are implicitly public static final. They cannot be declared using the interface’s type parameters.
• Static Methods: Static methods cannot reference the interface’s type parameters. If a static method requires generics, it must declare its own independent type parameters.

public interface Configurator<T> {
    // COMPILATION ERROR: Cannot make a static reference to the non-static type T
    // T defaultInstance; 
    
    // COMPILATION ERROR: Cannot make a static reference to the non-static type T
    // static void print(T item) { ... }
    
    // VALID: The static method declares its own independent type parameter <E>
    static <E> void printIndependent(E item) {
        System.out.println(item);
    }
}

Raw Types and Type Erasure

If a generic interface is implemented without specifying a type argument, it becomes a raw type. Due to Java’s type erasure, the compiler replaces the missing type parameters with their upper bound (or Object if unbounded). This bypasses compile-time type checking and results in compiler warnings.

// Discouraged: Raw type implementation
public class LegacyProcessor implements Processor {
    @Override
    public Object process(Object input) {
        return input;
    }
}

Master Java with Deep Grasping Methodology!

Learn More