Java泛型解析

1 什么是泛型

1.泛型是“参数化类型”，举个例子，我们在使用方法的时候，调用某个方法给某个方法传递实参。传入给方法的参数叫做实参，实参的类型就是形参。“参数化类型是什么呢”，就是把某个形参的类型参数化。所以可以称为 “”类型形参“” ，在调用的时候传入类型实参（也就是形参）。

泛型只在编译阶段有效

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();
 
Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();
 
if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}

输出的结果是 泛型测试: 类型相同。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

2 泛型的使用

泛型分为三种 泛型类，泛型接口，泛型方法

2.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map等

//最基本的写法
class 类名称 <泛型标识：任意标识符>{
private 泛型标识符 var；
}

写一个最简单的泛型类

public class Generic <K> {
     private K key；
     public Gneric(K key){
     this.key=key;
   }
     punlic K getKey(){
     return key;
     }
}


//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);
 
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());

1.泛型的类型参数只能是类类型，不能是简单类型。
2.不能对确切的泛型类型使用instanceof操作

2.2 泛型接口

//最基本的写法
public  interface 泛型接口名<泛型标识：任意标识符>{
public  泛型标识符   next()；
}
//当实现泛型接口的类，未传入泛型实参时：

/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator<T> implements Generator<T>{
   @Override
   public T next() {
       return null;
   }
}

当实现泛型接口的类，传入泛型实参时：


/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator<String> {

   private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

   @Override
   public String next() {
       Random rand = new Random();
       return fruits[rand.nextInt(3)];
   }

2.3 泛型通配符

Ingeter是Number的一个子类，验证过Generic与Generic实际上是相同的一种基本类型，使用Generic作为形参的方法中，能否使用Generic的实例传入呢？在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢？

public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
 
showKeyValue(gNumber);
 
// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);

类型通配符一般是使用？代替具体的类型实参.此处的？Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。
可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

2.4 泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

public class GenericTest {
  //这个类是个泛型类，在上面已经介绍过
  public class Generic<T>{     
       private T key;

       public Generic(T key) {
           this.key = key;
       }

       //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
       //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
       //所以在这个方法中才可以继续使用 T 这个泛型。
       public T getKey(){
           return key;
       }

       /**
        * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
        * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
       public E setKey(E key){
            this.key = keu
       }
       */
   }

   /** 
    * 这才是一个真正的泛型方法。
    * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
    * 这个T可以出现在这个泛型方法的任意位置.
    * 泛型的数量也可以为任意多个 
    *    如：public <T,K> K showKeyName(Generic<T> container){
    *        ...
    *        }
    */
   public <T> T showKeyName(Generic<T> container){
       System.out.println("container key :" + container.getKey());
       //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
       T test = container.getKey();
       return test;
   }

   //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
   public void showKeyValue1(Generic<Number> obj){
       Log.d("泛型测试","key value is " + obj.getKey());
   }

   //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
   //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
   public void showKeyValue2(Generic<?> obj){
       Log.d("泛型测试","key value is " + obj.getKey());
   }

    /**
    * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
    * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
    * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
   public <T> T showKeyName(Generic<E> container){
       ...
   }  
   */

   /**
    * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
    * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
    * 所以这也不是一个正确的泛型方法声明。
   public void showkey(T genericObj){

   }
   */

   public static void main(String[] args) {


   }
}

//类中的泛型方法
public class GenericFruit {
   class Fruit{
       @Override
       public String toString() {
           return "fruit";
       }
   }

   class Apple extends Fruit{
       @Override
       public String toString() {
           return "apple";
       }
   }

   class Person{
       @Override
       public String toString() {
           return "Person";
       }
   }

   class GenerateTest<T>{
       public void show_1(T t){
           System.out.println(t.toString());
       }

       //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
       //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
       public <E> void show_3(E t){
           System.out.println(t.toString());
       }

       //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
       public <T> void show_2(T t){
           System.out.println(t.toString());
       }
   }

   public static void main(String[] args) {
       Apple apple = new Apple();
       Person person = new Person();

       GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
       //apple是Fruit的子类，所以这里可以
       generateTest.show_1(apple);
       //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
       //generateTest.show_1(person);

       //使用这两个方法都可以成功
       generateTest.show_2(apple);
       generateTest.show_2(person);

       //使用这两个方法也都可以成功
       generateTest.show_3(apple);
       generateTest.show_3(person);
   }
}
}

2.5 泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public void showKeyValue1(Generic<? extends Number> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//showKeyValue1(generic1);

showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

这两种方式基本上解决了我们之前的问题，但是同时，也有一定的限制。

1.上界<? extends T>不能往里存，只能往外取

不要太疑惑，其实很好理解，因为编译器只知道容器里的是Fruit或者Fruit的子类，但不知道它具体是什么类型，所以存的时候，无法判断是否要存入的数据的类型与容器种的类型一致，所以会拒绝set操作。

2.下界<? super T>往外取只能赋值给Object变量，不影响往里存

因为编译器只知道它是Fruit或者它的父类，这样实际上是放松了类型限制，Fruit的父类一直到Object类型的对象都可以往里存，但是取的时候，就只能当成Object对象使用了。

所以如果需要经常往外读，则使用<? extends T>，如果需要经常往外取，则使用<? super T>。

泛型的上下边界添加，必须与泛型的声明在一起

这个哥们的写的很详细，我也是看这个https://www.cnblogs.com/coprince/p/8603492.html