本文详细介绍了Java泛型如何通过类型参数、通配符和上下限提供类型安全、代码重用和灵活性。通过Box和List等例子展示了泛型在类、接口和方法中的应用，以及通配符在方法参数中的使用策略。
泛型是Java编程语言中的一个强大特性，它允许在编写类、接口和方法时使用类型参数，从而使得代码能够更加灵活、安全和可重用。通过泛型，可以编写通用的代码，使其适用于多种不同类型的数据，同时减少类型转换和错误的可能性。
一、泛型的优势
1. 类型安全性：
假设我们有一个简单的泛型类 Box<T>，用于存储一个对象并提供访问和设置该对象的方法。通过泛型，我们可以确保 Box 类只能存储特定类型的对象，从而提高了类型安全性。
public class Box<T> {
private T value;
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
使用这个泛型类，我们可以创建多个 Box 实例来存储不同类型的数据，而不必担心类型转换错误：
Box<Integer> integerBox = new Box<>();
integerBox.setValue(10);
int intValue = integerBox.getValue(); // 不需要进行类型转换，代码更加安全
2. 代码重用：
假设我们有一个通用的方法 printList，用于打印任何类型的列表中的元素。通过泛型，我们可以编写一个通用的方法，而不需要为不同类型的列表编写多个方法
public static <T> void printList(List<T> list) {
for (T item : list) {
System.out.println(item);
}
}
我们可以将不同类型的列表传递给这个方法，而无需为每种类型的列表编写单独的打印方法：
List<Integer> integerList = Arrays.asList(1, 2, 3);
printList(integerList);
List<String> stringList = Arrays.asList("apple", "banana", "orange");
printList(stringList);
3. 更清晰的代码：
假设我们有一个泛型类 Pair<K, V>，用于表示键值对。通过泛型，我们可以直观地表达这个类是一个键值对，使得代码更加清晰易懂。
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
}
使用这个泛型类，我们可以创建键值对，而不必在类名中指定具体的类型：
Pair<String, Integer> pair1 = new Pair<>("age", 25);
Pair<String, String> pair2 = new Pair<>("name", "John");
String key = pair1.getKey();
Integer value = pair1.getValue();
二、泛型的类与泛型方法以及上下限
1. 泛型的类（Generic Class）：
泛型的类允许你在类的声明中使用一个或多个类型参数。这些类型参数在类的实例化时被指定具体的类型，从而使得该类能够操作指定的类型数据，提高了代码的类型安全性和重用性。
示例：
public class Box<T> {
private T value;
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
举例说明泛型的应用场景：
- 泛型集合：例如
List<T>、Map<K, V>等，可以容纳各种类型的数据，提高了集合的通用性和类型安全性。 - 泛型方法：例如
Collections.sort(List<T> list)，可以对任意类型的列表进行排序，而不需要编写多个重载方法。 - 自定义泛型类和接口：例如
Box<T>、Pair<K, V>等，可以提供通用的数据结构，适用于不同类型的数据存储和操作。
在这个示例中，Box 类是一个泛型类，使用类型参数 T 来表示将要存储的数据类型。在实例化 Box 类时，需要指定 T 的具体类型。
2. 泛型的方法（Generic Method）：
泛型的方法允许你在方法的声明中使用类型参数，而不是在整个类中。这使得你可以在方法级别上指定操作的数据类型，从而增强了代码的灵活性和通用性。
示例：
public <T> T getElementFromArray(T[] array, int index) {
if (array != null && index >= 0 && index < array.length) {
return array[index];
} else {
return null;
}
}
讨论泛型的限制和注意事项：
- 不能使用基本类型作为类型参数，只能使用引用类型。
- 不能创建参数化类型的数组，例如
List<String>[] array = new List<String>[10]是非法的。 - 泛型类型的类型参数在运行时是不可知的，会被擦除为原始类型，因此有时会导致编译器警告或类型转换问题。
在这个示例中，getElementFromArray 方法是一个泛型方法，使用类型参数 T 表示方法要操作的数据类型。在调用该方法时，需要指定 T 的具体类型。
3. 泛型的上下限（Upper Bound & Lower Bound）：
泛型的上下限允许你限制泛型类型参数的范围。上限通配符 <? extends 类型> 指定了类型参数必须是指定类型或指定类型的子类，而下限通配符 <? super 类型> 指定了类型参数必须是指定类型或指定类型的父类。
示例：
public void printList(List<? extends Number> list) {
for (Number item : list) {
System.out.println(item);
}
}
public void addIntegerToList(List<? super Integer> list, Integer value) {
list.add(value);
}
在这个示例中，printList 方法使用了上限通配符 <? extends Number>，表示该方法可以接受包含 Number 及其子类的列表。而 addIntegerToList 方法使用了下限通配符 <? super Integer>，表示该方法可以接受 Integer 及其父类的列表，并向列表中添加 Integer 类型的元素。
class Box<T extends Number> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
// 返回类型为 <? extends Number> 的对象
public static Box<? extends Number> createBox(Number value) {
if (value instanceof Integer) {
return new Box<>(value.intValue());
} else if (value instanceof Double) {
return new Box<>(value.doubleValue());
} else {
return null;
}
}
public static <U extends Number> Box<U> createBox2(U value) {
return new Box<>(value);
}
}通过泛型的上下限，我们可以限制泛型类型参数的范围，提高了代码的类型安全性和灵活性。
三、通配符的使用与上下限
通配符是Java泛型中的一种重要机制，用于增加代码的灵活性和安全性。通配符主要用于限制泛型类型参数的范围，以提高代码的可读性和可维护性。以下是通配符的作用和使用方式：
1. 作用：
-
限制泛型类型参数的范围： 通配符可以用来指定泛型类型参数的上限或下限，从而限制泛型类型参数的范围。这样可以增加代码的类型安全性，防止不合法的数据类型被传入或操作。
-
提高代码的灵活性： 通配符可以使代码更加灵活，允许接受多种不同类型的数据，而不需要在方法或类的声明中指定具体的数据类型。
2. 使用方式：
- 上限通配符
<? extends 类型>： 表示泛型类型参数必须是指定类型或指定类型的子类。适用于只读操作，例如遍历集合或获取元素。public void processList(List<? extends Number> list) { ... } - 下限通配符
<? super 类型>： 表示泛型类型参数必须是指定类型或指定类型的父类。适用于写操作，例如向集合中添加元素。public void addToList(List<? super Integer> list) { ... } -
无界通配符
<?>： 表示泛型类型参数是未知的，可以是任意类型。通常用于接受任意类型的数据，但不能对其进行具体的操作。public void printList(List<?> list) { ... }通配符的正确使用可以提高代码的灵活性和安全性，但也需要谨慎处理，避免滥用通配符导致代码可读性下降。通配符的选择取决于方法或类的具体需求，应根据情况选择合适的通配符来限制泛型类型参数的范围。
四、泛型的限制
尽管泛型是一种强大的特性，但在使用时还是有一些限制和注意事项需要考虑，这些包括：
-
不能使用基本数据类型： 泛型类型参数不能是基本数据类型，例如
int、char、double等。只能使用引用类型作为类型参数。但是Java提供了对应的包装类（例如Integer、Character、Double等），可以用作泛型类型参数。。 -
不能实例化泛型类型参数： 不能直接实例化泛型类型参数，例如
T t = new T();是非法的。因为在运行时无法确定泛型类型参数的具体类型。 -
静态上下文中不能引用泛型类型参数： 在静态方法或静态初始化块中，不能引用泛型类型参数，因为静态上下文是在类加载时处理的，无法确定泛型类型参数的具体类型。
-
泛型类型的类型擦除： 泛型在编译时会进行类型擦除，即将泛型类型参数替换为它们的边界或Object类型。因此，在运行时无法获取泛型类型参数的具体类型信息，会导致一些限制和约束。
-
通配符类型的局限性： 通配符类型（例如
<? extends 类型>或<? super 类型>）虽然提供了灵活性，但在一些情况下会限制对泛型类型的操作，例如不能向带有上限通配符的集合添加元素，不能从带有下限通配符的集合中获取元素等。 -
类型擦除可能引发警告： 在使用泛型时，有时可能会收到类型擦除相关的警告，例如未检查或未经过验证的操作。尽管这些警告通常是安全的，但你应该尽可能解决它们，以确保代码的健壮性和可读性。
五、泛型与通配符的对比
通配符（Wildcard）与泛型（Generics）在 Java 中是紧密相关的概念，都用于增强程序的类型安全性和灵活性。泛型是用于描述类的，通配符是用于限制类的。它们的关系可以通过以下几个方面来理解：
1. 目的的相似性
泛型和通配符都旨在提供更广泛的类型安全，同时提高代码的可重用性。泛型通过允许在类、接口和方法上使用类型参数来实现这一点，而通配符则用于表达对泛型类型的不确定性或灵活性。
2. 使用场景
- 泛型：泛型主要用于声明和实现通用的算法和数据结构，其类型在使用时才确定。泛型提供了一个框架，允许开发者在编译时定义类、接口和方法，这些定义中的类型参数在运行时具体化为实际的类型。
- 通配符：通配符用于使用泛型时增加额外的灵活性。它们主要用于泛型实例的类型参数不确定时的情况，比如方法参数、返回类型或泛型变量。通配符可以使用无界通配符（
?）、有界通配符（? extends Type）和下界通配符（? super Type）来表示。
3. 泛型与通配符的互补性
- 在实现泛型类或方法时，你定义泛型类型。例如，一个泛型类
Box<T>允许创建Box<Integer>、Box<String>等具体类型的实例。 - 当你需要操作这些具体化的泛型类型时，尤其是在你不需要或不能指定精确类型的情况下，通配符就显得非常有用。例如，编写一个方法来处理
Box<Number>和其子类型如Box<Integer>的方法，可以使用Box<? extends Number>作为参数类型。
4. 限制与灵活性
- 泛型：泛型的主要限制是它们的类型参数在实例化时必须被指定为具体的类型。
- 通配符：通配符提供了一种方式来表达类型参数的灵活性，允许在不完全知道具体类型的情况下操作泛型对象。例如，使用上界通配符可以允许方法接受任何类型为
Number或其子类的泛型对象。
总结
通配符作为泛型系统的一部分，允许在不牺牲类型安全性的前提下，对泛型代码进行更为灵活的操作。这使得Java的集合框架（如 List<?> 或 Map<?, ?>）、函数接口和其他使用泛型的API更加强大和灵活。通过泛型和通配符的配合使用，Java 开发者可以编写出既通用又类型安全的代码。
泛型和通配符都可以设定上限（extends）和下限（super），但它们在应用上界和下界的方式和上下文中有所不同。这些差异主要体现在泛型类型参数的声明和通配符的使用上。理解这些区别有助于更合理地设计和实现泛型接口、类和方法。
泛型类型参数的上下限
在泛型类或方法中，类型参数可以设定上限，但通常不设置下限。设定上限是通过使用关键字 extends 实现的，这意味着类型参数必须是特定类的子类型，可以是类或接口。
public class GenericClass<T extends Number> { // T 必须是 Number 或其子类
private T value;
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
public <T extends Comparable<T>> T max(T x, T y) {
return x.compareTo(y) > 0 ? x : y;
}
在这些例子中，T 必须是 Number 或其子类的实例，T 必须实现 Comparable<T> 接口。
通配符的上下限
通配符（?）在泛型使用中提供了一种方式来表达对泛型类型参数的不确定性。通配符可以设定上限和下限：
-
上限（
? extends Type）：表示参数化类型的未知类型参数是Type或其任何子类型。这主常用于安全地访问数据。 -
下限（
? super Type）：表示参数化类型的未知类型参数是Type或其任何父类型。这主常用于安全地插入数据。
示例：
public void printList(List<? extends Number> list) {
for (Number n : list) {
System.out.println(n);
}
}
public void addNumbers(List<? super Integer> list) {
list.add(123); // 安全地添加一个 Integer
}
主要区别
-
应用点：
- 泛型上下限：泛型的上限用于泛型类或方法的定义中，确保使用泛型时的类型安全。
- 通配符上下限：通配符的上下限用于方法的参数中，提供对各种泛型类型更广泛的兼容性。
-
灵活性：
- 泛型的上限是在定义时确定的，它强制类型必须遵守某种继承层次。
- 通配符的上下限允许在使用泛型时根据需要选择灵活性，不必在泛型定义时全部确定。
-
使用场景：
- 泛型上下限通常用于定义泛型类、接口或方法，这影响了整个类或方法。
- 通配符上下限通常用于方法的输入参数，使得方法可以接受更广泛的类型，特别是在API设计中非常有用。
//对T的限制只能放在前面，对整个方法用到T的地方起到限制,而通配符的限制往往只在使用时 public<T extends Comparator<T>> void printList(List<? extends Objects> list) { for (Object element : list) { System.out.print(element + " "); } System.out.println(); }
1616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
