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

泛型类

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

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); // 调用时类型为 IntegerSystem.out.println("Max Integer: " + maxInt); // 输出: 10String[] fruits = {"Apple", "Banana", "Mango"};String maxFruit = findMax(fruits); // 调用时类型为 StringSystem.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;}// 新增方法：重置内容为 nullpublic 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()); // 输出: falseintBox.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.0System.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类型读取}
}

关键点：

• 参数 dest 可以是 List、List 等（父类型容器）。
• 允许添加 Integer 或其子类型的元素。