一、概述

二、为什么使用泛型

三、常见泛型类型参数的含义与用途

示例一：使用 T 定义泛型类

示例二：使用 E 表示集合元素

示例三：使用 K 和 V 表示键值对

示例四：使用 ? 通配符处理未知类型

四、通配符 ? 的扩展用法

无界通配符：?

上限通配符：? extends T

下限通配符：? super T

五、泛型类别

泛型类

泛型接口

泛型方法

六、泛型的类型表示：Type 接口的实现

Class：非泛型类型

ParameterizedType：参数化类型

TypeVariable：类型变量

WildcardType：通配符类型

七、其他泛型写法

多边界类型参数

通配符嵌套

递归类型约束

泛型与函数式接口结合

泛型数组的创建技巧

八、注意事项

总结

Java 泛型（Generics）是 Java 5 引入的重要特性之一，它允许在类、接口和方法中使用类型参数，从而实现类型安全的复用代码。泛型不仅提高了代码的可重用性，还增强了编译时的类型检查，避免了运行时的类型转换错误。

元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。如：Collection<E>,List<E>，ArrayList<E>这个<E>就是类型参数，即泛型

在使用泛型的过程中，我们经常会看到 T、E、K、V、? 等符号，它们分别代表不同的类型参数。本文将详细解析这些符号的含义、用途以及最佳实践，帮助你不再“傻傻分不清”。

一、概述

泛型的核心思想是 “参数化类型”，即把类型作为参数传递给类或方法。例如：

List<String> list = new ArrayList<>();

这里的 String 就是类型参数，表示这个列表只能存放字符串类型的元素。

二、为什么使用泛型

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

保证了类型的安全性：在没有泛型之前，从集合中读取到的每一个对象都必须进行类型转换，如果不小心插入了错误的类型对象，在运行时的转换处理就会出错
消除强制转换：泛型的一个附带好处是，消除源代码中的许多强制类型转换，这使得代码更加可读，并且减少了出错机会
避免了不必要的装箱、拆箱操作，提高程序的性能
提高了代码的重用性

三、常见泛型类型参数的含义与用途

Java 泛型中并没有强制规定必须使用哪些字母作为类型参数，但为了代码的可读性和一致性，社区中形成了一些约定俗成的命名习惯。

类型参数	含义	常见使用场景
T	Type（类型）	表示任意具体类型，常用于类、接口、方法级别的泛型定义
E	Element（元素）	多用于集合类中，表示集合中的元素类型，如 `List<E>`
K	Key（键）	通常用于 Map 中的键类型，如 `Map<K, V>`
V	Value（值）	通常用于 Map 中的值类型，如 `Map<K, V>`
N	Number（数字）	表示数值类型，如 `Number`的子类
?	Unknown（未知）	表示不确定的类型，用于通配符（Wildcard）
S, U, V	第二、第三、第四个类型参数	当一个泛型需要多个类型参数时使用

示例一：使用 T 定义泛型类

public class Box<T> {private T item;public void setItem(T item) {this.item = item;}public T getItem() {return item;}
}

调用方式：

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello");Box<Integer> integerBox = new Box<>();
integerBox.setItem(123);

示例二：使用 E 表示集合元素

public interface List<E> extends Collection<E> {// ...
}

示例三：使用 K 和 V 表示键值对

public interface Map<K, V> {V put(K key, V value);V get(Object key);
}

示例四：使用 ? 通配符处理未知类型

public static void printList(List<?> list) {for (Object obj : list) {System.out.println(obj);}
}

此方法可以接受任何类型的 List，比如 List、List等。

四、通配符 ? 的扩展用法

通配符 ? 可以配合上下限使用，实现更灵活的类型约束。

无界通配符：?

适用于不知道或不关心具体类型的情况。

List<?> anyList = new ArrayList<String>();

上限通配符：? extends T

表示某种类型及其子类，适合“只读”操作。

public static void addNumbers(List<? extends Number> list) {for (Number number : list) {System.out.println(number.doubleValue());}
}

“
注意：不能向这种列表中添加元素（除了 null），因为编译器无法确定具体的类型。

下限通配符：? super T

表示某种类型及其父类，适合“写入”操作。

public static void addIntegers(List<? super Integer> list) {list.add(100); // 正确：Integer 是下限的子类
}

此时你可以往列表中添加 Integer 类型的数据，但不能保证读取的是什么类型。

五、泛型类别

泛型根据定义位置和作用范围，可分为泛型类、泛型接口和泛型方法三类。它们的核心都是 “参数化类型”，但适用场景和语法略有差异。

泛型类

泛型类是指在类定义时声明类型参数，使得类中的字段、方法参数或返回值可以使用这些类型参数。类型参数的作用域贯穿整个类。

public class DataWrapper<T> {private T data;public DataWrapper(T data) {this.data = data;}public T getData() {return data;}public void setData(T data) {this.data = data;}
}

泛型类继承，若父类指定类型，则子类不用指定，默认和父类一样。若父类没有指定泛型类型，则父类、子类都需要默认泛型（Object）

泛型接口

泛型接口与泛型类类似，在接口定义时声明类型参数，实现类需指定具体类型或继续保留泛型。

// 定义泛型接口，E表示产出的元素类型
public interface Producer<E> {E produce();
}// 实现接口时指定具体类型（如String）
public class StringProducer implements Producer<String> {@Overridepublic String produce() {return "Hello";}
}// 实现接口时继续保留泛型（泛型实现类）
public class GenericProducer<T> implements Producer<T> {private T data;public GenericProducer(T data) {this.data = data;}@Overridepublic T produce() {return data;}
}

泛型方法

泛型方法是指在方法声明时单独声明类型参数的方法，其类型参数的作用域仅限于当前方法。它可以是静态方法或实例方法，且无需依赖所在类是否为泛型类。

public class GenericMethodDemo {// 泛型实例方法：将输入对象转换为目标类型（简化示例）public <T> T convert(Object obj, Class<T> clazz) throws Exception {if (clazz.isInstance(obj)) {return clazz.cast(obj);}// 实际场景可能通过反射、JSON等方式转换return clazz.getConstructor(String.class).newInstance(obj.toString());}// 静态泛型方法：创建指定类型的列表并添加元素public static <E> List<E> createList(E... elements) {List<E> list = new ArrayList<>();for (E e : elements) {list.add(e);}return list;}
}// 使用泛型方法
public static void main(String[] args) throws Exception {GenericMethodDemo demo = new GenericMethodDemo();// 实例泛型方法：将String转换为IntegerInteger num = demo.convert("123", Integer.class);// 静态泛型方法：创建String列表List<String> strList = GenericMethodDemo.createList("a", "b", "c");
}

关键特性

泛型方法的类型参数声明（如）必须在返回值前，这是区分泛型方法与普通方法的核心标志；
静态方法无法使用所在类的泛型参数（因静态成员属于类，与实例无关），若需泛型需定义为静态泛型方法；

六、泛型的类型表示：Type 接口的实现

在 Java 中，泛型的类型信息在编译后会被部分保留（类型擦除不会完全抹去所有信息），这些信息可通过反射 API 获取。java.lang.reflect.Type接口是所有泛型类型的父接口，其下有 5 种核心实现（或子接口），用于表示不同场景的泛型类型。

Class<?>：非泛型类型

Class是Type的直接实现，用于表示非泛型类型（如String、Integer）或泛型类型的原始类型（如List，未指定类型参数的泛型类）。

// String是普通类，类型为Class
Class<String> stringClass = String.class;
// List是泛型类的原始类型，类型仍为Class
Class<List> listClass = List.class;

ParameterizedType：参数化类型

表示指定了具体类型参数的泛型类型，如List、Map<Integer, String>。其核心方法包括：

getRawType()：获取原始类型（如List的原始类型是List.class）；
getActualTypeArguments()：获取实际类型参数（如List的实际参数是String.class）。

public class ParameterizedTypeDemo {private List<String> stringList;private Map<Integer, List<String>> complexMap;public static void main(String[] args) throws NoSuchFieldException {// 获取stringList字段的类型Field field1 = ParameterizedTypeDemo.class.getDeclaredField("stringList");ParameterizedType pt1 = (ParameterizedType) field1.getGenericType();System.out.println(pt1.getRawType()); // interface java.util.ListSystem.out.println(pt1.getActualTypeArguments()[0]); // class java.lang.String// 获取complexMap字段的类型Field field2 = ParameterizedTypeDemo.class.getDeclaredField("complexMap");ParameterizedType pt2 = (ParameterizedType) field2.getGenericType();System.out.println(pt2.getRawType()); // interface java.util.MapSystem.out.println(pt2.getActualTypeArguments()[0]); // class java.lang.IntegerSystem.out.println(pt2.getActualTypeArguments()[1]); // java.util.List<java.lang.String>（也是ParameterizedType）}
}

TypeVariable：类型变量

表示泛型中的类型参数（如类或方法声明的T、E）。其核心方法包括：

getName()：获取类型参数名称（如T）；
getBounds()：获取类型参数的上限（如class Box中，T的上限是Number.class）。

public class TypeVariableDemo<T extends Number & Serializable, E> {public static void main(String[] args) {// 获取类的泛型类型参数TypeVariable<Class<TypeVariableDemo>>[] typeVariables = TypeVariableDemo.class.getTypeParameters();// 第一个类型参数TTypeVariable<Class<TypeVariableDemo>> t = typeVariables[0];System.out.println(t.getName()); // TSystem.out.println(Arrays.toString(t.getBounds())); // [class java.lang.Number, interface java.io.Serializable]// 第二个类型参数E（无显式上限，默认上限为Object）TypeVariable<Class<TypeVariableDemo>> e = typeVariables[1];System.out.println(e.getName()); // ESystem.out.println(Arrays.toString(e.getBounds())); // [class java.lang.Object]}
}

WildcardType：通配符类型

表示泛型通配符（如?、? extends Number、? super Integer）。其核心方法包括：

getUpperBounds()：获取上限（如? extends Number的上限是Number.class）；
getLowerBounds()：获取下限（如? super Integer的下限是Integer.class）。

public class WildcardTypeDemo {private List<? extends Number> upperList;private List<? super Integer> lowerList;public static void main(String[] args) throws NoSuchFieldException {// 获取上限通配符Field field1 = WildcardTypeDemo.class.getDeclaredField("upperList");ParameterizedType pt1 = (ParameterizedType) field1.getGenericType();WildcardType wt1 = (WildcardType) pt1.getActualTypeArguments()[0];System.out.println(Arrays.toString(wt1.getUpperBounds())); // [class java.lang.Number]System.out.println(Arrays.toString(wt1.getLowerBounds())); // []（无下限）// 获取下限通配符Field field2 = WildcardTypeDemo.class.getDeclaredField("lowerList");ParameterizedType pt2 = (ParameterizedType) field2.getGenericType();WildcardType wt2 = (WildcardType) pt2.getActualTypeArguments()[0];System.out.println(Arrays.toString(wt2.getUpperBounds())); // [class java.lang.Object]（默认上限）System.out.println(Arrays.toString(wt2.getLowerBounds())); // [class java.lang.Integer]}
}

为什么需要了解 Type 接口？

在日常开发中，直接使用这些类型的场景较少，但在框架开发（如 Spring、Jackson）中，反射处理泛型是常见需求。例如：

Jackson 解析List时，需通过ParameterizedType获取User类型；
Spring 的ResolvableType工具类封装了对这些类型的处理，用于依赖注入时的泛型匹配。

七、其他泛型写法

Java 泛型的高级写法主要体现在多边界约束、通配符嵌套、泛型方法重载和递归类型约束等场景。以下是一些实用的高级写法及示例：

多边界类型参数

当需要对泛型类型参数施加多个约束条件时，可以使用 & 符号连接多个接口（或一个类和多个接口）。注意：类必须放在第一个位置，且只能有一个类。

// 要求T必须同时实现Serializable和Cloneable接口
public static class Custom<T extends Serializable & Cloneable> {private T value;public Custom(T value) {this.value = value;}
}public static class Student implements Serializable, Cloneable {}public static void main(String[] args) {Custom<Student> custom = new Custom<>(new Student());
}

通配符嵌套

在处理复杂泛型结构时，通配符可以嵌套使用，实现更精确的类型约束。

// 嵌套通配符示例：表示一个列表，其元素是另一个列表，内层列表的元素类型是Number或其子类
List<? extends List<? extends Number>> nestedList;// 使用场景：统计嵌套列表中的所有数值之和
public static double sumNestedLists(List<? extends List<? extends Number>> lists) {double sum = 0;for (List<? extends Number> innerList : lists) {for (Number num : innerList) {sum += num.doubleValue();}}return sum;
}

递归类型约束

允许类型参数引用自身，常用于定义 “可比较自身的类型” 或 “自引用接口”。

// 定义一个可排序的元素，要求T必须实现Comparable接口且能比较自身类型
public static class SortedElement<T extends Comparable<T>> {private T value;public SortedElement(T value) {this.value = value;}// 判断当前元素是否小于另一个元素public boolean isLessThan(SortedElement<T> other) {return this.value.compareTo(other.value) < 0;}
}public static void main(String[] args) {SortedElement<Integer> e1 = new SortedElement<>(10);SortedElement<Integer> e2 = new SortedElement<>(20);System.out.println(e1.isLessThan(e2)); // true
}

泛型与函数式接口结合

利用 Java 8+ 的函数式接口和泛型，实现更灵活的类型安全操作。

// 定义一个泛型函数式接口，用于转换类型@FunctionalInterfacepublic interface Converter<T, R> {R convert(T source);}// 泛型工具类：提供类型转换方法public static class GenericConverter {// 使用泛型和函数式接口进行类型转换public static <T, R> List<R> convertList(List<T> sourceList, Converter<T, R> converter) {List<R> result = new ArrayList<>();for (T item : sourceList) {result.add(converter.convert(item));}return result;}}public static void main(String[] args) {List<String> stringList = Arrays.asList("1", "2", "3");List<Integer> integerList = GenericConverter.convertList(stringList, Integer::valueOf);}

泛型数组的创建技巧

由于类型擦除，直接创建泛型数组（如 new T[]）是非法的，但可以通过反射创建。

public static class GenericArray<T> {private T[] array;@SuppressWarnings("unchecked")public GenericArray(Class<T> clazz, int size) {// 通过Array.newInstance创建泛型数组this.array = (T[]) Array.newInstance(clazz, size);}public T[] getArray() {return array;}public void set(int index, T value) {array[index] = value;}
}public static void main(String[] args) {GenericArray<String> stringArray = new GenericArray<>(String.class, 3);stringArray.set(0, "Hello");stringArray.set(1, "world");
}