Java泛型

关于Java泛型内容学习的笔记

泛型是Java中一种非常重要的特性，它可以让我们在编写代码时指定一些类型参数，从而实现类型的参数化。泛型可以提高代码的可读性、安全性和复用性，避免了不必要的类型转换和运行时异常。

泛型的使用方式主要有三种：泛型类、泛型接口和泛型方法。下面我们分别来介绍一下。

泛型类

泛型类是在类定义时使用一个或多个类型参数的类。例如，我们常用的ArrayList就是一个泛型类，其中E是一个类型参数，表示列表中存储的元素类型。当我们创建一个ArrayList对象时，就可以指定E的具体类型，如ArrayList表示一个存储字符串的列表。

泛型类的定义格式如下：

class 类名<类型参数1, 类型参数2, ...> {
// 类体
}

其中，类型参数通常用单个大写字母表示，常见的有：

• E: 表示元素，如集合中的元素

• T: 表示类型，如一般的Java类

• K: 表示键，如Map中的键

• V: 表示值，如Map中的值

• sN: 表示数值类型

我们也可以自定义泛型类，例如：

// 定义一个泛型类Box，可以存放任意类型的对象
class Box<T> {
private T data; // 使用类型参数T定义一个成员变量

// 构造方法
public Box(T data) {
this.data = data;
}

// 获取数据的方法
public T getData() {
return data;
}
}

然后我们就可以创建不同类型的Box对象，如：

Box<Integer> intBox = new Box<>(10); // 创建一个存放整数的Box对象
Box<String> strBox = new Box<>("Hello"); // 创建一个存放字符串的Box对象
System.out.println(intBox.getData()); // 输出10
System.out.println(strBox.getData()); // 输出Hello

泛型接口

泛型接口是在接口定义时使用一个或多个类型参数的接口。例如，我们常用的Comparable就是一个泛型接口，其中T是一个类型参数，表示可比较的对象类型。当我们实现这个接口时，就需要指定T的具体类型，如String实现了Comparable接口，表示字符串是可比较的。

泛型接口的定义格式如下：

interface 接口名<类型参数1, 类型参数2, ...> {
// 接口体
}

我们也可以自定义泛型接口，例如：

// 定义一个泛型接口Generator，可以生成任意类型的对象
interface Generator<T> {
// 定义一个生成对象的方法
T next();
}

然后我们就可以实现这个接口，并指定具体的类型参数，如：

// 实现Generator接口，并指定类型参数为Integer
class IntegerGenerator implements Generator<Integer> {
private int value = 0;

@Override
public Integer next() {
return value++; // 返回当前值，并自增1
}
}

// 实现Generator接口，并指定类型参数为String
class StringGenerator implements Generator<String> {
private String[] fruits = {"apple", "banana", "orange"}; // 定义一个字符串数组

@Override
public String next() {
Random random = new Random(); // 创建一个随机数对象
int index = random.nextInt(fruits.length); // 随机生成一个数组下标
return fruits[index]; // 返回对应下标的字符串
}
}

然后我们就可以创建不同类型的Generator对象，并调用其方法，如：

Generator<Integer> intGen = new IntegerGenerator(); // 创建一个整数生成器对象
Generator<String> strGen = new StringGenerator(); // 创建一个字符串生成器对象
System.out.println(intGen.next()); // 输出0
System.out.println(intGen.next()); // 输出1
System.out.println(strGen.next()); // 随机输出一个水果名字，如apple
System.out.println(strGen.next()); // 随机输出另一个水果名字，如orange

泛型方法

泛型方法是在方法定义时使用一个或多个类型参数的方法。泛型方法可以定义在普通类中，也可以定义在泛型类中。例如，我们常用的Arrays.sort(T[] a, Comparator<? super T> c)就是一个泛型方法，其中T是一个类型参数，表示数组元素和比较器操作的对象类型。

泛型方法的定义格式如下：

修饰符 <类型参数1, 类型参数2, ...> 返回值类型 方法名(形参列表) {
// 方法体
}

其中，类型参数声明部分放在修饰符和返回值类型之间，用尖括号括起来，并用逗号分隔。注意这里的类型参数和类定义时的类型参数没有关系，即使同名也不是同一个参数。

我们也可以自定义泛型方法，例如：

// 定义一个普通类MathUtil，包含一个泛型方法max，可以返回三个可比较对象中的最大值

class MathUtil {
public static <T extends Comparable<T>> T max(T x, T y, T z) {
T max = x; // 假设x是最大值
if (y.compareTo(max) > 0) { // 如果y比max大，则更新max为y
max = y;
}
if (z.compareTo(max) > 0) { // 如果z比max大，则更新max为z
max = z;
}
return max; // 返回最大值
}
}

然后我们就可以调用这个泛型方法，并传入不同类型的参数，如：

System.out.println(MathUtil.max(10, 20, 15)); // 输出20
System.out.println(MathUtil.max(3.14, 2.73, 1.68)); // 输出3.14
System.out.println(MathUtil.max("hello", "world", "java")); // 输出world