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