java泛型基本知识和通用方法

Java泛型基本知识和通用方法攻略

1. 泛型的概念

泛型是Java 5中引入的一个新特性，它是为了解决在使用集合时发现的类型安全问题而设计的。泛型的本质就是参数化类型，即将类型作为参数传递。

在使用泛型时，需要知道以下几个关键字：

• 类型参数：使用尖括号<>括起来的类型名称，可以是任何标识符，但通常使用单个大写字母（如T、E、K表示Key、V表示Value等）表示泛型类型。
• 泛型类：带有泛型类型参数的类，例如List<T>。
• 泛型方法：带有泛型类型参数的方法，例如<T> T getInstance(Class<T> clazz)。

2. 基本语法

泛型的基本语法是在类型后面添加尖括号<>，并将泛型类型参数放在其中，例如：

public class MyClass<T> {
    // ...
}

在使用泛型类时，需要指定具体的泛型类型，例如：

MyClass<String> instance = new MyClass<String>();

这里将MyClass的泛型类型参数T指定为String，这样在使用MyClass类的方法时，就可以直接传入String类型的参数。

3. 泛型的通配符

通配符用于表示泛型类型的未知实参。有时候我们需要在使用泛型类时，对泛型类型的范围进行限制，这时候就可以使用通配符。通配符有两种，一种是?表示可以接受任何类型的实参，另一种是? extends 类型，表示可以接受所有该类型以及其子类型的实参。

例如：

public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

这里使用了?通配符表示可以接受任何类型的List对象，如果使用List<String>或List<Integer>等具体类型的实参都是可以的。

4. 泛型的限定

泛型的限定是指对泛型类型参数的取值范围进行限制，主要有以下两种：

• 上限限定：使用extends关键字限制泛型类型参数的上限，表示只能接受该类型及其子类型的实参。
• 下限限定：使用super关键字限制泛型类型参数的下限，表示只能接受该类型及其父类型的实参。

例如：

public <T extends Number> T addList(List<T> list) {
    // ...
}

public void printList(List<? super Integer> list) {
    // ...
}

第一个方法中，使用了extends关键字限制泛型类型参数T必须是Number及其子类，这样就可以在方法中调用Number及其子类的方法。

第二个方法中，使用了super关键字限制泛型类型参数?必须是Integer及其父类，这样就可以将Integer对象及其父类对象添加到List中。

5. 示例说明

示例一：泛型类的定义和使用

public class Pair<T, V> {
    private T first;
    private V second;

    public Pair(T first, V second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public V getSecond() {
        return second;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(V second) {
        this.second = second;
    }
}

// 使用泛型类Pair
Pair<String, Integer> pair = new Pair<>("Hello", 123);
System.out.println(pair.getFirst()); // 输出"Hello"
System.out.println(pair.getSecond()); // 输出123

在这个例子中，我们定义了一个泛型类Pair，它有两个泛型类型参数T和V，分别表示成对出现的两个元素的类型。在使用泛型类时，可以指定具体的泛型类型来实例化一个对象，例如Pair<String, Integer>表示第一个元素为String，第二个元素为Integer。

示例二：泛型方法与通配符的使用

public class Utils {
    public static <T> T max(List<? extends T> list) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        T result = list.get(0);
        for (T item : list) {
            if (item.compareTo(result) > 0) {
                result = item;
            }
        }
        return result;
    }
}

// 使用泛型方法
List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
Integer max1 = Utils.max(list1);
System.out.println(max1); // 输出5

List<String> list2 = Arrays.asList("apple", "banana", "orange");
String max2 = Utils.max(list2);
System.out.println(max2); // 输出"orange"

在这个例子中，我们定义了一个泛型方法max，它接受一个List对象，并使用通配符<? extends T>限制该对象的类型范围为T及其子类。在方法中，使用类型参数T表示返回值的类型，并使用compareTo方法比较列表中的元素大小。在使用泛型方法时，可以直接传入一个List<Integer>或List<String>等具体类型的参数，返回值会根据具体类型而确定。