如何通过Java泛型提升代码安全性？分享实用泛型编程技巧！

本文共计2873个文字，预计阅读时间需要12分钟。

在Java中，泛型为你的代码提供了额外的类型安全层，就像给你的代码穿上了一层保护甲。它可以帮助你提前发现类型错误，避免运行时出现ClassCastException，还能提高代码的重用性，让你的代码更加优雅。

类型擦除是Java泛型的一个特点，虽然编译时有类型检查，但运行时类型信息会被移除，这既是限制，也是一种实现策略。

泛型这玩意儿，用好了能让你的代码安全又高效。

什么是泛型擦除，它对泛型有什么影响？

泛型擦除，简单来说，就是Java编译器在编译时会将泛型类型信息移除，替换为原始类型（Raw Type）。比如，

List<String> 在运行时会变成

List。这主要是为了兼容JDK 1.5之前的版本，因为之前的版本没有泛型。

立即学习“Java免费学习笔记（深入）”；

影响嘛，主要有这么几个：

• 运行时无法获取泛型类型信息： 这意味着你不能通过反射来获取

  List<String>的实际类型

  String。

• 类型检查仅在编译时进行： 运行时不再进行类型检查，所以可能会出现类型转换异常，但这种情况通常是由于使用了不当的类型转换或者绕过了编译器的类型检查。
• 不能创建泛型数组： 你不能直接创建

  new List<String>[10] 这样的数组，因为运行时类型信息丢失，JVM无法确定数组元素的类型。

不过，Java也提供了一些方法来“曲线救国”，比如使用类型令牌（Type Token）或者反射结合泛型方法签名来获取泛型类型信息，但这通常比较复杂，而且有一定的性能开销。

如何使用泛型限定来约束类型？

泛型限定，就是用

extends 和

super 关键字来限制泛型类型参数的范围。这就像给你的泛型类型参数加上了“血统”认证，只有符合条件的类型才能被接受。

• extends 关键字： 用于限定上界，表示泛型类型参数必须是指定类或接口的子类或实现类。例如：

  public <T extends Number> T add(T a, T b) { return a.doubleValue() + b.doubleValue(); // Number类的方法 }

  这个例子中，

  T 必须是

  Number 类或其子类，比如

  Integer、

  Double 等。这样，你就可以安全地调用

  Number 类的方法，而不用担心类型转换异常。

• super 关键字： 用于限定下界，表示泛型类型参数必须是指定类或接口的父类或超接口。例如：

  public static <T> void addNumbers(List<? super Integer> list) { for (int i = 1; i <= 10; i++) { list.add(i); } }

  这个例子中，

  List 必须是

  Integer 或其父类的

  List，比如

  List<Number> 或

  List<Object>。这样，你可以安全地向

  List 中添加

  Integer 类型的元素。

使用泛型限定可以提高代码的类型安全性，减少运行时错误，并增加代码的灵活性。

泛型方法和泛型类有什么区别？

泛型方法和泛型类，虽然都用到了泛型，但它们的应用场景和作用范围有所不同。

• 泛型类： 在类声明时指定泛型类型参数。这意味着整个类中的所有方法都可以使用这个泛型类型参数。例如：

  public class Box<T> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } }

  在这个例子中，

  Box 类是一个泛型类，

  T 是泛型类型参数。你可以创建

  Box<Integer>、

  Box<String> 等不同类型的

  Box 对象。

• 泛型方法： 在方法声明时指定泛型类型参数。这意味着只有这个方法可以使用这个泛型类型参数，而类本身不一定是泛型类。例如：

  public class Util { public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); } }

  在这个例子中，

  compare 方法是一个泛型方法，

  K 和

  V 是泛型类型参数。这个方法可以比较任何类型的

  Pair 对象。

区别总结：

• 作用范围： 泛型类的泛型类型参数作用于整个类，而泛型方法的泛型类型参数只作用于该方法。
• 声明位置： 泛型类的泛型类型参数在类声明时指定，而泛型方法的泛型类型参数在方法声明时指定。
• 使用场景： 如果泛型类型参数需要在类的多个方法中使用，则应该使用泛型类。如果泛型类型参数只需要在某个方法中使用，则应该使用泛型方法。

选择使用泛型类还是泛型方法，取决于你的具体需求。

泛型中的通配符

? 有什么作用？

? extends T 和

? super T 的区别是什么？

通配符

? 在泛型中扮演着“未知类型”的角色，它允许你在不知道具体类型的情况下使用泛型。这就像一个占位符，表示可以是任何类型。

• ? 的作用： 主要用于以下场景：

  • 只读操作： 当你只需要从泛型集合中读取数据，而不需要写入数据时，可以使用

    ?。例如：

    public static void printList(List<?> list) { for (Object obj : list) { System.out.println(obj); } }

    这个例子中，

    printList 方法可以接收任何类型的

    List，因为它只需要读取数据。

  • 作为方法参数： 当你只想传递一个泛型集合，而不需要关心它的具体类型时，可以使用

    ?。例如：

    public static void processList(List<?> list) { // ... }

    这个例子中，

    processList 方法可以接收任何类型的

    List，因为它只需要处理数据，而不需要知道数据的具体类型。

• ? extends T 和

  ? super T 的区别： 这两个通配符用于限定通配符的范围。

  • ? extends T： 表示类型是

    T 或

    T 的子类。这限制了类型的上界，允许你读取

    T 类型的数据，但不能写入数据，因为你不知道具体的子类型。例如：

    public static void processList(List<? extends Number> list) { // 可以读取 Number 类型的数据 Number num = list.get(0); // 不能写入数据，因为不知道具体的子类型 // list.add(1); // 编译错误 }

  • ? super T： 表示类型是

    T 或

    T 的父类。这限制了类型的下界，允许你写入

    T 类型的数据，但读取的数据只能是

    Object 类型，因为你不知道具体的父类型。例如：

    public static void addNumbers(List<? super Integer> list) { // 可以写入 Integer 类型的数据 list.add(1); // 读取的数据只能是 Object 类型 Object obj = list.get(0); }

总结：

• ? extends T 适用于只读操作，可以读取

  T 类型的数据。

• ? super T 适用于只写操作，可以写入

  T 类型的数据。

选择使用哪个通配符，取决于你的具体需求。

如何避免泛型类型擦除带来的问题？

泛型类型擦除是Java泛型的一个特点，虽然它带来了兼容性，但也带来了一些问题，比如运行时无法获取泛型类型信息。要避免这些问题，可以采取以下策略：

1. 使用类型令牌（Type Token）： 类型令牌是一种在运行时保留泛型类型信息的技术。你可以创建一个类，将泛型类型作为参数传递给它，然后在运行时通过反射获取这个类型。例如：

   public class TypeToken<T> { private final Class<T> type; public TypeToken() { Type superclass = getClass().getGenericSuperclass(); type = (Class<T>) ((ParameterizedType) superclass).getActualTypeArguments()[0]; } public Class<T> getType() { return type; } } // 使用示例 TypeToken<String> token = new TypeToken<String>() {}; Class<String> type = token.getType(); // 获取 String.class

   这种方法比较复杂，但可以在运行时获取泛型类型信息。

2. 使用反射结合泛型方法签名： 你可以通过反射获取泛型方法的签名，然后解析签名中的泛型类型信息。例如：

   public static <T> Class<?> getGenericType(Method method, int index) { Type[] genericParameterTypes = method.getGenericParameterTypes(); if (genericParameterTypes.length > index && genericParameterTypes[index] instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) genericParameterTypes[index]; Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); if (actualTypeArguments.length > 0 && actualTypeArguments[0] instanceof Class) { return (Class<?>) actualTypeArguments[0]; } } return null; } // 使用示例 Method method = MyClass.class.getMethod("myMethod", List.class); Class<?> genericType = getGenericType(method, 0); // 获取 List<String> 中的 String.class

   这种方法也比较复杂，但可以在运行时获取泛型方法的泛型类型信息。

3. 避免不必要的类型转换： 尽量避免在代码中使用强制类型转换，因为这可能会导致运行时出现

   ClassCastException。如果必须进行类型转换，可以使用

   instanceof 关键字进行类型检查。

4. 使用泛型集合的正确类型： 在使用泛型集合时，一定要指定正确的类型参数，避免使用原始类型（Raw Type）。例如，应该使用

   List<String> 而不是

   List。

5. 注意泛型数组的创建： 由于类型擦除，不能直接创建泛型数组，例如

   new List<String>[10] 是不允许的。可以使用

   List<List<String>> 或

   Object[] 来代替。

通过以上策略，可以最大限度地避免泛型类型擦除带来的问题，提高代码的类型安全性。