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反射资料

 

posted @ 2016-12-07 13:58  疯狂的肉包  阅读(422)  评论(0编辑  收藏  举报