当前位置：首页 > news >正文

摄影婚纱网站建设人和马做的网站

news 2025/9/16 16:30:23

摄影婚纱网站建设,人和马做的网站,wordpress 随机播放,wordpress不适合大型网站Java泛型类和泛型方法是Java泛型编程中的重要组成部分。它们允许开发者编写类型安全且高度复用的代码。下面详细介绍泛型类和泛型方法的概念、用法和示例。泛型类泛型类是在类定义中使用类型参数的类，可以指定具体的类型实例化该类。这样可以确保类型安全&#…

Java泛型类和泛型方法是Java泛型编程中的重要组成部分。它们允许开发者编写类型安全且高度复用的代码。下面详细介绍泛型类和泛型方法的概念、用法和示例。

泛型类

泛型类是在类定义中使用类型参数的类，可以指定具体的类型实例化该类。这样可以确保类型安全，并且提高代码的复用性。

声明泛型类

泛型类的声明格式如下：

1public class ClassName<TypeParameters> {
2    // 类成员
3}

其中，TypeParameters是一个或多个类型参数的列表，用逗号分隔。类型参数通常使用大写字母表示，如T、E、K、V等。

示例1：简单泛型类

1public class Box<T> {
2    private T item;
3
4    public Box(T item) {
5        this.item = item;
6    }
7
8    public T getItem() {
9        return item;
10    }
11
12    public void setItem(T item) {
13        this.item = item;
14    }
15}
16
17// 使用泛型类
18Box<String> stringBox = new Box<>("Hello");
19String value = stringBox.getItem(); // 编译时类型检查

在这个例子中，Box类使用类型参数T，表示可以存储任何类型的对象。实例化时指定具体类型，如Box<String>。

示例2：泛型类的继承

泛型类也可以继承其他类，并且可以指定父类的类型参数。

1public class Box<T> {
2    private T item;
3
4    public Box(T item) {
5        this.item = item;
6    }
7
8    public T getItem() {
9        return item;
10    }
11
12    public void setItem(T item) {
13        this.item = item;
14    }
15}
16
17public class NumberBox<T extends Number> extends Box<T> {
18    public NumberBox(T item) {
19        super(item);
20    }
21}
22
23// 使用泛型类的继承
24NumberBox<Integer> intBox = new NumberBox<>(123);
25Integer value = intBox.getItem(); // 编译时类型检查

在这个例子中，NumberBox类继承自Box类，并且指定了类型参数T必须是Number的子类型。

泛型方法

泛型方法是在方法定义中使用类型参数的方法，可以在非泛型类或接口中声明。泛型方法允许在方法内部使用泛型类型参数，从而实现类型安全的代码。

声明泛型方法

泛型方法的声明格式如下：

1public ReturnType methodName<TypeParameters>(ParameterTypes...) {
2    // 方法体
3}

其中，TypeParameters是一个或多个类型参数的列表，用逗号分隔。

示例1：简单泛型方法

1public class Utility {
2    public static <T> void printArray(T[] array) {
3        for (T element : array) {
4            System.out.println(element);
5        }
6    }
7}
8
9// 使用泛型方法
10Integer[] intArray = {1, 2, 3};
11Utility.printArray(intArray);

在这个例子中，printArray方法使用类型参数T，表示可以处理任何类型的数组。调用时指定具体类型，如Integer[]。

示例2：泛型方法的返回值

泛型方法也可以返回泛型类型的值。

1public class Utility {
2    public static <T> T max(T[] array, Comparator<T> comparator) {
3        if (array == null || array.length == 0) {
4            throw new IllegalArgumentException("Array must not be null or empty.");
5        }
6
7        T maxElement = array[0];
8        for (int i = 1; i < array.length; i++) {
9            if (comparator.compare(array[i], maxElement) > 0) {
10                maxElement = array[i];
11            }
12        }
13
14        return maxElement;
15    }
16}
17
18// 使用泛型方法的返回值
19Integer[] intArray = {1, 2, 3};
20Comparator<Integer> comparator = Integer::compare;
21Integer maxValue = Utility.max(intArray, comparator);
22System.out.println("Max value: " + maxValue); // 输出 Max value: 3

在这个例子中，max方法返回最大值，类型参数T表示数组元素的类型。

泛型类与泛型方法的组合

泛型类和泛型方法可以结合使用，以实现更加灵活的类型安全代码。

示例3：泛型类与泛型方法的组合

1public class Box<T> {
2    private T item;
3
4    public Box(T item) {
5        this.item = item;
6    }
7
8    public T getItem() {
9        return item;
10    }
11
12    public void setItem(T item) {
13        this.item = item;
14    }
15
16    public <U> void swap(Box<U> other) {
17        T temp = this.item;
18        this.item = other.getItem();
19        other.setItem(temp);
20    }
21}
22
23// 使用泛型类与泛型方法的组合
24Box<Integer> intBox = new Box<>(123);
25Box<String> stringBox = new Box<>("Hello");
26
27intBox.swap(stringBox);
28
29Integer intValue = intBox.getItem(); // 输出 Hello
30String stringValue = stringBox.getItem(); // 输出 123

在这个例子中，Box类有一个泛型方法swap，用于交换两个不同类型的Box对象的内容。

类型通配符

类型通配符通常使用?表示，可以表示任何类型。这在处理不确定类型的集合时非常有用。

示例4：使用类型通配符

1public class Utility {
2    public static void printCollection(Collection<?> collection) {
3        for (Object element : collection) {
4            System.out.println(element);
5        }
6    }
7}
8
9// 使用类型通配符
10List<Integer> intList = Arrays.asList(1, 2, 3);
11Utility.printCollection(intList);

在这个例子中，printCollection方法接受任何类型的Collection，使用类型通配符?。