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

JavaSE核心知识点02面向对象编程02-07（枚举）

news 来源：原创 2025/5/13 13:02:42

🤟致敬读者

🟩感谢阅读🟦笑口常开🟪生日快乐⬛早点睡觉

📘博主相关

🟧博主信息🟨博客首页🟫专栏推荐🟥活动信息

文章目录

## JavaSE核心知识点02面向对象编程02-07（枚举）
- - **一、泛型存在的意义**
  - **二、泛型核心语法**
  - **三、类型通配符**
  - **四、类型擦除与限制**
  - **五、泛型高级应用**
  - **六、最佳实践与常见错误**
  - **七、学习建议**

📃文章前言

🔷文章均为学习工作中整理的笔记。
🔶如有错误请指正，共同学习进步。

## JavaSE核心知识点02面向对象编程02-07（枚举）

以下是关于Java泛型的详细讲解，从基础概念到实际应用逐步展开：

一、泛型存在的意义

1.1 类型安全

// 泛型出现前的集合使用（JDK1.5之前）
List list = new ArrayList();
list.add("Hello");
list.add(100); // 编译通过，运行时可能抛出ClassCastExceptionString str = (String) list.get(1); // 运行时报错：Integer无法转String

1.2 代码复用
通过泛型实现通用容器：

// 泛型类定义
public class Box<T> {private T content;public void set(T content) { this.content = content; }public T get() { return content; }
}// 使用时指定具体类型
Box<String> stringBox = new Box<>();
Box<Integer> intBox = new Box<>();

二、泛型核心语法

2.1 泛型类

// 多类型参数示例
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);

2.2 泛型方法

// 独立于类的泛型方法
public class Utils {public static <T> void printArray(T[] array) {for (T element : array) {System.out.print(element + " ");}System.out.println();}
}// 调用示例
Integer[] intArr = {1, 2, 3};
Utils.<Integer>printArray(intArr); // 显式指定类型
Utils.printArray(new String[]{"A", "B"}); // 自动类型推断

2.3 泛型接口

// 泛型接口定义
public interface Generator<T> {T generate();
}// 实现类指定具体类型
class StringGenerator implements Generator<String> {@Overridepublic String generate() {return UUID.randomUUID().toString();}
}

三、类型通配符

3.1 上界通配符（<? extends T>）

// 接收Number及其子类集合
public static double sum(List<? extends Number> list) {double sum = 0;for (Number num : list) {sum += num.doubleValue();}return sum;
}// 可以传入List<Integer>或List<Double>
List<Integer> ints = Arrays.asList(1,2,3);
System.out.println(sum(ints)); // 输出6.0

3.2 下界通配符（<? super T>）

// 向集合中添加元素
public static void addNumbers(List<? super Integer> list) {for (int i = 1; i <= 5; i++) {list.add(i);}
}List<Number> numbers = new ArrayList<>();
addNumbers(numbers); // 合法操作

3.3 无界通配符（<?>）

// 仅需遍历集合元素时不关心类型
public static void printList(List<?> list) {for (Object elem : list) {System.out.print(elem + " ");}System.out.println();
}

四、类型擦除与限制

4.1 类型擦除原理
编译后泛型类型会被擦除为原始类型：

// 编译前
List<String> list = new ArrayList<>();// 编译后（字节码层面）
List list = new ArrayList();

4.2 泛型限制

无法实例化类型参数

public class Box<T> {// 错误写法private T instance = new T(); // 正确方式通过反射（需谨慎）public T createInstance(Class<T> clazz) throws Exception {return clazz.newInstance();}
}

无法使用基本类型

// List<int> list; // 编译错误
List<Integer> list; // 正确

静态成员不能使用类型参数

public class Box<T> {// static T staticField; // 错误
}

五、泛型高级应用

5.1 泛型与反射

public class GenericFactory<T> {private Class<T> type;public GenericFactory(Class<T> type) {this.type = type;}public T createInstance() throws Exception {return type.getDeclaredConstructor().newInstance();}
}// 使用示例
GenericFactory<StringBuilder> factory = new GenericFactory<>(StringBuilder.class);
StringBuilder sb = factory.createInstance();

5.2 泛型数组

// 正确创建泛型数组的方式
public class ArrayMaker<T> {private Class<T> kind;public ArrayMaker(Class<T> kind) {this.kind = kind;}@SuppressWarnings("unchecked")T[] create(int size) {return (T[]) Array.newInstance(kind, size);}
}// 使用示例
ArrayMaker<String> maker = new ArrayMaker<>(String.class);
String[] strArray = maker.create(10);

六、最佳实践与常见错误

6.1 PECS原则（Producer Extends, Consumer Super）

// 正确使用示例
public static <T> void copy(List<? super T> dest, List<? extends T> src) {for (T item : src) {dest.add(item);}
}List<Number> dest = new ArrayList<>();
List<Integer> src = Arrays.asList(1,2,3);
copy(dest, src); // 正确执行

6.2 常见错误示例

// 错误1：类型不匹配
List<String> list = new ArrayList<Object>(); // 编译错误// 错误2：原始类型警告
List rawList = new ArrayList<String>(); // 编译警告
rawList.add(100); // 运行时可能出错

七、学习建议

实践路线：
- 从集合框架（如ArrayList）开始体验泛型
- 尝试自定义泛型类（如实现一个通用缓存类）
- 研究JDK源码中的泛型应用（如Comparable接口）
调试技巧：
- 使用javac -Xlint:unchecked查看未检查警告
- 在IDE中观察类型擦除后的字节码
延伸学习：
- 泛型与设计模式（如工厂模式、策略模式）
- Java8后的改进（如泛型类型推断增强）
- Kotlin/Scala等JVM语言的泛型特性对比