死磕Java泛型(一篇就够)

浪人 等级 991 0 0

Java泛型,算是一个比较容易产生误解的知识点,因为Java的泛型基于擦除实现,在使用Java泛型时,往往会受到泛型实现机制的限制,如果不能深入全面的掌握泛型知识,就不能较好的驾驭使用泛型,同时在阅读开源项目时也会处处碰壁,这一篇就带大家全面深入的死磕Java泛型。

泛型擦除初探

相信泛型大家都使用过,所以一些基础的知识点就不废话了,以免显得啰嗦。
先看下面的一小段代码

public class FruitKata {
    class Fruit {}
    class Apple extends generic.Fruit {}

    public void eat(List fruitList) {}

    public void eat(List<Fruit> fruitList) { }   // error, both methods has the same erasure
} 

我们在FruitKata类中定义了二个eat的方法,参数分别是List和List类型,这时候编译器报错了,并且很智能的给出了“ both methods has the same erasure” 这个错误提示。显然,编译器在抱怨,这二个方法具有同样的签名,嗯~~,这就是泛型擦除存在的一个证据,要进一步验证也很简单。我们通过ByteCode Outline这个插件,可以很方便的查看类被编译后的字节码,这里我们只贴出eat方法的字节码。

 // access flags 0x1
  // signature (Ljava/util/List<Lgeneric/FruitKata$Fruit;>;)V
  // declaration: void eat(java.util.List<generic.FruitKata$Fruit>)
  public eat(Ljava/util/List;)V 

可以看到参数确实已经被擦除为List类型,这里要明确一点是,这里擦除的只是方法内部的泛型信息,而泛型的元信息还是保存在类的class字节码文件中,相信细心的同学已经发现了上面我特意将方法的注释一并贴了出来

 // signature (Ljava/util/List<Lgeneric/FruitKata$Fruit;>;)V 

这个signature字段大有玄机,后面会详细说明。 这里只是以泛型方法来做个说明,其实泛型类,泛型返回值都是类似的,兄弟们可以自己动手试试看。

为什么用擦除来实现泛型

要回答这个问题,需要知道泛型的历史,Java的泛型是在Jdk 1.5 引入的,在此之前Jdk中的容器类等都是用Object来保证框架的灵活性,然后在读取时强转。但是这样做有个很大的问题,那就是类型不安全,编译器不能帮我们提前发现类型转换错误,会将这个风险带到运行时。
引入泛型,也就是为解决类型不安全的问题,但是由于当时java已经被广泛使用,保证版本的向前兼容是必须的,所以为了兼容老版本jdk,泛型的设计者选择了基于擦除的实现。

由于Java的泛型擦除,在运行时,只有一个List类,那么相对于C#的基于膨胀的泛型实现,Java类的数量相对较少,方法区占用的内存就会小一点,也算是一个额外的小优点吧。

泛型擦除带来的问题

由于泛型擦除,下面这些代码都不能编译通过

T t = new T();
T[] arr = new T[10];
List<T> list = new ArrayList<T>();
T instanceof Object 

通配符

作为泛型擦除的补偿,Java引入了通配符

List<? extends Fruit> fruitList;
List<? super Apple> appleList; 

这二个通配符很多同学都存在误解。

? extends

?extends Fruit 表示Fruit是这个传入的泛型的基类(Fruit是泛型的上界),还是以上面的Fruit和Apple为例,看下面这段代码

List<? extends Fruit> fruitList = new ArrayList<>();
fruitList.add(new Fruit());  //error 

按照我们上面对? extends的理解,fruitList应该是可以添加一个Fruit的,但是编译器却给我们报错了。我第一次看到这里时也感觉不太好理解,我们来看个例子就能理解了。

List<? extends Fruit>  fruitList = new ArrayList<>();
List<Apple> appleList = new ArrayList<>();
fruitList = appleList;
fruitList.add(new Fruit());   //error 

如果fruitList允许添加Fruit,我们就将Fruit添加到了AppleList中了,这肯定是不能接受的。

? super

再来看个?super的例子

List<? super Apple> superAppleList = new ArrayList<>();
superAppleList.add(new Apple());
superAppleList.add(new Fruit());  // error 

向superAppleList中添加Apple是可以的,添加Fruit还是会报错,好,上面我们说的这些就是 PECS 原则。

PECS

英文全称,Producer Extends Consumer Super,

  1. 如果需要一个只读的泛型集合,使用?extends T
  2. 如果需要一个只写的泛型集合,使用?super T

我自己是这样来理解通配符的

  1. 因为? extends T给外界的承诺语义是,这个集合内的元素都是T的子类型,但是到底是哪个子类型不知道,所以添加哪个子类型,编译器都认为是危险的,所以直接禁止添加。
  2. 因为? super T 给外界的承诺语义是,这个集合内的元素的下界是T,所以向集合中添加T以及T的子类型是安全的,不会破坏这个承诺语义。
  3. List, List 都是List<? super Apple>的子类型。
    List 是List<? extends Apple>的子类型。

关于泛型的使用,Jdk中有很多经典的应用范例,比如Collections的copy方法

 public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    } 

泛型擦除了,我们还能拿到泛型信息吗

前面我们提到过class字节码中会有个signature字段来保存泛型信息。我们新建一个泛型方法

 public <T extends Apple> T plant(T fruit) {
        return fruit;
    } 

查看class文件的二进制信息,发现里面确实有Signature字段信息。

Signature�%<T:Lgeneric/FruitKata$Apple;>(TT;)TT; 

既然泛型信息还是在class文件中,那我们有没有办法在运行时拿到呢?
办法肯定是有的。
来看一个例子

 Class clazz = HashMap<String, Apple>(){}.getClass();
  Type superType = clazz.getGenericSuperclass();
  if (superType instanceof ParameterizedType) {
  ParameterizedType parameterizedType = (ParameterizedType) superType;
  Type[] actualTypes = parameterizedType.getActualTypeArguments();
   for (Type type : actualTypes) {
            System.out.println(type);
       }
   }

// 打印结果
class java.lang.String
class generic.FruitKata$Apple 

可以看到我们拿到并打印了泛型的原始类型信息。为了加深对泛型使用的理解,我接下来再看几个小例子。

泛型在Gson解析中的使用
String jsonString = ".....";  // 这里省略json字符串
Apple apple = new Gson().fromJson(jsonString, Apple.class); 

这是一段很简单的Gson解析使用代码,我们进一步去看它fromJson的方法实现

 public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {
    Object object = fromJson(json, (Type) classOfT);
    return Primitives.wrap(classOfT).cast(object);
  } 

最终会执行到

 TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
  TypeAdapter<T> typeAdapter = getAdapter(typeToken);
  T object = typeAdapter.read(reader); 

通过我们传入的Class类型构造TypeToken,然后通过TypeAdapter将json字符串转化为对象T,中间的细节这里就不继续深入了。

泛型在retrofit中的使用

我们在使用retrofit时,一般都会定义一个或多个ApiService接口类

@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user); 

接口方法的返回值都使用了泛型,所以注定在编译期是要被擦除的,那retrofit是如何得到原始泛型信息的呢。其实有上面的泛型知识以及Gson的使用说明,相信大家以及有答案了。
retrofit框架本身设计的很优雅,细节这里我们不深入展开,这里我们只关心泛型数据转换为返回值的过程。
我们需要定义如下几个类

// ApiService.class
public interface ApiService {
    Observable<List<Apple>> getAppleList();
}

// Apple.class
class Apple extends Fruit {
    private int color;
    private String name;
    public Apple() {}

    public Apple(int color, String name) {
        this.color = color;
        this.name = name;
    }

    @Override
    public String toString() {
        return "color:" + this.color + "; name:" + name;
    }
} 

接下来,我定义一个动态代理,

InvocationHandler handler = new InvocationHandler() {
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Type returnType = method.getGenericReturnType();
            if (returnType instanceof ParameterizedType) {
               ParameterizedType parameterizedType = (ParameterizedType) returnType;
               Type[] types = parameterizedType.getActualTypeArguments();
               if (types.length > 0) {
                   Type type = types[0];
                   Object object = new Gson().fromJson(mockAppleJsonString(), type);
                   return Observable.just(object);
             }
           }
          return null;
     }
  };

// mock json数据
public static String mockAppleJsonString() {
   List<Apple> apples = new ArrayList<>();
   apples.add(new Apple(1, "红富士"));
   apples.add(new Apple(2, "青苹果"));
   return new Gson().toJson(apples);
} 

接下来就是正常的调用了,这里模拟了retrofit数据转换的过程。

ApiService apiService = (ApiService) Proxy.newProxyInstance(ProxyKata.class.getClassLoader(),
                new Class[] {ApiService.class}, handler);

Observable<List<Apple>> call = apiService.getAppleList();
if (call != null) {
      call.subscribe(apples -> {
           if (apples != null) {
              for (Apple apple : apples) {
                 System.out.println(apple);
              }
         }
     });
}

// 输出结果
color:1; name:红富士
color:2; name:青苹果 
泛型在MVP中的应用

MVP模式相信做Android开发的没人不知道,假设我们有这样几个类

public class BaseActivity<V extends IView, P extends IPresenter<V>> extends AppCompatActivity {
   protected P mPresenter;
  //....
}
public class MainActivity extends BaseActivity<MainView, MainPresenter> implements MainView {
  //....
} 

由于泛型擦除的关系,我们不能在BaseActivity中直接新建Presenter来初始化mPresenter,所以一般通常的做法是暴露一个createPresenter方法让子类重写。但是今天我们介绍另外一种方法,直接看代码

// BaseActivity.class
        Type superType = getClass().getGenericSuperclass();
        if (superType instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) superType;
            Type[] types = parameterizedType.getActualTypeArguments();
            for (Type type : types) {
                if (type instanceof Class) {
                    Class clazz = (Class) type;
                    try {
                        mPresenter = (P) clazz.newInstance();
                        mPresenter.bindView((V) this);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    }
                }
            }
        } 

我们通过在BaseActivity中是能够拿到泛型的原始信息的,通过反射初始化出来mPresenter,并调用bindView来绑定我们的视图接口。通过这种方式,我们利用泛型的能力,基类包办了所有的初始化任务,不但逻辑简单,而且也体现了高内聚,在实际项目中可以尝试使用。

总结

深入理解Java泛型是工程师进阶的必备技能,希望你看了这篇文章,在今后,不论是面试还是其他的时候,谈到Java泛型时都能够云淡风轻,在使用泛型编写代码时也能够信手拈来。

收藏
评论区

相关推荐

java 泛型详解-绝对是对泛型方法讲解最详细的,没有之一
java 泛型详解绝对是对泛型方法讲解最详细的,没有之一 对java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 本文参考、、 1、概述泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型?
死磕Java泛型(一篇就够)
Java泛型,算是一个比较容易产生误解的知识点,因为Java的泛型基于擦除实现,在使用Java泛型时,往往会受到泛型实现机制的限制,如果不能深入全面的掌握泛型知识,就不能较好的驾驭使用泛型,同时在阅读开源项目时也会处处碰壁,这一篇就带大家全面深入的死磕Java泛型。 泛型擦除初探相信泛型大家都使用过,所以一些基础的知识点就不废话了,以免显得啰嗦。
Dart中的泛型、泛型方法、泛型类、泛型接口
一、Dart中的泛型 泛型方法 通俗理解:泛型就是解决 类 接口 方法的复用性、以及对不特定数据类型的支持(类型校验) 一般用   T   表示泛型 getData<T(T value){ return
C#非泛型集合和泛型集合的超级详解(转)
C# 泛型集合之非泛型集合类与泛型集合类的对应: ------------------------ ArrayList对应List HashTable对应Dictionary Queue对应Queue Stack对应Stack SortedList对应SortedList ###  转自(https://www.cnblogs.com/cheng
JAVA泛型的简单思考一
对于熟悉JAVA语言的coder来说,泛型绝对曾让自己伤透脑筋,因为java中的泛型就像是一个糖果,但嚼起来却痛苦不堪(可能有点过分,不过看很多论坛贴吧的抱怨,我觉得也是不可否认的)。每个初涉泛型的人可能都会经历这样的阶段,什么是泛型,为什么会有泛型,怎么样使用泛型,它能给我们带来什么?等等       其实早在JDK1.5之前,java还不存在泛型,但j
Java 中的 T,E,K,V, 别傻傻分不清楚
![](https://oscimg.oschina.net/oscnet/dc5177d8f673230278cc7349a7209b83f87.png) > 作者: Java的小本家 > > 来源:http://suo.im/6uFZuc 前言 Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检
Java 泛型
命名类型参数 推荐的命名约定是使用大写的单个字母名称作为类型参数。这与 C++ 约定有所不同(参阅 附录 A:与 C++ 模板的比较),并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式,推荐的名称是: K —— 键,比如映射的键。 V —— 值,比如 List 和 Set 的内容,或者 Map 中的值。 E
Java中ArrayList的向上转型问题(父类与子类的关系)
果然是java都没学好,今天写方法的时候想把方法参数写成List<父类>,然后传子类进去统一处理,结果发现报错。 丢人地百度了: ArrayList<ChildClass>();包括泛型在内的整个作为类型是无法强转成ArrayList<FatherClass>  如果想这样使用 可以使用 extends 关键字来限制泛型参数的适用范围  List<T
Java泛型的使用
### 泛型的定义: 泛型,就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如,继承或实现这个接口,用这个类型声明变量、创建对象时)确定(即传入实 际的类型参数,也称为类型实参)。 ### 泛型的引入背景: 集合容器类在设计阶段或声明阶段不能确定这个容器到底实际存储的是什么类型的对象
Java泛型详解
**引言** ------ Java泛型是jdk1.5中引入的一个新特性,泛型提供了编译时的类型检测机制,该机制允许程序员在编译时检测到非法的类型。 泛型是Java中一个非常重要的知识点,在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除。 **泛型基础** --------
java 泛型详解
对java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1\. 概述 泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型?为什么要使用泛型? 泛型,即“参数化类型”。一提到参数,最熟
java泛型
一、实现机制 java泛型实现方法为类型擦除,基于这种方法实现的泛型称为伪泛型。 java泛型只在源代码中存在,在编译后的文件中替换为原生类型,并插入强制转换。 (真正的泛型是应该存在于源码、编译后文件、运行期) 二、擦除实例 源码: List<String> testList = new ArrayList<String>();
java泛型总结
###1. 特点, 好处 java1.5后出现 包含1.5版本 泛型的出现 解决程序的安全性 保证程序的一致安全机制 使用泛型 避免了类型的强制类型转换 代码就简单 数据类型只能是 应用类型 **不能使基本类型,且前后保持一致** 泛型的 定义格式: > 集合类<数据类型>变量 = new集合类<数据类型>(); ###2. 定义使用
Gson通过借助TypeToken获取泛型参数的类型的方法
最近在使用Google的Gson包进行Json和Java对象之间的转化,对于包含泛型的类的序列化和反序列化Gson也提供了很好的支持,感觉有点意思,就花时间研究了一下。 由于Java泛型的实现机制,使用了泛型的代码在运行期间相关的泛型参数的类型会被擦除,我们无法在运行期间获知泛型参数的具体类型(所有的泛型类型在运行时都是Object类型)。 但是有的时候
Thinking in java Chapter15 泛型
* 1 与C ++比较 * 2 简单泛型 泛型 类 * 3 泛型 接口 * 4 泛型 方法 * 5 匿名内部类 * 6 构建复杂模型 * 7 * 8 * 9 * 10 “泛型”意思就是:适用于许多许多的类型 <h2 id="1">1 与C++比较 </h2> ------------------------- C