Java泛型简介
Java泛型（Generics）是Java 5.0引入的一项重要特性，旨在提高代码的复用性和类型安全性。通过泛型，程序员可以在编写代码时定义一个类、接口或方法，而不必指定具体的类型。这使得代码更加灵活和通用，减少了重复代码的编写，并且在编译时就能捕获类型错误，避免了运行时的类型转换问题。
泛型的基本概念
泛型的核心思想是使用“类型参数”来代替具体的类型。类型参数通常用大写字母表示，最常见的有T（Type）、E（Element）、K（Key）、V（Value）等。通过这些类型参数，我们可以在定义类、接口或方法时，延迟具体类型的确定，直到实际使用时再指定。
例如，List<T>是一个泛型接口，T是类型参数。当我们创建一个List<String>时，T就被替换为String，表示这是一个存储字符串的列表。
// 定义一个泛型类
public class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}
// 使用泛型类
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello, World!");
System.out.println(stringBox.getContent()); // 输出: Hello, World!在这个例子中，Box<T>是一个泛型类，T可以是任何类型。我们在创建Box对象时指定了String作为类型参数，因此Box<String>只能存储字符串类型的对象。
泛型的优势
-
提高代码复用性：通过泛型，我们可以编写一次代码，适用于多种类型。例如，
ArrayList<T>可以用于存储不同类型的元素，而不需要为每种类型都编写一个单独的类。 -
增强类型安全性：泛型允许编译器在编译时检查类型是否匹配，从而避免了运行时的类型转换错误。例如，在没有泛型的情况下，
ArrayList可以存储任何类型的对象，而在使用泛型后，ArrayList<String>只能存储字符串类型的对象。 -
减少强制类型转换：在非泛型代码中，从集合中获取元素时，通常需要进行强制类型转换。使用泛型后，编译器会自动处理类型转换，减少了代码中的冗余。
-
更好的可读性和维护性：泛型使代码更具表达力，开发者可以通过类型参数明确地知道某个类或方法可以处理哪些类型的数据，从而提高了代码的可读性和维护性。
泛型的语法
1. 泛型类
泛型类是在类声明时使用类型参数来代替具体的类型。类型参数通常出现在类名后的尖括号<>中。以下是一个简单的泛型类示例：
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;
}
public void setKey(K key) {
this.key = key;
}
public void setValue(V value) {
this.value = value;
}
}在这个例子中，Pair<K, V>是一个泛型类，K和V是两个类型参数，分别代表键和值的类型。我们可以根据需要为K和V指定不同的类型：
Pair<String, Integer> pair = new Pair<>("Age", 25);
System.out.println(pair.getKey() + ": " + pair.getValue()); // 输出: Age: 252. 泛型接口
泛型接口与泛型类类似，也可以使用类型参数来定义接口。以下是一个泛型接口的示例：
public interface Cache<K, V> {
void put(K key, V value);
V get(K key);
boolean containsKey(K key);
void remove(K key);
}我们可以实现这个接口，并为类型参数指定具体的类型：
public class InMemoryCache<K, V> implements Cache<K, V> {
private Map<K, V> cache = new HashMap<>();
@Override
public void put(K key, V value) {
cache.put(key, value);
}
@Override
public V get(K key) {
return cache.get(key);
}
@Override
public boolean containsKey(K key) {
return cache.containsKey(key);
}
@Override
public void remove(K key) {
cache.remove(key);
}
}3. 泛型方法
泛型方法是指在方法声明中使用类型参数的方法。与泛型类和接口不同，泛型方法的类型参数只在方法的作用域内有效。以下是一个泛型方法的示例：
public class Util {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
}在这个例子中，<T>是方法的类型参数，表示printArray方法可以接受任何类型的数组。我们可以调用这个方法并传入不同类型的数组：
Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"Apple", "Banana", "Orange"};
Util.printArray(intArray); // 输出: 1 2 3 4 5
Util.printArray(stringArray); // 输出: Apple Banana Orange4. 泛型构造函数
泛型构造函数是指在构造函数中使用类型参数的构造函数。以下是一个泛型构造函数的示例：
public class Container<T> {
private T content;
public Container(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}在这个例子中，Container<T>的构造函数接受一个类型为T的参数，并将其赋值给成员变量content。
类型参数的限定
在某些情况下，我们可能希望对泛型的类型参数进行限制，以确保它们满足某些条件。Java提供了两种方式来限制类型参数：上界限定和下界限定。
1. 上界限定（Upper Bound）
上界限定使用extends关键字来指定类型参数必须是某个类或接口的子类型。例如，如果我们希望T必须是Number或其子类（如Integer、Double等），可以使用以下语法：
public class Calculator<T extends Number> {
public double sum(T... numbers) {
double result = 0;
for (T number : numbers) {
result += number.doubleValue();
}
return result;
}
}在这个例子中，Calculator<T>的类型参数T必须是Number或其子类。我们可以创建Calculator<Integer>或Calculator<Double>，但不能创建Calculator<String>，因为String不是Number的子类。
2. 下界限定（Lower Bound）
下界限定使用super关键字来指定类型参数必须是某个类或接口的父类型。例如，如果我们希望T必须是Comparable<? super T>，即T必须实现Comparable接口，并且它可以比较自己或其父类的对象，可以使用以下语法：
public class Comparator<T extends Comparable<? super T>> {
public int compare(T a, T b) {
return a.compareTo(b);
}
}在这个例子中，Comparator<T>的类型参数T必须实现Comparable接口，并且它可以比较自己或其父类的对象。例如，Comparator<String>是有效的，因为String实现了Comparable<String>，而Comparator<Object>也是有效的，因为Object是所有类的父类。
泛型的通配符
通配符（Wildcard）是Java泛型中的一种特殊符号，用于表示未知的类型。通配符可以用在泛型类、接口或方法的参数中，使得代码更加灵活。通配符分为三种类型：无界通配符、上界通配符和下界通配符。
1. 无界通配符（Unbounded Wildcard）
无界通配符使用?表示，表示类型参数可以是任意类型。例如，List<?>表示一个包含任意类型元素的列表。我们无法向List<?>中添加元素（除了null），但可以从中读取元素：
List<?> list = Arrays.asList(1, "two", 3.0);
Object obj = list.get(0); // 可以读取元素，但类型为Object2. 上界通配符（Upper Bounded Wildcard）
上界通配符使用? extends表示，表示类型参数必须是某个类或接口的子类型。例如，List<? extends Number>表示一个包含Number或其子类（如Integer、Double等）元素的列表。我们无法向List<? extends Number>中添加元素（除了null），但可以从中读取元素，并将它们视为Number类型：
List<? extends Number> list = Arrays.asList(1, 2.5, 3L);
Number num = list.get(0); // 可以读取元素，类型为Number3. 下界通配符（Lower Bounded Wildcard）
下界通配符使用? super表示，表示类型参数必须是某个类或接口的父类型。例如，List<? super Integer>表示一个包含Integer或其父类（如Number、Object等）元素的列表。我们可以向List<? super Integer>中添加Integer类型的元素，但无法从中读取元素，除非我们知道列表的实际类型：
List<? super Integer> list = new ArrayList<>();
list.add(1); // 可以添加Integer类型的元素泛型的类型擦除
Java泛型的一个重要特性是类型擦除（Type Erasure）。类型擦除是指在编译时，Java编译器会将泛型代码转换为非泛型代码，并移除所有的类型参数。这意味着在运行时，泛型信息将不再存在，所有泛型类都被视为原始类型（Raw Type）。
例如，List<String>和List<Integer>在编译后都会被转换为List，并且在运行时无法区分它们的具体类型。为了模拟泛型的行为，编译器会在编译时插入必要的类型检查和强制转换。
类型擦除带来了一些限制：
-
无法创建泛型类型的数组：由于类型擦除，编译器无法在运行时确定泛型类型的实际类型，因此不能创建泛型类型的数组。例如，
new List<String>[10]会导致编译错误。 -
无法实例化泛型类型参数：我们不能直接使用
new T()来创建泛型类型参数的实例，因为编译器无法确定T的具体类型。例如，new T()会导致编译错误。 -
泛型类的静态成员不能使用类型参数：由于静态成员属于类本身，而不是类的实例，因此它们不能使用泛型类的类型参数。例如，
static T value;会导致编译错误。
为了克服这些限制，Java提供了一些替代方案，例如使用反射或传递Class对象。
泛型的最佳实践
-
尽量使用泛型：泛型可以提高代码的复用性和类型安全性，因此在设计类、接口或方法时，尽量使用泛型来代替具体的类型。
-
避免使用原始类型：原始类型（Raw Type）是指不带类型参数的泛型类或接口。虽然Java允许使用原始类型，但它们会失去泛型带来的类型安全性和编译时检查。因此，尽量避免使用原始类型。
-
合理使用通配符：通配符可以使代码更加灵活，但也可能导致代码难以理解。因此，在使用通配符时，应该根据具体情况选择合适的通配符类型，并尽量保持代码的简洁性。
-
避免不必要的类型参数：过多的类型参数会使代码变得复杂和难以维护。因此，在设计泛型类或方法时，应该尽量减少类型参数的数量，只保留必要的类型参数。
-
使用类型参数的限定：当需要对泛型的类型参数进行限制时，应该使用上界或下界限定，以确保类型参数满足特定的条件。这可以提高代码的安全性和灵活性。
-
理解类型擦除的影响：由于类型擦除的存在，泛型在运行时并没有具体的类型信息。因此，在编写泛型代码时，应该考虑到类型擦除的影响，并采取相应的措施来避免潜在的问题。
结论
Java泛型是提高代码复用性和类型安全性的强大工具。通过使用泛型，我们可以编写更加灵活和通用的代码，同时避免了运行时的类型转换错误。泛型的语法包括泛型类、泛型接口、泛型方法和泛型构造函数，同时还支持类型参数的限定和通配符的使用。尽管泛型带来了许多优点，但也有一些限制，例如类型擦除和无法创建泛型类型的数组。因此，在使用泛型时，我们应该遵循最佳实践，合理设计泛型代码，以充分发挥其优势。
