Java | 泛型实现机制

前言

泛型的本质是参数化类型，就是将原来的具体的类型参数化。在不确定需要类型的情况下，通过泛型来指定具体的限制

Java 的实现机制就是类型擦除，在编译的时候被擦除为 Obect

类型擦除有哪些好处

首先是运行时内存负担小，经过了类型擦除后，在运行期间，内存里面是不会有泛型的，只会有一个 List，所以减少了内存负担。对比下面的 C# ，在运行时泛型是真实存在的。

还有就是兼容性好了，

类型擦除有哪些问题

• 基本类型无法作为泛型的实参

  所有就有了装箱和拆箱的类型，这就涉及到了装箱和拆箱的内存开销。但是在 C# 中基本数据类型是可以的

• 泛型类型无法用作方法重载

  public void printList(List<Integer> list)
  public void printList(List<String> list)
  

  上面这种写法就是错误的，因为在编译后泛型被擦除后这两个方法就没有任何区别了，这种写法是不行的。

• 泛型类型无法当做真实的类型使用

  public <T> void genericMethod(T t){
  	T newInstance = new T(); //Error
  	Class c = T.class;    //Error
      Class c = T.class;    //Error
      List<T> list = new ArrayList<T>(); //Ok，用于其他的泛型类型可以
      if(list instanceof List<String>) //Error，非法的类型判断，因为 List<String> 不是一个真实的类型，真实的类型就是 List
  	....
  }
  

  上面的 T 在编译完之后就会变成一个 Object，但是方法中想要创建的实际上是 T ，并不是 Object，所以 java 中不能这样写。

• Gson.fromJson 为什么要传入 T

  public <T> T fromJson(Reader json, Class<T> classOfT) throws JsonSyntaxException, JsonIOException {
    JsonReader jsonReader = newJsonReader(json);
    Object object = fromJson(jsonReader, classOfT);
    assertFullConsumption(object, jsonReader);
    return Primitives.wrap(classOfT).cast(object);
  }
  

  实际上，编译过来这个方法返回的是一个 Object，如果不传入 T，就不知道传进来的类型是什么，也不知道拿到的是一个什么样的对象。

• 静态方法无法引用类泛型参数

  class Demo<T>{
  	public static T test(T t){}
  }
  

  这种写法是错误的，因为泛型是在创建实例的时候才能确定，而静态方法在一开始就创建好了，并不需要有类的实例

• 类型强转的运行时开销

  List<String> strs = new ArrayList();
  strs.add("hello");
  String value = strs.get(0);
  

  如果成字节码上来看，从 list 中获取到元素之后会进行类型强转，这也会带来开销。

• 类型擦除对反射的影响

  泛型擦除后就会导致在反射的时候有些信息获取不到，但是 java 提供了附加的签名信息。

  附加的签名信息，如果实现了一个带泛型的类，并且确定的泛型的类型。那么编译的时候就会为 这个类附加一个签名信息。这个签名信息里面就会携带这个泛型的具体类型。

  这个附加信息一般是没有什么用的，但是在反射的时候就可以通过这个附加信息获取的具体的泛型类型。

  class Test<T> {
  
      public static void main(String[] args) {
          try {
              //凡是看到 Generic..Type 都是获取的泛型类型，例如 getGenericReturnType 就是获取返回泛型类型
              Type type = Test2.class.getField("list").getGenericType();
              System.out.println(type);
          } catch (NoSuchFieldException e) {
              e.printStackTrace();
          }
      }
  }
  
  class Test2 extends Test<String> {
      public List<String> list = new ArrayList<>();
  }
  

  

  使用泛型签名的两个实例：

  • Gson

    Type collectionType = new TypeToken<Collection<Integer>>(){}.getType();
    Collection<Ingeger> ints = gson.fromJson(json,collectionType);
    

    TypeToken 本身是 protected 的，不能直接 new 出来，但是可以创建他的匿名内部类，这个内部类就是TtypeToken的子类，子类可以访问父类的构造方法。创建出对象以后泛型的实参也就有了，然后通过 getType 获取具体的 type 类型。getType 里面调用的就是 getGenericSuperclass 获取超类的泛型 Type。

    Type type = new TypeToken<Collection<Integer>>() {
    }.getType();
    System.out.println(type);
    

    打印结果如下：

    java.util.Collection<java.lang.Integer>

  • Retrofit

    interface Api{
        @GET("users/${name}")
    	Call<User> getUser(@Path("user")String name)
    }
    

    对于这个方法，其实在运行的时候泛型擦除，返回值类型应该是个 Call。

    这里其实也是通过实现类的反射拿到了返回值的泛型，也就是 getGenericReturnType。

Kotlin 反射的实现原理

Kotlin 的每一个类在编译后都会有一个注解，叫做 Metadata，这个注解里面就会有这个类的名称，方法名称，签名等信息

总结

• Java 的泛型通过类型擦除来实现
• 类型编译时被擦除为 Object，不兼容基本类型
• 类型擦除的实现方案主要考虑的是向后兼容
• 泛型类型签名信息在特定场合下可通过反射获取

参考

bennyhuo 视频

这篇好文章是转载于：学新通技术网