“泛型” 意味着编写的代码可以被不同类型的对象所重用。泛型的提出是为了编写重用性更好的代码。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
比如常见的集合类 LinkedList:
public class LinkedList extends AbstractSequentialList implements List,Deque,Cloneable,Serializable{
//.....
transient Link voidLink;
//.....
}
可以看到,LinkedList
在引入泛型之前,要想实现一个通用的、可以处理不同类型的方法,你需要使用 Object 作为属性和方法参数,比如这样:
public class Generic{
private Object[] mData;
public Generic(int capacity){
mData = new Object[capacity];
}
public Object getData(int index){
//.....
return mData[index];
}
public void add(int index,Object item){
//.....
mData[index] = item;
}
}
它使用一个 Object 数组来保存数据,这样在使用时可以添加不同类型的对象:
Generic generic = new Generic(10);
generic.add(0,"fangxing");
generic.add(1,23);
Object 是所有类的父类,所有的类都可以作为成员被添加到上述类中;当需要使用的时候,必须进行强制转换,而且这个强转很有可能出现转换异常:
String item1 = (String) generic.getData(0);
String item2 = (String) generic.getData(1);
第二行代码将一个 Integer 强转成 String,运行时会报错 :
可以看到,使用 Object 来实现通用、不同类型的处理,有这么两个缺点:
根据《Java 编程思想》中的描述,泛型出现的动机在于:
有许多原因促成了泛型的出现,而最引人注意的一个原因,就是为了创建容器类。
在 JDK 1.5 出现泛型以后,许多集合类都使用泛型来保存不同类型的元素,比如 Collection:
public interface Collection extends Iterable{
Iterator iterator();
Object[] toArray();
T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collecion c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
}
实际上引入泛型的主要目标有以下几点:
类型安全
消除强制类型转换
潜在的性能收益
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
类型参数的意义是告诉编译器这个集合中要存放实例的类型,从而在添加其他类型时做出提示,在编译时就为类型安全做了保证。
参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。
public class GenericClass{
private F mContent;
public GenericClass(F content){
mContent = content;
}
/*
泛型方法
*/
public F getContent(){
return mContent;
}
public void setContent(F content){
mcontent = content;
}
/*
泛型接口
*/
public interface GenericInterface{
void doSomething(T t);
}
}
泛型类
泛型类和普通类的区别就是类名后有类型参数列表
类名中声明参数类型后,内部成员、方法就可以使用这个参数类型,比如上面的 GenericClass
泛型类最常见的用途就是作为容纳不同类型数据的容器类,比如 Java 集合容器类。
泛型接口
和泛型类一样,泛型接口在接口名后添加类型参数,比如上面的 GenericInterface
实现类在实现泛型接口时需要指明具体的参数类型,不然默认类型是 Object,这就失去了泛型接口的意义。
未指明类型的实现类,默认是 Object 类型:
public class Generic implements GenericInterface{
@Override
public void doSomething(Object o){
//...
}
}
指明了类型的实现:
public class Generic implements GericInterface{
@Override
public void doSomething(String s){
//.....
}
}
泛型接口比较实用的使用场景就是用作策略模式的公共策略, Comparator就是一个泛型接口:
public interface Comparator{
public int compare(T lhs, Trhs);
public bollean equals(Object object);
}
泛型接口定义基本的规则,然后作为引用传递给客户端,这样在运行时就能传入不同的策略实现类。
泛型方法
泛型方法是指使用泛型的方法,如果它虽在的类是一个泛型类,那就很简单了,直接使用类声明的参数。
如果一个方法所在的类不是泛型类,或者他想要处理不同于泛型类声明类型的数据,那它就需要自己声明类型。
/*
传统的方法,会有unchecked ... raw type 的警告
*/
public Set union(Set s1, Set s2){
Set result = new HashSet(s1);
result.addAll(s2);
return result;
}
/*
泛型方法,介于方法修饰符和返回值之间的称作 类型参数列表(可以有多个)
类型参数列表 指定参数、返回值中泛型的参数类型范围,命名惯例与泛型相同。
*/
public Set union2(Set s1, Set s2){
Set result = new HashSet<>(s1);
result.addAll(s2);
return result;
}
通配符:传入的类型有一个指定的范围,从而可以进行一些特定的操作
泛型中有三种通配符形式:
1.无限制通配符
2. extends 关键字声明了类型的上界,表示参数化的类型可能是所指定的类型,或者是此类型的子类。
3. super 关键字声明了类型的下界,表示参数化类型可能是指定类型,或者是此类型的父类。
要使用泛型,但是不确定或者不关心实际要操作的类型,可以使用无限制通配符(尖括号里一个问号,即 ),表示可以持有任何类型。
? 和 Object 不一样,List 表示未知类型的列表,而 List
如传入个 List
在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类,这样有两个好处:
在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
private void add(List dst, List Src){
for (E e : src){
dst.add(e);
}
}
上面的 dst 类型 “大于等于” src 的类型,这里的“大于等于”是指 dst 表示的范围比 src 要大,因此装得下 dst 的容器也就能装 src。
通配符比较
无限制通配符 < ?> 和 Object 有些相似,用于表示无限制或者不确定范围的场景。
< ? super E> 用于灵活写入或比较,使得对象可以写入父类型的容器,使得父类型的比较方法可以应用于子类对象。
< ? extends E> 用于灵活读取,使得方法可以读取 E 或 E 的任意子类型的容器对象。
因此使用通配符的基本原则:
小总结一下:
举个例子:
private > E max(List e1){
if(e1 == null){
return null;
}
//迭代器返回的元素属于 E 的某个子类型
Iterator iterator = e1.iterator();
E result = iterator.next();
while (iterator.hasNext()){
E next = iterator.next();
if(next.compareTo(result)>0){
result = next;
}
}
return result;
}
1.要进行比较,所以 E 需要是可比较的类,因此需要 extends Comparable<…>(注意这里不要和继承的 extends 搞混了,不一样)
2.Comparable< ? super E> 要对 E 进行比较,即 E 的消费者,所以需要用 super
3.而参数 List< ? extends E> 表示要操作的数据是 E 的子类的列表,指定上限,这样容器才够大
Java 中的泛型和 C++ 中的模板有一个很大的不同:
在 Java 中,泛型是 Java 编译器的概念,用泛型编写的 Java 程序和普通的 Java 程序基本相同,只是多了一些参数化的类型同时少了一些类型转换。
实际上泛型程序也是首先被转化成一般的、不带泛型的 Java 程序后再进行处理的,编译器自动完成了从 Generic Java 到普通 Java 的翻译,Java 虚拟机运行时对泛型基本一无所知。
当编译器对带有泛型的java代码进行编译时,它会去执行类型检查和类型推断,然后生成普通的不带泛型的字节码,这种普通的字节码可以被一般的 Java 虚拟机接收并执行,这在就叫做 类型擦除(type erasure)。
实际上无论你是否使用泛型,集合框架中存放对象的数据类型都是 Object,这一点不仅仅从源码中可以看到,通过反射也可以看到。
List strings = new ArrayList<>();
List integers = new ArrayList<>();
System.out.println(Strings.getClass()==integers.getClass());//true
上面代码输出结果并不是预期的false,而是true。其原因就是泛型的擦除。
一直有个疑问,Java 编译器在编译期间擦除了泛型的信息,那运行中怎么保证添加、取出的类型就是擦除前声明的呢?
Java 编辑器会将泛型代码中的类型完全擦除,使其变成原始类型。当然,这时的代码类型和我们想要的还有距离,接着 Java 编译器会在这些代码中加入类型转换,将原始类型转换成想要的类型。这些操作都是编译器后台进行,可以保证类型安全。总之泛型就是一个语法糖,它运行时没有存储任何类型信息。
擦除导致的泛型不可变性
泛型中没有逻辑上的父子关系,如 List 并不是 List 的父类。两者擦除之后都是List,所以形如下面的代码,编译器会报错:
/*
两者并不是方法的重载,擦除之后就是同一方法,所以编译不会通过。
擦除之后:
void m(List numbers){}
void m(List Strings){} //编译不通过,已经存在形同方法签名
*/
void method(List
泛型的这种情况称为 不可变性,与之对应的概念是 协变、逆变:
Java 中数组是协变的,泛型是不可变的。
擦除的拯救者:边界
我们知道,泛型运行时被擦除成原始类型,这使得很多操作无法进行.
如果没有指明边界,类型参数将被擦除为 Object。
如果我们想要让参数保留一个边界,可以给参数设置一个边界,泛型参数将会被擦除到它的第一个边界(边界可以有多个),这样即使运行时擦除后也会有范围。
比如:
public class GenericErasure {
interface Game{
void play();
}
interface Program{
void code();
}
public static calss People{
private T mPeople;
public People(T people){
mPeople = people;
}
public void habit(){
mPeople.code();
mPeople.play();
}
}
}
上述代码中, People 的类型参数 T 有两个边界,编译器事实上会把类型参数替换为它的第一个边界的类型。
泛型的使用场景
当类中要操作的引用数据类型不确定的时候,过去使用 Object 来完成扩展,JDK 1.5后推荐使用泛型来完成扩展,同时保证安全性。
1.上面说到使用 Object 来达到复用,会失去泛型在安全性和直观表达性上的优势,那为什么 ArrayList 等源码中的还能看到使用 Object 作为类型?
泛型出现时,Java 平台即将进入它的第二个十年,在此之前已经存在了大量没有使用泛型的 Java 代码。人们认为让这些代码全部保持合法,并且能够与使用泛型的新代码互用,非常重要。
这样都是为了兼容,新代码里要使用泛型而不是原始类型。
2.泛型是通过擦除来实现的。因此泛型只在编译时强化它的类型信息,而在运行时丢弃(或者擦除)它的元素类型信息。擦除使得使用泛型的代码可以和没有使用泛型的代码随意互用。
3.如果类型参数在方法声明中只出现一次,可以用通配符代替它。
private void swap(List list, int i, int j){
//....
}
只出现了一次 类型参数,没有必要声明,完全可以用通配符代替:
private void swap(List list, int i, int j){
//...
}
对比一下,第二种更加简单清晰吧。
4.数组中不能使用泛型
Array 事实上并不支持泛型,这也是为什么 Joshua Bloch 在 《Effective Java》一书中建议使用 List 来代替 Array,因为 List 可以提供编译期的类型安全保证,而 Array 却不能。
5.Java 中 List
静态资源不认识泛型
接上一个话题,如果把
private static T ifThenElse(boolean b, T first, T second){
return b ? first : second;
}
报错,T未定义。但是如果我们再把static去掉:
public class TestMain{
public static void main(String[] args){}
@SuppressWarnings("unused")
private List ifThenElse(boolean b,T first, T second){
return null;
}
}
这并不会有任何问题。两相对比下,可以看出static方法并不认识泛型,所以我们要加上一个
public class TestMain{
private List notStaticList;
private static List staticList;
}
这证明了,static变量也不认识泛型,其实不仅仅是staic方法、static变量、static块,也不认识泛型,可以自己试一下。总结起来就是一句话:静态资源不认识泛型。