一、为什么使用泛型?
多种数据类型执行相同代码需要使用泛型
使用泛型后不需要强制转换
规范数据类型,减少异常
二、 泛型类/泛型接口/泛型方法
泛型接口与泛型类的定义基本相同。
/** * 泛型类 */ public class Genericity<K, V> { private K data; private V result; public K getData() { return data; } public void setData(K data) { this.data = data; } public V getResult() { return result; } public void setResult(V result) { this.result = result; } public static void main(String[] args) { Genericity<String, Integer> genericity = new Genericity<String, Integer>(); genericity.setData("只能传递String"); genericity.setResult(1); //不需要强制转型 String data = genericity.getData(); Integer result = genericity.getResult(); } }
/** * 泛型接口 */ public interface GenericityPort <T,V>{ public T next(V v); }
/** * 泛型方法 */ public <T> T getText(T... ts) { return ts[ts.length / 2]; }
泛型接口的实现
/** * 泛型接口的两种实现 传入实参 */ public class ImplGenericityPort implements GenericityPort<String, Integer> { @Override public String next(Integer integer) { return "OK"; } }
/** * 泛型接口的两种实现 未传入实参 */ public class ImplGenericityPort<T, V> implements GenericityPort<T, V> { @Override public T next(V v) { return null; } public static void main(String[] args) { GenericityPort<String, Integer> genericityPort = new GenericityPort<String, Integer>() { @Override public String next(Integer integer) { return "OK"; } }; } }
三、限定类型变量
有时候需要对变量加以约束,如比较变量的大小,如何确定两个变量拥有compareTo方法。
/** * 有问题的 */ public static <T> T comapare(T t1, T t2) { return (t1.compareTo(t2) > 0) ? t1 : t2; } /** * 解决方法 <T extends Comparable> */ public static <T extends Comparable> T comapare(T t1, T t2) { return (t1.compareTo(t2) > 0) ? t1 : t2; }
T extends Comparable中
T表示应该绑定类型的子类型,Comparable表示绑定类型,子类型和绑定类型可以是类也可以是接口。
如果这个时候,我们试图传入一个没有实现接口Comparable的类的实例,将会发生编译错误。
同时extends左右都允许有多个,如 T,V extends Comparable & Serializable
注意限定类型中,只允许有一个类,而且如果有类,这个类必须是限定列表的第一个。
这种类的限定既可以用在泛型方法上也可以用在泛型类上。
四、泛型中的约束和局限性
不能用基本类型实例化类型参数 int -> Integer
public class Restrict<T> { public static void main(String[] args) { //不允许 Restrict<int> restrict1 = new Restrict(); //允许 Restrict<Integer> restrict2 = new Restrict(); } }
运行时类型查询只适用
public class Restrict<T> { public static void main(String[] args) { Restrict<Integer> restrict = new Restrict(); //不允许 if(restrict instanceof Restrict<Integer>){} //允许 if(restrict instanceof Restrict){} } }
运行时类型查询只适用 泛型类的静态上下问中类型变量失效
//静态域或静态方法中不能引用类型变量 priviete startic T instance; //静态泛型方法允许 privete static <T> T getInstance(){}
不能在静态域或方法中引用类型变量。因为泛型是要在对象创建的时候才知道是什么类型的,而对象创建的代码执行先后顺序是static的部分,然后才是构造函数等等。所以在对象初始化之前static的部分已经执行了,如果你在静态部分引用的泛型,那么毫无疑问虚拟机根本不知道是什么东西,因为这个时候类还没有初始化。
不能实例化泛型变量
//不允许 new T();
不能创建泛型数组
public static void main(String[] args) { Restrict<String>[] strRestrict; //不允许 strRestrict = new Restrict<String>[10]; }
不能捕获泛型类的实例
//不允许 public class Restrict<T> extends Throwable/Exception{} //不允许 public <T extends Throwable> void work(T t) { try { } catch (T e) { //do.. } } //允许 public <T extends Throwable> void work(T t) throws T{ try { } catch (Throwable e) { //do.. throw e; } }
五、泛型类的继承规则
public class Employee { } class Worker extends Employee { } class Pair<T>{} class Main{ public static void main(String[] args) { //问题,employeePair,workerPair 是否存在继承关系? Pair<Employee> employeePair; Pair<Worker> workerPair; //答:不存在 //正常 Employee employee = new Worker(); //异常 Pair<Employee> employeePair1 = new Pair<Worker>(); } }
但是泛型类可以继承或者扩展其他泛型类,比如List和ArrayList
六、通配符类型
? extends X 表示类型的上界,类型参数是X的子类
? super X 表示类型的下界,类型参数是X的超类
? extends X 表示传递给方法的参数,必须是X的子类(包括X本身)
总结:主要用于安全地访问数据,可以访问X及其子类型,并且不能写入非null的数据。
? super X 表示传递给方法的参数,必须是X的超类(包括X本身)
总结:主要用于安全地写入数据,可以写入X及其子类型。
无限定通配符 ? 表示对类型没有什么限制,可以把?看成所有类型的父类,如Pair< ?>;
如:
ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T类型
ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型,这种没有意义,一般是方法中,只是为了说明用法。
在使用上:
? getFirst() : 返回值只能赋给 Object,;
void setFirst(?) : setFirst 方法不能被调用, 甚至不能用 Object 调用;
七、虚拟机实现泛型
泛型思想早在C++语言的模板(Template)中就开始生根发芽,在Java语言处于还没有出现泛型的版本时,只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。,由于Java语言里面所有的类型都继承于java.lang.Object,所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性,就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间,编译器无法检查这个Object的强制转型是否成功,如果仅仅依赖程序员去保障这项操作的正确性,许多ClassCastException的风险就会转嫁到程序运行期之中。
泛型技术在C#和Java之中的使用方式看似相同,但实现上却有着根本性的分歧,C#里面泛型无论在程序源码中、编译后的IL中(Intermediate Language,中间语言,这时候泛型是一个占位符),或是运行期的CLR中,都是切实存在的,List<int>与List<String>就是两个不同的类型,它们在系统运行期生成,有自己的虚方法表和类型数据,这种实现称为类型膨胀,基于这种方法实现的泛型称为真实泛型。
Java语言中的泛型则不一样,它只在程序源码中存在,在编译后的字节码文件中,就已经替换为原来的原生类型(Raw Type,也称为裸类型)了,并且在相应的地方插入了强制转型代码,因此,对于运行期的Java语言来说,ArrayList<int>与ArrayList<String>就是同一个类,所以泛型技术实际上是Java语言的一颗语法糖,Java语言中的泛型实现方法称为类型擦除,基于这种方法实现的泛型称为伪泛型。
将一段Java代码编译成Class文件,然后再用字节码反编译工具进行反编译后,将会发现泛型都不见了,程序又变回了Java泛型出现之前的写法,泛型类型都变回了原生类型
上面这段代码是不能被编译的,因为参数List<Integer>和List<String>编译之后都被擦除了,变成了一样的原生类型List<E>,擦除动作导致这两种方法的特征签名变得一模一样。
由于Java泛型的引入,各种场景(虚拟机解析、反射等)下的方法调用都可能对原有的基础产生影响和新的需求,如在泛型类中如何获取传入的参数化类型等。因此,JCP组织对虚拟机规范做出了相应的修改,引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题,Signature是其中最重要的一项属性,它的作用就是存储一个方法在字节码层面的特征签名[3],这个属性中保存的参数类型并不是原生类型,而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。
另外,从Signature属性的出现我们还可以得出结论,擦除法所谓的擦除,仅仅是对方法的Code属性中的字节码进行擦除,实际上元数据中还是保留了泛型信息,这也是我们能通过反射手段取得参数化类型的根本依据。