深入 Java 泛型：基础应用与实战技巧

在 Java 泛型中，T、E、K、V、? 是常见的占位符符号，它们本质上没有区别，只是命名习惯不同，用于提高代码可读性。以下是详细解释和案例：

一、符号的常见含义

二、具体案例解析

1. T（通用类型）

• 用途：表示任意类型，常见于泛型类或泛型方法。
• 示例：定义一个泛型类 Box<T>，可以存放任意类型的对象。

  public class Box<T> {
      private T content;
      
      public void setContent(T content) {
          this.content = content;
      }
      
      public T getContent() {
          return content;
      }
  }
  
  // 使用示例
  Box<String> stringBox = new Box<>();
  stringBox.setContent("Hello");
  Box<Integer> intBox = new Box<>();
  intBox.setContent(100);
  

2. E（集合元素）

• 用途：表示集合中的元素类型，常见于集合类。
• 示例：自定义一个简单的集合类 MyList<E>。

  public class MyList<E> {
      private E[] elements;
      
      public void add(E element) { /* 添加元素 */ }
      public E get(int index) { /* 获取元素 */ }
  }
  
  // 使用示例
  MyList<String> list = new MyList<>();
  list.add("Java");
  String element = list.get(0);
  

3. K 和 V（键值对）

• 用途：表示键值对的键和值类型，常见于 Map 类。
• 示例：自定义一个泛型键值对类 Pair<K, V>。

  public class Pair<K, V> {
      private K key;
      private V value;
      
      public Pair(K key, V value) {
          this.key = key;
          this.value = value;
      }
      
      public K getKey() { return key; }
      public V getValue() { return value; }
  }
  
  // 使用示例
  Pair<String, Integer> pair = new Pair<>("Age", 25);
  String key = pair.getKey();    // "Age"
  int value = pair.getValue();   // 25
  

4. ?（通配符）

• 用途：表示未知类型，常用于泛型方法的参数或返回值。
• 示例：编写一个方法，打印任意类型集合的内容。

  public void printList(List<?> list) {
      for (Object item : list) {
          System.out.println(item);
      }
  }
  
  // 使用示例
  List<String> strings = Arrays.asList("A", "B", "C");
  List<Integer> numbers = Arrays.asList(1, 2, 3);
  printList(strings);  // 输出 A, B, C
  printList(numbers);  // 输出 1, 2, 3
  

三、通配符 ? 的进阶用法

1. 上界通配符 <? extends T>

• 用途：表示类型是 T 或其子类。
• 示例：处理数字集合（如 Integer、Double）。

  public double sum(List<? extends Number> numbers) {
      double sum = 0;
      for (Number num : numbers) {
          sum += num.doubleValue();
      }
      return sum;
  }
  
  // 使用示例
  List<Integer> integers = Arrays.asList(1, 2, 3);
  List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
  System.out.println(sum(integers));  // 6.0
  System.out.println(sum(doubles));   // 6.6
  

2. 下界通配符 <? super T>

• 用途：表示类型是 T 或其父类。
• 示例：向集合中添加 T 类型的元素。

  public void addNumbers(List<? super Integer> list) {
      list.add(1);
      list.add(2);
  }
  
  // 使用示例
  List<Number> numbers = new ArrayList<>();
  addNumbers(numbers);  // 可以添加 Integer 到 Number 集合
  

四、符号的命名习惯总结

五、注意事项

1. 符号可自定义：
   你可以使用其他字母（如 A、B），但遵循习惯能提高代码可读性。

   public class MyGeneric<A, B> { /* ... */ }  // 合法但不推荐
   

2. 通配符 ? 的限制：

   • 不能直接实例化泛型类型：List<?> list = new ArrayList<?>(); ❌
   • 正确写法：List<?> list = new ArrayList<>(); ✅

3. 类型擦除：
   泛型信息在编译后会被擦除，运行时无法获取具体类型（如 T 的实际类型）。

通过以上案例，可以清晰理解不同符号的用途和区别！