java中泛型的理解及使用

1. 泛型的一些概念

Java从1.5开始加入了泛型，主要是解决类型安全及扩展问题，它的本质是参数化类型的应用，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类，接口和方法的创建中，分别称为泛型类，泛型接口和泛型方法。

泛型的一些特性：

• 泛型是类型擦除的：Java的泛型只在编译期有效，它只在程序源码中存在，在编译后的字节码文件中就已经替换为原来的原生类型。并且在对象的地方插入了强制转型代码。因此对于运行期的Java语言来说List<String>和List<Int>就是同一个类。

• 泛型识别：为了解决泛型的识别问题，Java引入了Signature,LocalVaribaleTypeTable等新的属性用于解决参数类型的识别问题。Signature的作用就是存储一个方法在字节码层面的特征签名，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。从Signature属性可以得知，所谓的擦除仅仅是对方法的Code属性中的字节码进行擦锁，实际上元数据中还是保留了泛型信息，所以还是通过class对象反射得到泛型信息。

• 泛型不是协变的：如String是Object的子类，但是List<String>并不是List<Object>的子类型，它们是2个单独的类型。

2. 泛型的使用

泛型类及泛型接口

public class Shop<T> {
    //商品数量
    int count;
    //抽象商品
    T goods;
    public T get(){
        return t;
    }
}

假如有一个Shop类，现在并不明确是什么类型的店，里面定义了卖物品的数量int类型的count,以及不确定什么类型的商品goods。

这里有个问题，不确定类型，但是必须有类型。否则编译器就会报错。所以要给goods一个类型，因为不确定，所以可以先用一个代号代替，等实际类型确定时再替换掉，这里使用T。但是这个T只是一个代号，编译器不可能认识，所以要在类名的右边用<>包裹T，告诉编译器T是一个类型的代号，然后就可以在类中使用T代表某种类型了。

这里的T不具备特殊意义，只是到时会被替换的实际类型的代号，所以它可以随便写成A，B，C，D等等其他任何形式。

再继续看，泛型T可以代表任何类型，这个范围太广，如果要限定是某一种类型，或符合某些特性呢？，如是一家书店，所以如果要限定某种类型的话就要对T进行限制：

public class Shop<T extends BookShop> {
    
    //商品数量
    int count;

    //抽象商品
    T goods;

    public T get(){
        return goods;
    }
}

使用extends关键字，限定了T只能是BookShop类型，那么如果要求即是书店，又是咖啡店呢：

//如果有2种特性，直接用&符号连接,BookShop为类，CoffeShop为接口
public class Shop<T extends BookShop & CoffeShop> {

    //商品数量
    int count;

    //抽象商品
    T goods;

    public T get(){
        return goods;
    }
}

直接使用&符号连接即可，这里的extends遵循Java的单继承原则，BookShop和CoffeShop只能一个是类，另外个是接口，当然接口是可以多实现的，继续用&连接即可，如添加Rest属性：

//如果有2种特性，直接用&符号连接,BookShop为类，CoffeShop，Rest为接口，遵循Java的单继承，多实现原则
public class Shop<T extends BookShop & CoffeShop & Rest> {

    //商品数量
    int count;

    //抽象商品
    T goods;

    public T get(){
        return goods;
    }
}

再来看，假如要开一个分店，BranchShop:

public class BranchShop<B> extends Shop{
    
    int count ;
    
    B goods;

    @Override
    public BookShop get() {
        return super.get();
    }
}

可以看到BranchShop声明了自己的泛型B（写在类右边，用<>包裹）但是重写的get()返回值类型变成了BookShop，如果BranchShop需要get()的返回值类型是泛型类型呢？：

public class BranchShop<B> extends Shop{

    int count ;

    B goods;
        //这里不会报错
    public B getGoods(){
        return goods;
    }
    @Override
    //这里会报错
    public B get() {
        //这里也会报错
        return super.get();
    }
}

getGoods()不会报错，但是get()会报错，因为get是父Shop的方法，而Shop的泛型T是这样的:

T extends BookShop & CoffeShop & Rest

它限制了范围，所以如果要重写父类的方法，也要和父类的泛型保持一样的限制（也可以不重写，不限制，如getGoods()）:

public class BranchShop<B extends BookShop & CoffeShop & Rest> extends Shop{

    int count ;

    B goods;

    public B getGoods(){
        return goods;
    }
        
    @Override
    //这里不报错了
    public B get() {
      //这里还是报错
        return super.get();
    }
}

可以看到当B和父类的T同步了限制之后，返回值类型不报错了，但是super.get()还是报错，这是因为之前说过，要使用泛型必须在类的右边声明，BranchShop在自己右边声明了<B extends BookShop & CoffeShop & Rest>，但是在BranchShop中，父类Shop并没有声明，没有声明就没法使用，这里子类把父类的泛型类型丢失了，所以要给它加上声明:

public class BranchShop<B extends BookShop & CoffeShop & Rest> extends Shop<B>{

    int count ;

    B goods;

    public B getGoods(){
        return goods;
    }

    @Override
    public B get() {
        return super.get();
    }
}

直接在Shop后声明<B>就OK，这里的泛型就不能随便写，必须和BranchShop的声明保持一致，也就是必须写成B。

A：public class BranchShop<B extends BookShop & CoffeShop & Rest> extends Shop<B>
B：public class BranchShop<B> extends Shop<B extends BookShop & CoffeShop & Rest>
至于Shop<>,里只能和BranchShop保持一致，以及为什么不写成B，而写成A这样，可以简单理解为，泛型必须声明在类的右边且必须声明才能使用。所以Shop<>它是使用泛型，而不是声明，所以不能随便写成一个没有声明的类型，所以只能是B。所以限制条件也必须加在BranchShop后，也就是A写法。

2. 泛型方法

如果类没有声明泛型类型，那么如何在方法里使用泛型？，看一下一个常用的方法findViewById()：

    public <T extends View> T findViewById(@IdRes int id) {
        return this.getDelegate().findViewById(id);
    }

可以看到，是在返回值前面声明了T，并且限制了T extends View,然后返回值就可以使用T了。

3. 通配符

• 上界通配符

public class FruitShop {
        //Apple集合，Apple继承自Fruit
    List<Apple> apples;
      //Orange集合，Orange继承自Fruit
    List<Orange> oranges;
        //这样写没法遍历Apple和Orange集合
    public  void getFruit(List<Fruit> fruits){
    }
}

假如有一个水果店，需要一个通用的方法遍历每一种水果，但是由于泛型不是协变的，所以上面的getFruit()是没法遍历Apple和Orange集合的，这里要解决这个问题，要用到? extends关键字：

public class FruitShop {

    List<Apple> apples;

    List<Orange> oranges;

    public  void getFruit(List<? extends Fruit> fruits){
        for (int i = 0; i < fruits.size(); i++) {
            //得到每一个fruit
            Fruit fruit = fruits.get(i);
        }

    }
}

使用? extends Fruit代表了Fruit某个字类型，所以只要是Fruit子类型都可以（每个类型都是自身的子类型）进行遍历。

但是上界通配符有一个问题：

public class FruitShop<E> {

    List<Apple> apples;

    List<Orange> oranges;

    public  void getFruit(List<? extends Fruit> fruits){
        //不报错
        fruits.get(0);
            //这里报错
        fruits.add(new Orange());
    }
}

在getFruit()接收了一个Fruit一个子类型的List，但是只知道是Fruit的子类型，具体是哪种子类型是不知道的，如上图，很可能传入了一个Apple的的List，但是有可能添加进一个Orange，所以Java不允许这样操作。

这就是上界通配符？extends T,限制了？只能是T或者T的子类，并且只能取内容，不能存内容

• 下界通配符

    public void setFruit(List<? super Fruit> fruits){
        fruits.add(new Apple());
        Object object = fruits.get(0);
    }

和上界通配符刚好相反，下届通配符代表可以接受Fruit及它的所有超类型。
它的特性是可以存东西，但是不能取，或者只能用Object接收，但是类型信息会全部丢失。因为确定取的到底是什么类型。

• 无界通配符

    //无界通配符
    public void setFruit(List<?> fruits){
        //这行报错
        fruits.add(new Apple());
        //同样只能用Object接收
        Object o = fruits.get(0);
    } 

？代表不进行任何限制，可以是任何类型。所以它既不能存，也不能取（或者取出的值元素只能用Object接收）。

但是可以通过写一个帮助类，来达到让？能取的功能：

    public void setFruit(List<?> fruits){
        //这行报错
        fruits.add(fruits.get(0));
        //只能获取到Object类型
        Object o = fruits.get(0);
        setFruitHelper(fruits);
    }

    public <E> void setFruitHelper(List<E> e){
        //这行不报错
        e.add(e.get(0));
        //可以获取到T类型
        T t = e.get(0);


    }

setFruitHelper()知道e列表中取出的任何值均为E类型，并且知道E类型的任何值放进列表都是安全的。

无界通配符也有要注意的问题：

    public  void test(){
    //构造一个下界通配符集合
    List<? super Fruit> f =new ArrayList<>();
     //添加Apple
     f.add(new Apple());
     //添加Orange
     f.add(new Orange());
      //把下届通配符集合传入无界通配符集合里
      setFruit(f);
    }
    
    public void setFruit(List<?> fruits){
        //调用Helper方法
        setFruitHelper(fruits);
    }

    public <T> void setFruitHelper(List<T> e){
        //在这里执行get()以及add()
      
        //取出的是Apple
        T t = e.get(0);
        //添加的是Apple
        e.add(e.get(0));
        //取出的是Orange
        T t = e.get(1);
        //添加的是Orange
        e.add(e.get(1));

    }

可以看到通过setFruitHelper()，规避了下界通配符不能取的问题。使用的时候需要注意。

3. 获取泛型类型

前面说过，泛型在运行期间是擦除的，但是会保存在class文件里，所以可以从class里获取

1. 获取类及接口泛型，Java提供了2个关于泛型的方法：

• getGenericSuperclass：返回此类所表示的实体的直接超类的类型，看一下代码

//part1:AppleShop自身的泛型T，明确了父类FruitShop的泛型Apple
public class AppleShop<T> extends FruitShop<Apple> {

}

//part 2
//获取AppleShop的class
Class<AppleShop> appleShopClass = AppleShop.class;
//获取type
Type genericSuperclass = appleShopClass.getGenericSuperclass();
//获取具体type的数组结合
Type[] actualTypeArguments = ((ParameterizedType)genericSuperclass).getActualTypeArguments();

可以看到在part1中，AppleShop类声明了自身的泛型T，明确了父类的泛型类型为Apple

然后在part2中，先获取了AppleShop的class，class通过调用getGenericSuperclass()，返回了Type。

然后通过type再获取具体的泛型数组，由于这里只有一个泛型，所以取第一个actualTypeArguments[0],分别看一下它们的结果：

type:xxx.xxx.xxx.FruitShop<xxx.xxx.xxx.Apple>
actualTypeArguments[0]:xxx.xxx.xxx.Apple

可以看到type包含了父类FruitShop信息，actualTypeArguments[0]返回了具体泛型类型。

这里要注意一点，这个方法获取的是明确的父类泛型，不是自身声明的泛型类型。因为自身泛型类型这时还并没有确定。

• getGenericInterfaces：返回此类直接实现的所有接口类型，看一下代码：

//part1:明确了父类FruitShop的泛型Apple
public class AppleShop implements Rest<Apple> {

}
//part2:
//获取AppleShop的class
Class<AppleShop> appleShopClass = AppleShop.class;
//获取type数组（因为可能实现多个接口，所以是数组）
Type[] genericInterfaces = appleShopClass.getGenericInterfaces();
//取第一个的type
ParameterizedType genericInterface = (ParameterizedType) genericInterfaces[0];
//获取具体type的数组结合
Type[] actualTypeArguments = genericInterface.getActualTypeArguments();

看一下获取结果：

type:xxx.xxx.xxx.FruitShop<xxx.xxx.xxx.Apple>
actualTypeArguments[0]:xxx.xxx.xxx.Apple

和getGenericSuperclass的过程和结果都是一样的。

2. 获取方法和成员变量的泛型

方法及成员变量的泛型，可以通过反射获取。

public class AppleShop<T> extends FruitShop<Apple> {
        //成员变量泛型
    List<Apple> apples = new ArrayList<>();
        //方法泛型，包括返回值泛型以及参数泛型
    public List<Apple> getApples(List<Apple> count){
       
        return apples;
    }

}

看一下如何获取的代码：

//获取class
        Class<AppleShop> appleShopClass = AppleShop.class;
        try {
            //获取apples成员变量，这里只是测试，使用了获取单个成员变量的方法
            Field apples = appleShopClass.getDeclaredField("apples");
            //获取成员变量的type
            Type genericType = apples.getGenericType();
            //获取成员变量泛型的具体type
            Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();

        }catch (Exception e){

        }

        try{
            //获取getApples(),这里只是测试，使用了获取单个方法的方法
            Method getApples = appleShopClass.getMethod("getApples", new Class[]{List.class});
            //获取方法参数的Type集合
            Type[] genericParameterTypes = getApples.getGenericParameterTypes();
            //取第一个参数的具体Type
            ParameterizedType genericParameterType = (ParameterizedType) genericParameterTypes[0];
            //取第一个参数的具体类型集合
            Type[] actualTypeArguments1 = genericParameterType.getActualTypeArguments();
            
            //获取getApples()的返回值Type
            Type genericReturnType = getApples.getGenericReturnType();
            //获取返回值具体类型的Type集合
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();

        }catch (Exception e){

        }

以上就是获取成员变量以及方法返回值，方法参数泛型类型的方式。

3. 运行时代码的泛型

前面的都是通过class获取的泛型类型，但是有些代码是运行时才确定的，如下：

    public List<Apple> getApples(List<Apple> count){
            //这里运行时才会确定
        List <Orange> oranges=new ArrayList<>();
        return apples;
    }

运行时才能确定的，通过之前的方法就没法获取。

还是前面说过,class会保留泛型信息，那么这里通过建立匿名内部类的方式，然后就会产生class文件，从而让泛型类型保存起来，如下：

  public List<Apple> getApples(List<Apple> count){
            //通过在后面加一个{}的方式建立一个匿名内部类
        List <Apple> applesList=new ArrayList<Apple>(){};
            //获取type,和之前一样
        Type genericSuperclass = applesList.getClass().getGenericSuperclass();
        return apples;
    }

通过建立一个匿名内部类的方式，产生class文件，然后就可以获取泛型类型了。