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