一、泛型通配符：灵活与安全的平衡术

在Java动物收容所系统中，我们常需要处理不同动物类型的集合。通过泛型通配符，可以构建更灵活的API：

class Shelter<T extends Animal> {private List<T> animals = new ArrayList<>();// 上界通配符实现安全读取public void processAnimals(Consumer<? super T> processor) {animals.forEach(processor::accept);}// 下界通配符实现安全写入public void addAnimals(List<? extends T> newAnimals) {animals.addAll(newAnimals);}
}

关键点解析：

<? super T>允许传入T及其父类的Consumer，实现类型安全的写入操作
<? extends T>确保读取时获得T及其子类的实例
结合PECS原则（Producer Extends, Consumer Super）设计API

二、类型擦除现象：编译期的魔法与限制

通过反射演示类型擦除的底层机制：

public class TypeErasureDemo {public static void main(String[] args) throws Exception {List<String> stringList = new ArrayList<>();List<Integer> intList = new ArrayList<>();// 运行时类型信息丢失System.out.println(stringList.getClass() == intList.getClass()); // true// 通过TypeToken获取泛型类型Class<List<String>> stringListClass = new TypeToken<List<String>>(){}.getType();System.out.println(stringListClass); // java.util.List<java.lang.String>}
}

应对策略：

使用TypeToken保留泛型信息
避免在运行时依赖具体泛型类型
通过工厂模式封装泛型实例化

三、实战：自定义响应式API框架

设计一个迷你版响应式流处理框架，展示泛型在异步编程中的应用：

public interface Observable<T> {void subscribe(Observer<T> observer);
}public interface Observer<T> {void onNext(T item);void onError(Throwable error);void onComplete();
}// 泛型工厂实现类型安全的创建
class Observables {public static <T> Observable<T> create(Supplier<T> supplier) {return observer -> {try {T value = supplier.get();observer.onNext(value);observer.onComplete();} catch (Exception e) {observer.onError(e);}};}
}// 使用示例
public class Demo {public static void main(String[] args) {Observable<String> observable = Observables.create(() -> "Hello Reactive");observable.subscribe(new Observer<String>() {@Overridepublic void onNext(String item) {System.out.println("Received: " + item);}@Overridepublic void onError(Throwable error) {System.err.println("Error: " + error.getMessage());}@Overridepublic void onComplete() {System.out.println("Stream completed");}});}
}

四、泛型设计最佳实践

接口优先原则：

// 定义通用仓库接口
public interface Repository<T, ID> {T findById(ID id);List<T> findAll();void save(T entity);
}

异常处理策略：

public class RepositoryException extends RuntimeException {public <T> RepositoryException(Class<T> entityClass, String message) {super(String.format("Operation failed for %s: %s", entityClass.getSimpleName(), message));}
}

文档规范：

/*** 响应式数据流处理器* @param <T> 流元素类型* @apiNote 支持背压控制的观察者模式实现* @see Observer*/
public interface FlowProcessor<T> {/*** 处理传入的数据流* @param stream 输入流，支持延迟加载* @return 处理后的结果流* @throws ProcessingException 当处理失败时抛出*/Flowable<T> process(Publisher<T> stream) throws ProcessingException;
}

五、类型擦除的深层影响与解决方案

当需要创建泛型数组时的解决方案：

public class GenericArray<T> {private final T[] array;@SuppressWarnings("unchecked")public GenericArray(int size) {// 通过反射绕过类型擦除限制array = (T[]) Array.newInstance(// 获取类型参数的实际类对象(Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0],size);}
}

六、性能优化技巧

在处理泛型集合时的性能对比：

// 原始类型操作
public long processRaw(List list) {long start = System.nanoTime();for (Object o : list) {// 类型检查开销if (o instanceof String) {String s = (String) o;// 业务逻辑}}return System.nanoTime() - start;
}// 泛型类型操作
public <T> long processGeneric(List<T> list, Class<T> clazz) {long start = System.nanoTime();for (T t : list) {// 消除类型检查// 业务逻辑}return System.nanoTime() - start;
}