Java基础 - 泛型（常见用法）

最新推荐文章于 2025-04-12 11:29:35 发布

递归书房

最新推荐文章于 2025-04-12 11:29:35 发布

阅读量652

点赞数 7

分类专栏： Java基础系列文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/gdr12/article/details/147154084

版权

Java基础系列专栏收录该内容

4 篇文章

订阅专栏

文章目录

泛型类
泛型方法
泛型类派生子类
类型通配符

泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。这样的话，用户明确了什么类型，该类就代表着什么类型，用户在使用的时候就不用担心强转的问题，和运行时转换异常的问题了。

public class Box<T> {
    private T content;  // 泛型字段

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    public static void main(String[] args) {
        // 存储字符串类型
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello Generics");
        System.out.println(stringBox.getContent()); // 输出: Hello Generics

        // 存储整数类型
        Box<Integer> intBox = new Box<>();
        intBox.setContent(100);
        int value = intBox.getContent(); // 无需强制类型转换
        System.out.println(value);       // 输出: 100
    }
}

关键点：

Box<T> 的 T 是类型参数，使用时由开发者指定具体类型（如 String 或 Integer）。
类型安全：例如 stringBox.setContent(100) 会在编译时报错。

泛型方法

除了在类上使用泛型，我们可能就仅仅在某个方法上需要使用泛型，外界仅仅是关心该方法，不关心类其他的属性，这样的话，我们在整个类上定义泛型，未免就有些大题小作了。那么此时，我们可以采用泛型方法。

public class MaxFinder {

    /**
     * 泛型方法：找到数组中的最大值（要求元素类型实现 Comparable 接口）
     * @param array 输入数组
     * @return 最大值
     */
    public static <T extends Comparable<T>> T findMax(T[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("数组不能为空");
        }
        T max = array[0];
        for (T item : array) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Integer[] integers = {5, 8, 2, 10};
        Integer maxInt = findMax(integers); // 调用时类型为 Integer
        System.out.println("Max Integer: " + maxInt); // 输出: 10

        String[] fruits = {"Apple", "Banana", "Mango"};
        String maxFruit = findMax(fruits); // 调用时类型为 String
        System.out.println("Max String: " + maxFruit); // 输出: Mango（按字典序比较）
    }
}

关键点：

<T> 声明在方法返回类型前，表示这是一个泛型方法，独立于类是否泛型。
<T extends Comparable<T>> 确保类型 T 的对象可以相互比较（通过 compareTo 方法）。
类型安全：拒绝不可比较的类型：例如 findMax(new Object[]{…}) 会编译失败。
返回 T 类型，确保返回元素类型与输入数组类型完全一致。

泛型类派生子类

前面我们已经定义了泛型类，泛型类是拥有泛型特性的类，它本质上还是一个 J av a 类，那么它就可以被继承或实现。这个情况比较多：

示例 1：子类固定父类泛型类型（`StringBox` 继承自 `Box<String>`）

子类直接指定父类泛型参数的具体类型，适用于特定场景的扩展：

// 泛型父类
class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }
    public T getContent() {
        return content;
    }
}
// 子类继承时指定父类泛型类型为 String
class StringBox extends Box<String> {
    // 新增方法：专为字符串内容设计
    public void toUpperCase() {
        String value = getContent(); // 直接使用 String 类型
        if (value != null) { 
            setContent(value.toUpperCase());
        }
    }
}
public class Main {
    public static void main(String[] args) {
        StringBox box = new StringBox();
        box.setContent("hello");
        box.toUpperCase();
        System.out.println(box.getContent()); // 输出: HELLO
    }
}

关键点：

子类 StringBox 继承时固定了父类泛型为 String，因此 getContent() 直接返回 String 类型。
子类可以添加与固定类型相关的专属方法（如 toUpperCase）。

示例 2：子类保留父类泛型类型（`AdvancedBox<T>` 继承自 `Box<T>`)

子类保持父类泛型参数的灵活性，并扩展新功能：

// 父类定义不变，与示例1相同

// 子类保留父类的泛型参数 <T>
class AdvancedBox<T> extends Box<T> {
    // 新增方法：检查内容是否为空
    public boolean isEmpty() {
        return getContent() == null;
    }

    // 新增方法：重置内容为 null
    public void clear() {
        setContent(null);
    }
}

public class Main2 {
    public static void main(String[] args) {
        AdvancedBox<Integer> intBox = new AdvancedBox<>();
        intBox.setContent(100);
        System.out.println(intBox.isEmpty()); // 输出: false
        intBox.clear();
        System.out.println(intBox.getContent()); // 输出: null
    }
}

关键点：

子类 AdvancedBox<T> 保留父类泛型参数 <T>，可复用父类逻辑。
功能上扩展了新方法（如 isEmpty 和 clear），独立于具体类型的通用操作。

示例 3：添加子类自己的泛型参数（`KeyValuePair<K,V>` 继承自 `Pair<K>`）

父子类均使用泛型，子类引入新的类型参数：

// 泛型父类
class Pair<T> {
    private T first;
    private T second;

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

    public T getFirst() { return first; }
    public T getSecond() { return second; }
}

// 子类添加新的泛型参数 V，与父类参数 K 独立
class KeyValuePair<K, V> extends Pair<K> {
    private V value;

    public KeyValuePair(K key, V value) {
        super(key, key); // 父类需要两个同类型参数，此处复用 key 作为示例
        this.value = value;
    }

    // 新增方法：获取键值对的独立值
    public V getValue() { return value; }
}

public class Main3 {
    public static void main(String[] args) {
        KeyValuePair<String, Integer> entry = new KeyValuePair<>("Age", 30);
        String key = entry.getFirst(); // 类型为 String（父类返回值）
        int value = entry.getValue();  // 类型为 Integer（子类新增方法）
        System.out.println(key + ": " + value); // 输出: Age: 30
    }
}

关键点：

子类 KeyValuePair<K, V> 扩展了父类的泛型参数 <K>，并新增了独立参数 <V>。
父子类泛型参数独立，子类可以实现更复杂的数据结构（如键值对）。

示例 4：约束父类类型边界（`IntCalculator` 继承自 `NumberCalculator<Integer>`）

子类继承时遵循父类的泛型约束（如 <T extends Number>），并进一步具体化：

// 泛型父类，约束类型必须为 Number 的子类
class NumberCalculator<T extends Number> {
    protected T value;

    public NumberCalculator(T value) {
        this.value = value;
    }

    public double doubleValue() {
        return value.doubleValue();
    }
}

// 子类指定父类泛型类型为 Integer
class IntCalculator extends NumberCalculator<Integer> {
    public IntCalculator(Integer value) {
        super(value);
    }

    // 新增方法：计算平方（专为 Integer 设计）
    public int squareInt() {
        return value * value;
    }
}

public class Main4 {
    public static void main(String[] args) {
        IntCalculator calc = new IntCalculator(5);
        System.out.println(calc.doubleValue()); // 输出: 5.0（调用父类方法）
        System.out.println(calc.squareInt());   // 输出: 25（子类专属方法）
    }
}

关键点：

父类 NumberCalculator<T> 的泛型参数已被约束为 <T extends Number>。
子类 IntCalculator 继承时将泛型固定为 Integer，确保父类逻辑安全，同时添加 Integer 专用的新方法。

类型通配符

示例 1：无界通配符（`<?>`）

用于处理未知类型的集合，适合只读取集合内容的场景：

public class UnboundedWildcardDemo {
    /**
     * 打印任意类型集合的元素
     * @param list 使用无界通配符 <?>，表示接受任意类型的 List
     */
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        List<Integer> numbers = Arrays.asList(1, 2, 3);

        printList(names);   // 输出: Alice Bob Charlie 
        printList(numbers); // 输出: 1 2 3 
    }
}

关键点：

List<?> 可以接受任何类型的 List，如 List<String>、List<Integer>。
只能读取元素（返回 Object），但不能添加元素（除了 null），因为具体类型未知。

示例 2：上界通配符（`<? extends Number>`）

限制类型为 Number 或其子类（如 Integer、Double），适合读取场景：

public class UpperBoundedWildcardDemo {
    /**
     * 计算数值列表的总和
     * @param list 使用上界通配符 <? extends Number>
     * @return Sum of numbers as double
     */
    public static double sumOfList(List<? extends Number> list) {
        double sum = 0.0;
        for (Number num : list) {
            sum += num.doubleValue(); // 调用 Number 的方法
        }
        return sum;
    }

    public static void main(String[] args) {
        List<Integer> integers = Arrays.asList(1, 2, 3);
        List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);

        System.out.println(sumOfList(integers)); // 输出: 6.0
        System.out.println(sumOfList(doubles));  // 输出: 6.6
    }
}

关键点：

参数 list 可以接受 List<Integer>、List<Double> 等（只要元素是 Number 的子类）。
不能添加元素（如 list.add(5) 会编译报错），具体子类型未知，可能破坏类型安全。

示例 3：下界通配符（`<? super Integer>`）

限制类型为 Integer 或其父类（如 Number、Object），适合写入场景：

public class LowerBoundedWildcardDemo {

    /**
     * 向集合中添加多个 Integer 值
     * @param dest 使用下界通配符 <? super Integer>,可以接受Integer或其父类（如Number、Object）的List
     * @param values 要添加的多个 Integer 值
     */
    public static void addNumbersToList(List<? super Integer> dest, List<Integer> values) {
        dest.addAll(values); 
    }

    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        addNumbersToList(numberList, Arrays.asList(10, 20, 30));
        System.out.println(numberList); // 输出: [10, 20, 30]

        List<Object> objectList = new ArrayList<>();
        addNumbersToList(objectList, Arrays.asList(100, 200));
        System.out.println(objectList); // 输出: [100, 200]
        
        List<? super Integer> list = new ArrayList<Number>();
        list.add(1); // 允许
        Object obj = list.get(0); // 只能作为Object类型读取

    }
}