泛型方法

泛型方法在方法返回类型前声明类型参数，独立于类的类型参数。

泛型方法定义

// 泛型方法：在返回类型前声明 <T>
public <T> T getFirst(List<T> list) {
    if (list.isEmpty()) {
        return null;
    }
    return list.get(0);
}

// 静态泛型方法
public static <T> void print(T item) {
    System.out.println(item);
}

注意：泛型方法的类型参数 <T> 声明在返回类型前，这是泛型方法的标志。

泛型方法调用

// 显式指定类型
String first = this.<String>getFirst(stringList);

// 类型推断（推荐）
String first = getFirst(stringList);  // 自动推断为 String
Integer first = getFirst(intList);    // 自动推断为 Integer

类型推断：编译器根据参数类型自动推断泛型类型，无需显式指定。

泛型方法 vs 泛型类

public class MyClass<T> {  // 泛型类
    private T field;

    // 使用类的类型参数
    public T getField() {
        return field;
    }

    // 泛型方法：独立类型参数 <E>
    public <E> void print(E item) {
        System.out.println(item);
    }

    // 泛型方法：可以和类参数不同
    public <E> E convert(T source) {
        // T 是类参数，E 是方法参数
        return null;
    }
}

静态方法不能使用类泛型参数：静态成员在类加载时存在，不依赖实例，无法获取泛型参数。静态方法需要泛型时必须定义为泛型方法。

多类型参数方法

public <K, V> Map<K, V> createMap(K key, V value) {
    Map<K, V> map = new HashMap<>();
    map.put(key, value);
    return map;
}

// 调用
Map<String, Integer> map = createMap("age", 25);

泛型方法示例

类型安全的数组填充

public static <T> void fillArray(T[] array, T value) {
    for (int i = 0; i < array.length; i++) {
        array[i] = value;
    }
}

// 使用
String[] strings = new String[5];
fillArray(strings, "default");
Integer[] ints = new Integer[10];
fillArray(ints, 0);

通用交换方法

public static <T> void swap(List<T> list, int i, int j) {
    T temp = list.get(i);
    list.set(i, list.get(j));
    list.set(j, temp);
}

// 使用
List<String> list = Arrays.asList("A", "B", "C");
swap(list, 0, 2);  // A 和 C 交换

类型转换方法

public static <T> List<T> castList(List<?> list, Class<T> clazz) {
    List<T> result = new ArrayList<>();
    for (Object item : list) {
        result.add(clazz.cast(item));
    }
    return result;
}

// 使用
List<?> rawList = Arrays.asList("A", "B", "C");
List<String> stringList = castList(rawList, String.class);

要点总结

• 泛型方法在返回类型前声明 <T>
• 泛型方法的类型参数独立于类参数
• 静态方法需要泛型时必须定义为泛型方法
• 类型推断：编译器自动推断，无需显式指定
• 多类型参数用 <K, V> 等命名
• 泛型方法适用于通用工具方法