Java泛型

概念与基础

泛型是Java 5引入的重要特性，它从根本上改变了Java的类型系统。泛型允许在定义类、接口和方法时使用类型参数(Type Parameter)，这种机制使得代码更加类型安全且可重用。泛型的本质是参数化类型(Parameterized Type)，即在定义时不指定具体的类型，而是在使用时才指定具体的类型参数。

泛型的主要优势包括：

1. 类型安全：在编译时就能发现类型不匹配的错误
2. 消除强制类型转换：使代码更加简洁易读
3. 提高代码复用性：同一套逻辑可以适用于多种类型

例如，在使用集合框架时：

// 非泛型方式
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);  // 需要显式类型转换

// 泛型方式
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);  // 自动类型推断，无需强制转换

泛型可以应用于多种场景：

• 泛型类：如集合框架中的ArrayList<E>
• 泛型接口：如Comparable<T>
• 泛型方法：可以定义在普通类中

Java泛型的实现采用类型擦除(Type Erasure)机制，这是为了保持与旧版本Java的兼容性。虽然运行时类型信息会被擦除，但编译器仍然会进行严格的类型检查。

基本语法示例：

// 泛型类
public class Box<T> {
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

// 泛型方法
public <T> T genericMethod(T t) {
    return t;
}

泛型通配符

1. 无界通配符：<?> 表示未知类型
2. 上界通配符：<? extends Number> 表示Number或其子类
3. 下界通配符：<? super Integer> 表示Integer或其父类

类型擦除

Java泛型是通过类型擦除实现的，在编译时会将泛型类型参数擦除，替换为它们的边界类型（无界则替换为Object）。

示例：

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
// 运行时，两者类型都是List

泛型应用场景

1. 集合框架中的类型安全

泛型在集合框架中最典型的应用就是提供编译期的类型安全检查。例如，在使用ArrayList时，可以指定存储的元素类型：

// 非泛型写法，可能引发运行时异常
List list = new ArrayList();
list.add("字符串");
list.add(123); // 编译通过，但可能导致后续处理时出现ClassCastException

// 泛型写法
List<String> stringList = new ArrayList<>();
stringList.add("字符串");
// stringList.add(123); // 编译时报错，直接阻止错误类型元素的添加

2. 创建可重用的通用组件

泛型允许我们编写可适用于多种类型的通用代码。以下是一个简单的泛型类示例：

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(123);

3. 避免类型转换

泛型可以消除许多显式的类型转换，提高代码可读性和安全性：

// 不使用泛型
List list = new ArrayList();
list.add("Test");
String str = (String) list.get(0); // 需要显式类型转换

// 使用泛型
List<String> genericList = new ArrayList<>();
genericList.add("Test");
String str = genericList.get(0); // 无需类型转换

4. 实现通用算法

泛型特别适合用于实现与具体类型无关的算法。例如，一个通用的比较方法：

public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

// 可以用于多种可比较类型
Integer maxInt = max(10, 20);
String maxStr = max("apple", "orange");

这种通用算法可以处理任何实现了Comparable接口的类型，而无需为每种类型都编写特定的实现。

Java反射

反射基础

反射是Java提供的在运行时检查和修改类、方法、字段等的能力，通过java.lang.reflect包实现。

核心类：

• Class类：代表类和接口
• Field类：代表成员变量
• Method类：代表方法
• Constructor类：代表构造方法

基本用法：

// 获取Class对象
Class<?> clazz = Class.forName("java.lang.String");

// 创建实例
Object obj = clazz.newInstance();

// 获取方法并调用
Method method = clazz.getMethod("length");
int length = (int) method.invoke("Hello");

反射应用场景

1. 动态加载类
2. 框架开发（如Spring的IoC容器）
3. 测试工具
4. 动态代理

性能考虑： 反射操作比直接调用慢，应该避免在性能关键的代码中过度使用。

Java注解

注解基础

注解（Annotation）是Java 5引入的元数据机制，用于为代码提供附加信息。

内置注解：

• @Override
• @Deprecated
• @SuppressWarnings
• @SafeVarargs
• @FunctionalInterface

自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value() default "";
    int count() default 1;
}

元注解：

• @Target：指定注解可用范围
• @Retention：指定注解保留策略
• @Documented：文档化
• @Inherited：允许子类继承

注解处理

1. 编译时处理：通过注解处理器（APT）
2. 运行时处理：通过反射API

运行时处理示例：

Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
    if (method.isAnnotationPresent(MyAnnotation.class)) {
        MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
        System.out.println(annotation.value());
    }
}

综合应用

泛型+反射+注解的实际应用

1. ORM框架：通过注解定义实体类与表的映射关系，利用反射获取类信息，使用泛型实现通用DAO
2. 依赖注入：通过注解标记需要注入的字段，使用反射实现依赖注入
3. 序列化/反序列化：通过注解配置序列化行为，使用泛型处理不同类型

示例代码：

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface JsonField {
    String value() default "";
}

// 使用反射处理注解
public class JsonSerializer {
    public static String serialize(Object object) throws IllegalAccessException {
        Class<?> clazz = object.getClass();
        StringBuilder json = new StringBuilder("{");
        
        Field[] fields = clazz.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            fields[i].setAccessible(true);
            if (fields[i].isAnnotationPresent(JsonField.class)) {
                JsonField annotation = fields[i].getAnnotation(JsonField.class);
                String fieldName = annotation.value().isEmpty() ? 
                    fields[i].getName() : annotation.value();
                json.append("\"").append(fieldName).append("\":")
                    .append("\"").append(fields[i].get(object)).append("\"");
                if (i < fields.length - 1) {
                    json.append(",");
                }
            }
        }
        json.append("}");
        return json.toString();
    }
}

最佳实践

泛型：

1. 优先使用泛型集合而非原始类型

   • 示例：使用List<String>而非原始List，可以获得编译时类型检查
   • 好处：提高代码安全性，减少运行时类型转换错误
   • 典型应用场景：集合框架中的各种容器类

2. 避免在静态上下文中使用泛型类型参数

   • 原因：静态成员属于类而非实例，无法访问实例的类型参数
   • 替代方案：使用具体的类型或通配符
   • 错误示例：public static <T> void method(T t) {...}（静态方法中的泛型）

3. 注意类型擦除带来的限制

   • 运行时限制：无法获取泛型的实际类型参数
   • 解决方案：使用Class<T>参数传递类型信息
   • 常见问题：instanceof检查无法用于泛型类型

反射：

1. 缓存反射结果以提高性能

   • 实现方式：使用静态Map缓存Method/Field等对象
   • 性能对比：直接调用 vs 反射调用可能有100倍性能差异
   • 示例：Spring框架中的反射缓存机制

2. 使用setAccessible(true)时需要谨慎

   • 安全影响：破坏了封装性，可能绕过访问控制
   • 合法用途：测试框架、序列化库等特殊场景
   • 最佳实践：尽量通过正规API访问而非强行突破访问限制

3. 考虑安全性影响

   • 风险点：反射可能被用于绕过安全检查
   • 防护措施：使用SecurityManager进行控制
   • 典型案例：某些框架会限制反射操作

注解：

1. 为注解定义明确的保留策略和目标

   • 保留策略：SOURCE（仅源码）、CLASS（类文件）、RUNTIME（运行时）
   • 目标范围：TYPE、METHOD、FIELD等
   • 示例：@Retention(RetentionPolicy.RUNTIME)

2. 避免过度使用注解

   • 问题：过多的注解会使代码难以阅读
   • 平衡点：在需要元数据的场景下合理使用
   • 反面示例：一个方法上标注5个以上的注解

3. 考虑注解处理器的编译时检查

   • 优势：可以在编译期发现问题
   • 实现方式：实现AbstractProcessor
   • 应用场景：Lombok、MapStruct等工具的核心机制