18.Java泛型

1.为什么需要泛型

List list1=new ArrayList(Arrays.asList(new String("string"),new Integer(20)));

String str=(String)list.get(0);//强制向下转型
System.out.println(str.matches("y\\w+"));

说明：

• Java在1.5版本的时候引入了泛型机制，list1就是没有使用泛型的容器，可以向容器中添加任何类的对象
• 传入容器的对象都是Object对象，从容器中取出对象的时候可以强制向下转型（很有可能出错，只有在运行时才会报错）

引入泛型的目的：

• 1.限制添加进容器的元素的类型

• List<String> list=new ArrayList();
  list.add(new String("Hello world"));
  list.add(new Integer(12));//编译时就会报错
  String str=list.get(0);//不需要转型

• 2.代码复用（或者说减少冗余的代码）

2.泛型的写法

2.1 泛型类

语法：class ClassName<E>{//code}

class Cell<T>{
    private T t;
    public Cell(T t){
        this.t=t;
    }
}

说明：

• 1.泛型并不是一种新的类型，Cell<Integer>和Cell<String>都是Cell类，原始类Cell，Cell<Integer>,Cell<String>是Cell的两种不同的泛型调用。
• 即Cell和Cell<E>是同一个类，后者称为有类型参数的泛型类。

• Cell<String> cell2=new Cell<String>("Hello");
  System.out.println(cell1.getClass()==cell2.getClass());//true，Class对象相同所以是同一种类型

• 2.静态函数、静态成员不能使用类的类型参数、静态内部类不能使用外部类的类型参数
• 理由是静态函数只能使用静态属性，静态函数属性和内部类不依赖于类的对象，也就是说使用静态函数的时候，参数化类型还没有被初始化，因此不能使用。
• 3.泛型的类型参数不存在继承关系前后必须一致

• List<Number> list=new ArrayList<Integer>();//wrong
  List<Integer> list=new ArrayList<Integer>();//right

2.2 泛型函数

语法：public<E> E f(E e){//code}

public class Main {
    public static void main(String[] atgs) {
        System.out.println(new MyClass().f(20));//调用泛型函数
    }
}

class MyClass{
    public<E> E f(E e){
        return e;
    }
}

问题：怎么使用

• 方式1不指定泛型:Serializable b=Main.dosomthing(new String(),new Integer(1));//最小公共父类是 Serializable
• 方式2指定泛型:Number a=Main.<Number>dosomthing(1,2.2);//指定参数化类型为Number
• 例子：

• public static void main(String[] args) {
          /**不指定泛型的时候*/
          int i=Test2.add(1, 2); //这两个参数都是Integer，所以T为Integer类型
          Number f=Test2.add(1, 1.2);//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number
          Object o=Test2.add(1, "asd");//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Object  
  
          /**指定泛型的时候*/
          int a=Test2.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
          int b=Test2.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float
          Number c=Test2.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
      }  
  
      //这是一个简单的泛型方法
      public static <T> T add(T x,T y){
          return y;  
  }  

3.泛型进阶

3.1有界的类型参数—对类型参数的类型进行限制

• List<T> T没有限制
• List<T extends Number> Number是T的上界，传入容器中的类必须是Number或者Number的子类
• List<T extends Integer & Comparable<T>> 可以有多个上界，但是上界里只能有一个类，可以有多个接口,而且它们中的函数都可以使用。
• 备注：List<Number> List<Integer>是没有继承关系的

3.2 参数化类型的数组

• 1.泛型和数组之间有一个矛盾，数组必须知道具体的类型，但是泛型的参数化类型恰恰确定不了具体的类型，不能直接创建泛型数组
• E[] arrays=new E[10];//wrong
• E[] arrays=null;//right
• 2.不能实例化带有参数化类型的数据
• ArrayList<String>[] arrays=new ArrayList<String>[10];//wrong
• ArrayList<String>[] arrays=new ArrayList[10]; //right----arrays[0]中只能存放String类型的对象

3.3 通配符

1.问题:

• List<Number> 与 List<Integer>之间没有任何继承关系，所以sum函数不能接受List<Integer>作为参数

public class Main {
    public static void main(String[] atgs) {
        ArrayList<Integer> arrays=new ArrayList<Integer>();
        arrays.add(new Integer(1));
        arrays.add(new Integer(1));
        arrays.add(new Integer(1));
        System.out.println(Main.sum(arrays));//wrong
    }

    public static double sum(List<Number> arrays){
        int sum=0;
        for(Number integer:arrays){
            sum+=integer.doubleValue();
        }
        return sum;
    }
}

 解决：

• 使用通配符？可疑解决

•     public static double sum(List<? extends Number> arrays){
          int sum=0;
          for(Number integer:arrays){
              sum+=integer.doubleValue();
          }
          return sum;
      } 

2.通配符的界限----有点难理解

• 通配符与类型参数并不相同，只能有一个边界，也就是说不能这么写，List<? extends Number &Comparable>//wrong
• a.*通配符List<?> ------不能存入元素除了null
• 取出来的元素是Object，List<?> 相当于 List<? extends Object>不是List<Object>
• 不能像其中添加任何的对象

• b.有上届的通配符List<? extends Number> 取出来的元素是Number----不能存入元素除了null
• List<? extends Animal>的子类是List<Animal> List<Bird> List<Cat>
• 但是传入容器中的参数类型是不定的（假设可以），可能是Animal，Bird，Cat
• 传入的参数是未知的，还会有冲突，所以java为了保护其类型一致，禁止向这种容器中添加除了null之外的所有类型数据

• c.有下界的通配符List<? Super Number>  取出来的元素是Object-----可以存入Number以及子类对象，但是不能存入Number的父类
• List<? super Animal> 是 List<? super Bird>的子类型
• List<? super Animal> 只能添加Animal及其子类，原因是Animal的子类可以向上转型为Animal类的对象，但是Animal的父类的类型不确定，所以不能添加到容器中。

总结：

• 通配符修饰的容器，向其中添加元素的限制很多，比如List<?>,List<? extends Number>都不能向里面添加元素非null元素，List<? super Number>只能添加Number以及它的子类。
• 一般用作函数的参数
• public void f(List<?>){//code}
• public void f(List<? extends Number>){//code}   传入List<Number>、List<Integer>都是可以的
• public void f(List<? super Integer>){//code}  传入List<? super Number>可以的，List<? super Number>是List<? super Integer>的子类（子集）
• 例子：

• public static void main(String[] atgs) {
     List<? super Number> list=new ArrayList<>();
     list.add(new Integer(1));
     list.add(new Double(3.9));
     System.out.println(sum(list));
  }
  
  public static double sum(List<? super Integer> arrays){
      double sum=0;
      for(Object integer:arrays){
          Number number=(Number) integer;
          sum+=number.doubleValue();
      }
      return sum;
   }
  

  备注：List<? super Number> 是 List<? super Integer>的子类，所以可以执行

4.泛型擦除

4.1泛型擦除概述

Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦除（type erasure）。 Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

4.2 类型擦除的表现

• 1.List<Integer>和List<Number>的类型相同
• 原因就是编译的时候，由于类型擦除，均变成了List<Object>,这里给了我们一个信息，那么运行的时候是不是就可以向容器中添加任意类型的数据了，因为他们都是Object的子类.
• 2.运行时向容器中添加任意元素

• public static void main(String[] atgs) {
          List<String> list=new ArrayList<>();
          //list.add(new Integer(1));编译时添加wrong
          try {
              Method add=list.getClass().getMethod("add",Object.class);
              add.invoke(list,new Integer(1));//运行时添加可以
              add.invoke(list,new String("yangyun"));
              add.invoke(list,new Double(1.23));
              add.invoke(list,new Float(1.1234));
          } catch (Exception e) {
              e.printStackTrace();
          }
          System.out.println(list);
      }

• 利用反射在运行的时候，可以向list中添加任何元素

4.3 泛型的写法

• a.泛型的写法
• 1.ArrayList list=new ArrayList<Integer>();------这里的参数化类型没有作用(有什么作用？)
• 2.ArrayList<Integer> list=new ArrayList<>();---类型参数有作用
• 3.new ArrayList<String>().add("yangyun");-----类型参数有作用
• 真正涉及类型检查的是它的引用，因为我们是使用它引用 list 来调用它的方法，比如说调用add()方法。所以arrayList1引用能完成泛型类型的检查

4.4 运行时取值-自动类型转换

• List<String>编译期擦除之后变为原始类型 List<Object>,那么取值的时候的类型自动转换是怎么做的？
• 通过参考文献的3.2可以知道，转型是在调用get函数的地方进行的。

4.5 泛型与函数覆盖

class Father<E>{
    private E e;

    public void setE(E e) {
        this.e = e;
    }

    public E getE() {
        return e;
    }
}

class Son extends Father<String>{
    @Override
    public void setE(String string){
        super.setE(string);
    }

    @Override
    public String getE(){
        return super.getE();
    }
}

说明上边的继承关系中，Father是一个泛型类，Son继承自Father<String>,并覆盖了父类中的函数。

问题：覆盖应该是参数一样的，父类中的函数的参数编译后擦除应该是Object，子类的中的函数参数是String，为什么构成覆盖？

解决：J于是JVM采用了一个特殊的方法，来完成这项功能，那就是桥方法。

桥方法：就是子类中，参数为Object的函数，我们自己写的函数回去调用桥方法，间接的实现重载

说明：参考文献2中有具体的例子

5.泛型知识点补充

5.1 泛型与内部类

内部类可以使用外部类的一切数据，包括类型参数，反过来外部类不可以使用内部类的类型参数，但是外部类可以利用内部类的对象使用内部类的private属性（在外部类的范围内）

5.2 使用泛型类的时候应该指出具体的类型参数的类型

5.3 类型

System.out.println(list instanceof ArrayList<?>);//可以，但是通配符不能设置界限
System.out.println(list instanceof ArrayList<String>);//不行

5.4 利用反射创建泛型数组

说明:我们知道参数类型数组不能直接实例化，那么我们如何返回泛型数组，答案就是利用反射

public class Main<E>{
    public static void main(String[] atgs) {
        Main<String> obj=new Main<>();
        String[] arrays=obj.getArrays(2);
        Array.set(arrays,0,"123");
        Array.set(arrays,1,"yangyun");
        Array.set(arrays,2,"Hello");

        System.out.println(Arrays.toString(arrays));
    }

    public E[] getArrays(int length) {
        return (E[])Array.newInstance(String.class,3);
    }
}

参考文献

http://blog.csdn.net/baple/article/details/25056169

https://my.oschina.net/fuyong/blog/719013

http://www.cnblogs.com/penghongwei/p/3300094.html   //特别好的Java反射资料