一、为什么需要使用泛型?
先来看一段代码
public int addInt(int x, int y) {
return x + y;
}
public float addFloat(float x, float y) {
return x + y;
}
可以看到实现一个简单的加法需求,需要对int和float类型分别处理,这时候想要实现double类型求和,就得重新再写一个double类型的方法。
定义了一个List类型的集合,加入字符串和Integer类型的值,这是完全可以的,因为此时list默认的类型为Object类型,编译阶段也是正常,而运行时会出现"java.lang.ClassCastException"异常。
以上过程发现:
泛型适用于多种数据类型执行相同的代码
泛型中的类型在使用时指定,不需要强制类型转换
二、泛型类和泛型接口
泛型,即“参数化类型”,怎么理解参数化类型?
顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
泛型类:引入一个变量类型T(其他字母也可,常用T,E,K,V),使用<>包括,放在类名后面,允许有多个类型变量。
public class Generic<T> {
private T data;
public Generic(T data) {
this.data = data;
}
}
public class Generic<T,K> {
private T data;
private K result;
public Generic(T data ,K result) {
this.data = data;
this.result =result;
}
}
泛型接口:
public interface Generator<T> {
private T play();
}
实现泛型接口的类,有两种实现方法
//未传入泛型实参时
public class ImplGenerator<T> implements Generator<T>{
private T data;
@Override
public T play() {
return null;
}
}
//传入泛型实参
public class ImplGenerator1 implements Generator<String>{
@Override
public String play() {
return null;
}
}
泛型方法:
泛型方法在public与返回值之间的<T>必不可少,表明这是一个泛型方法,并且声明了一个泛型T,这个T可以出现在这个泛型方法的任意位置,泛型的数量也可以多个。
public class Generic<T> {
private T data;
//普通方法
public T getData() {
return data;
}
//泛型方法
public <T> T genericMethod(Generic<T> generic) {
T t = generic.getData();
return t;
}
//泛型方法
public <T,K> K genericMethod1(Generic<K> generic) {
K k = generic.getData();
return k;
}
}
三、限定类型变量
有时候,我们需要对类型变量加以约束,比如使用Comparable计算两个变量大小,那么必须将T限制为实现了Comparable接口的类。
public static <T extends Comparable> T min(T a, T b) {
if (a.compareTo(b) > 0)
return b;
else
return a;
}
public static <T extends Comparable & Serializable> T max(T a, T b) {
if (a.compareTo(b) > 0)
return a;
else
return b;
}
T extends Comparable中,T表示应该绑定类型的子类型,Comparable表示绑定类型,子类型和绑定类型可以是类也可以是接口。
同时extends左右都允许有多个,如 T,V extends Comparable & Serializable
注意限定类型中,只允许有一个类,而且如果有类,这个类必须是限定列表的第一个。
这种类的限定既可以用在泛型方法上也可以用在泛型类上。
如果这个时候,我们试图传入一个没有实现接口Comparable的类的实例,将会发生编译错误。
四、泛型中的约束和局限性
不能用基本类型实例化类型参数
public class Generic<T> {
Generic<int> genericInt =new Generic<int>();//不允许
Generic<double> genericDouble =new Generic<double>();//不允许
}
运行时类型查询只适用于原始类型
public class Generic<T> {
Generic<Double> genericDouble =new Generic<Double>();
if(genericDouble instanceof Generic<Double>)//不允许
if(genericDouble instanceof Generic<T>)//不允许
}
泛型类的静态上下文中类型变量失效
因为泛型是要在对象创建的时候才知道是什么类型的,而对象创建的代码执行先后顺序是static的部分,然后才是构造函数等等,所以在对象初始化之前static的部分已经执行了。
//静态域或者方法里不能饮用类型变量
private static T instance; //不允许
//静态方法本身是泛型方法就可以
private static <T> T getInstance(){}//允许
不能创建参数化类型的数组
//不允许
Generic<Double>[] getGenericArrayy =new Generic<Double>[10];
不能实例化类型变量
public class Generic<T> {
private T data;
//不允许
public Generic(){
this.data =new T();
}
}
五、泛型类型通配符
现有一个类和子类,以及一个泛型类
public class Fruits{}
public class Apple extends Fruits{}
public class Pair<T>{}
请问Pair<Fruits>和Pair<Apple>是继承关系吗?
答案:不是,Pair<Fruits>在逻辑上不能视为Pair<Apple>的父类。
但是泛型类可以继承或者扩展其他泛型类,如ArrayList继承List
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
正是因为前面所述的,Pair<Fruits>和Pair<Apple>没有任何关系,就会出现下图这种情况
那么如何解决呢?因此,我们需要一个在逻辑上可以用来表示同时是Pair<Fruits>和Pair<Apple>的父类的一个引用类型,由此,类型通配符应运而生。
给print方法加入上界通配符,即可
public void print(Pair<? extends Fruits> pair){
}
泛型通配符有两种使用方式:
? extends X 表示类型的上界,类型参数是X的子类,包括X本身
? super X 表示类型的下界,类型参数是X的超类,包括X本身
?extends X 通配符
对泛型类Pair来说,如果其中提供了get和set类型参数变量的方法的话,set方法是不允许被调用的,会出现编译错误,get方法则没问题,会返回一个Fruit类型的值。
为何?
道理很简单,? extends X 表示类型的上界,类型参数是X的子类,那么可以肯定的说,get方法返回的一定是个X(不管是X或者X的子类)编译器是可以确定知道的。但是set方法只知道传入的是个X,至于具体是X的那个子类,不知道。
总结:主要用于安全地访问数据,可以访问X及其子类型,并且不能写入非null的数据。
?super X 通配符
对泛型类Pair来说,如果其中提供了get和set类型参数变量的方法的话,set方法可以被调用的,且能传入的参数只能是X或者X的子类
get方法只会返回一个Object类型的值,为何?
? super X 表示类型的下界,类型参数是X的超类(包括X本身),那么可以肯定的说,get方法返回的一定是个X的超类,那么到底是哪个超类?不知道,但是可以肯定的说,Object一定是它的超类,所以get方法返回Object。编译器是可以确定知道的。对于set方法来说,编译器不知道它需要的确切类型,但是X和X的子类可以安全的转型为X。
总结:主要用于安全地写入数据,可以写入X及其子类型。
六、虚拟机是如何实现泛型的?
Java 语言中的泛型,它只在程序源码中存在,在编译后的字节码文件中,就已经替换为原来的原生类型(RawType,也称为裸类型)了,并且在相应的地方插入了强制转型代码,因此,对于运行期的 Java 语言来说,ArrayList<int>与 ArrayList<String>就是同一个类,所以泛型技术实际上是 Java 语言的一颗语法糖,Java 语言中的泛型实现方法称为类型擦除,基于这种方法实现的泛型称为伪泛型。