文章目录
- 1. 为什么需要泛型？
- 2. 泛型的基本概念
- 3. 泛型类的例子
- 4. 泛型方法的例子
- 5. 泛型的好处
- 泛型使用的位置
- 1. 泛型类（Generic Class）：
- 2. 泛型接口（Generic Interface）：
- 3. 泛型方法（Generic Method）：
- 4. 泛型通配符（Generic Wildcard）：
- 5. 泛型上下界（Generic Bounds）：
- 6. 泛型数组（Generic Array）：
当我们谈到“泛型”时，我们实际上是在谈论一种在编程中用来处理不同类型数据的方法。想象一下，你写了一个很好用的方法或者类，但是它只能处理一种特定类型的数据，如果你想处理其他类型，你就得重写或者重新实现。这时，泛型就派上用场了。
1. 为什么需要泛型？
考虑一个简单的例子，比如一个存储数据的盒子（Box）。你可能想要一个可以存储整数的盒子，也可能需要一个可以存储字符串的盒子。如果没有泛型，你可能需要为每一种数据类型写一个不同的盒子类。
泛型就是为了解决这样的问题。它允许你写一个通用的类或者方法，可以适用于多种数据类型，而不用为每一种类型写不同的代码。
2. 泛型的基本概念
在使用泛型时，我们通常会看到一些带尖括号的符号 <T>，其中 T 是类型的占位符。这个 T 可以是任何你希望使用的数据类型。当你实际使用泛型时，你会将这个占位符替换成你实际想要的类型。
3. 泛型类的例子
比如，有一个 Box 类，你可以用它来存储各种类型的数据：
public class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
这里的 <T> 表示这是一个泛型类，T 是一个占位符，代表实际的类型。你可以创建一个存储整数的盒子：
Box<Integer> intBox = new Box<>(42);
或者创建一个存储字符串的盒子：
Box<String> stringBox = new Box<>("Hello, Generics!");
4. 泛型方法的例子
同样，你也可以在方法中使用泛型。比如，有一个泛型方法，可以打印任意类型的数据：
public class Utils {
public static <T> void printValue(T value) {
System.out.println("Value: " + value);
}
}
你可以用这个方法来打印整数：
Utils.printValue(42);
或者打印字符串：
Utils.printValue("Hello, Generics!");
5. 泛型的好处
- 代码重用： 你可以编写更通用、可重用的代码，而不用为每一种数据类型写不同的实现。
- 类型安全： 编译器会在编译时检查类型，防止一些在运行时可能出现的类型错误。
- 简化代码： 不再需要进行强制类型转换，代码更加清晰简洁。
泛型可能在一开始看起来有点抽象，但一旦你理解了它的基本概念，你会发现它是一种非常有用的工具，能够让你的代码更加灵活、通用和安全。
泛型使用的位置
泛型可以在很多不同的位置使用，包括类、接口、方法等。下面是一些常见的使用位置：
1. 泛型类（Generic Class）：
public class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
public static void main(String[] args) {
// 使用泛型类存储整数
Box<Integer> intBox = new Box<>(42);
int intValue = intBox.getValue();
// 使用泛型类存储字符串
Box<String> stringBox = new Box<>("Hello, Generics!");
String stringValue = stringBox.getValue();
}
}
在类的声明中，使用 <T> 表示这是一个泛型类，T 是一个类型参数。
2. 泛型接口（Generic Interface）：
public interface Pair<T> {
T getFirst();
T getSecond();
}
// 实现泛型接口
class OrderedPair<T> implements Pair<T> {
private T first;
private T second;
public OrderedPair(T first, T second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return first;
}
public T getSecond() {
return second;
}
public static void main(String[] args) {
// 创建存储整数的OrderedPair对象
OrderedPair<Integer> pair = new OrderedPair<>(10, 20);
int firstValue = pair.getFirst();
int secondValue = pair.getSecond();
}
}
同样，在接口的声明中，使用 <T> 表示这是一个泛型接口。
3. 泛型方法（Generic Method）：
public class Utils {
public static <T> void printValue(T value) {
System.out.println("Value: " + value);
}
public static void main(String[] args) {
// 调用泛型方法，编译器会根据传入参数的类型进行类型推断
printValue("Hello, Generics!");
printValue(42);
}
}
在方法的返回类型之前，使用 <T> 表示这是一个泛型方法。泛型方法允许你在调用时指定类型参数，而不是在整个类或接口中指定。
4. 泛型通配符（Generic Wildcard）：
有时，你可能不关心泛型的具体类型，而只想表示它是某个类型的子类。这时可以使用通配符 ?：
import java.util.List;
public class GenericWildcardExample {
public void processList(List<?> list) {
// 处理 list 中的元素，但不关心具体类型
for (Object item : list) {
System.out.println(item);
}
}
}
5. 泛型上下界（Generic Bounds）：
有时，你希望限制泛型的类型范围，可以使用上下界：
public class GenericBoundsExample {
public <T extends Number> void processNumber(T number) {
// 处理数字类型的数据
double square = number.doubleValue() * number.doubleValue();
System.out.println("Square: " + square);
}
}
这表示 T 必须是 Number 类型或其子类。
6. 泛型数组（Generic Array）：
在 Java 中，创建泛型数组是有限制的，不能直接使用 new T[] 的方式创建泛型数组。通常可以使用 List 来代替。
import java.util.ArrayList;
import java.util.List;
public class GenericArrayExample {
public <T> List<T> createGenericList(T... elements) {
List<T> list = new ArrayList<>();
for (T element : elements) {
list.add(element);
}
return list;
}
public static void main(String[] args) {
GenericArrayExample example = new GenericArrayExample();
// 创建存储整数的列表
List<Integer> intList = example.createGenericList(1, 2, 3);
// 创建存储字符串的列表
List<String> stringList = example.createGenericList("A", "B", "C");
}
}
总体而言，泛型的使用位置取决于你的需求。在大多数情况下，你可能会在类和方法上使用泛型，以实现更通用和灵活的代码。
