date: 2016-09-04 23:00
status: public
tags:[Thinking In Java]
title: 'Thinking In Java 第15章 泛型'
本文发表于KuTear's Blog,转载请注明
元组
public class TwoTuple<A,B> {
public final A first;
public final B second;
public TwoTuple(A a, B b){first = a; second = b;}
}
泛型接口
public interface Generator<T>{
T next();
}
泛型方法
public <T> void function(T i){ //将泛型参数列表置于返回类型之前
}
泛型类
public class Generator<T>{
private T mVar;
public void set(T var){
this.mVar = var;
}
public T get(){
return mVar;
}
}
擦除
java中泛型擦除的原因
假设某个应用程序具有两个类库 X/Y，并且 Y 还要使用类库 Z。随着 Java SE5的出现，这个应用程序和这些类库的创建者最终可能希望迁移到泛型上。但是，迁移是个大工程，不能为了迁移而迁移。所以，为了实现迁移兼容性，每个类库和应用程序都必须与其他所有的部分是否使用了泛型无关。这样，它们不能拥有探测其他类库是否使用了泛型的能信。因此，某个特定的类库使用了泛型这样的证据必须被“擦除”。试想，如果没有某种类型的迁移途径，所有已经构建了很长时间的类库就需要与希望迁移到 Java 泛型的开发者们说再见了。正因为类库对于编程语言极其重要，所以这不是一种可以接受的代价。擦除是否是最佳的或者唯一的迁移途径，还需要时间来检验。
在泛型代码内部，无法获得任何有关泛型参数类型的信息。
Java泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此List< String >和List< Integer >在运行时事实上是相同的类型。
List<Integer> intList = new ArrayList<>();
List<String> stringList = new ArrayList<>();
System.out.println(intList.getClass() == stringList.getClass()); //true
既然泛型类的内部持有类型被抹掉，那么为什么我们在调用Generator#get()的时候还能够得到它所持有的具体类型呢？下面就看看是如何实现的。
擦除的补偿
Java泛型在instanceof、创建类型实例，创建数组、转型时都会有问题。有时必须通过引入类型标签（即你的类型的Class对象）进行补偿。使用动态的isInstance()方法，而不是instanceof。
public class _15_GenericHolder<T> {
private T obj;
public void set(T obj) {
this.obj = obj;
}
public T get() {
return obj;
}
public static void main(String[] args) {
_15_GenericHolder<String> holder = new _15_GenericHolder<String>();
holder.set("Item");
// 这里没有转型了，但是我们知道传递给 set()的值在编译期还是会接受检查
String s = holder.get();
}
}
// 反编译：
public class Chapter15._15_GenericHolder<T> {
public Chapter15._15_GenericHolder();
Code:
0: aload_0
1: invokespecial #12 // Method java/lang/Object."<init>":()V
4: return
public void set(T);
Code:
0: aload_0
1: aload_1
2: putfield #23 // Field obj:Ljava/lang/Object;
5: return
public T get();
Code:
0: aload_0
1: getfield #23 // Field obj:Ljava/lang/Object;
4: areturn
public static void main(java.lang.String[]);
Code:
0: new #1 // class Chapter15/_15_GenericHolder
3: dup
4: invokespecial #30 // Method "<init>":()V
7: astore_1
8: aload_1
9: ldc #31 // String Item
11: invokevirtual #33 // Method set:(Ljava/lang/Object;)V
14: aload_1
15: invokevirtual #35 // Method get:()Ljava/lang/Object;
18: checkcast #37 // class java/lang/String
21: astore_2
22: return
}
上面的代码中可以在main的18行看见，有一次类型的强转，这是通过编译器实现的，也就是说当我们编译的时候代码其实就已经对它指定了返回类型，而不是在运行时判断返回类型。
我们知道，实际的持有对象已经向上转型成为Object,也就是说我们的泛型只能使用Object的方法，而不能获取到真正的持有类的方法，于是，擦除边界就诞生了。
public class Base{
public void func(){
System.out.println(“This is Base”)；
}
}
public class Holder<T extends Base>{
T mVar;
public void set(T var){
this.mVar = var;
}
public func(){
this.mVar.func();
}
}
通过这样，我们的持有类型其实就由原本的Object变为了Base,这样我们就可以调用Base中的方法。同时还可以extends多个接口。
interface Animal{
public void speek();
}
interface Fish{
public void bubble();
}
class GoldenFish implements Animal, Fish{
@Override
public void bubble() {
System.out.println("O。.");
}
@Override
public void speek() {
System.out.println("wow~");
}
}
class HoldItem<T>{
T item;
HoldItem(T item){ this.item = item; }
T getItem() { return item; }
}
class Item1<T extends Animal & Fish> extends HoldItem<T>{
Item1(T item){ super(item); }
public void doSomething(){
item.speek();
item.bubble();
}
}
这里的Item的持有对象必须是Animal和Fish。
为了在泛型类中能够判断类型，可以引入类型标签.
class ClassTypeCapture<T> {
Class<T> kind;
public ClassTypeCapture(Class<T> kind){
this.kind = kind;
}
public boolean f(Object arg){
return kind.isInstance(arg);
}
public static void main(String[] args){
ClassTypeCapture<String> ctc = new ClassTypeCapture<String>(String.class);
System.out.println(ctc.f("art")); // true
System.out.println(ctc.f(1)); // false
}
}
泛型数组
public class ArrayItem<T>{};
public class Demo{
private ArrayItem<Integer> array;
public Demo(int size){
//this.array = (ArrayItem<Integer>[])new Object[size];//运行时错误：ClassCastException
this.array = (ArrayItem<Integer>[])new ArrayItem[size];
}
}
成功创建泛型数组的唯一方式就是创建一个被擦除类型的新数组，然后对其转型。
