Thinking In Java 第15章 泛型

---

date: 2016-09-04 23:00
status: public
tags:[Thinking In Java]
title: 'Thinking In Java 第15章 泛型'

---

本文发表于KuTear's Blog,转载请注明

元组

public class TwoTuple {
    public final A first;
    public final B second;
    public TwoTuple(A a, B b){first = a; second = b;}
}

泛型接口

public interface Generator{
    T next();
}

泛型方法

public  void function(T i){ //将泛型参数列表置于返回类型之前
} 

泛型类

public class Generator{
    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 intList = new ArrayList<>();
List stringList = new ArrayList<>();
System.out.println(intList.getClass() == stringList.getClass()); //true

既然泛型类的内部持有类型被抹掉，那么为什么我们在调用Generator#get()的时候还能够得到它所持有的具体类型呢？下面就看看是如何实现的。

擦除的补偿

Java泛型在instanceof、创建类型实例，创建数组、转型时都会有问题。有时必须通过引入类型标签（即你的类型的Class对象）进行补偿。使用动态的isInstance()方法，而不是instanceof。

public class _15_GenericHolder {
    private T obj;

    public void set(T obj) {
        this.obj = obj;
    }

    public T get() {
        return obj;
    }

    public static void main(String[] args) {
        _15_GenericHolder holder = new _15_GenericHolder();
        holder.set("Item");
        // 这里没有转型了，但是我们知道传递给 set()的值在编译期还是会接受检查
        String s = holder.get();
    }
}

// 反编译：
public class Chapter15._15_GenericHolder {
  public Chapter15._15_GenericHolder();
    Code:
       0: aload_0
       1: invokespecial #12                 // Method java/lang/Object."":()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 "":()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 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 item;
    HoldItem(T item){ this.item = item; }
    T getItem() { return item; }
}
class Item1 extends HoldItem{
    Item1(T item){ super(item); }
    public void doSomething(){
        item.speek();
        item.bubble();
    }
}

这里的Item的持有对象必须是Animal和Fish。
为了在泛型类中能够判断类型，可以引入类型标签.

class ClassTypeCapture {
    Class kind;
    public ClassTypeCapture(Class kind){
        this.kind = kind;
    }
    public boolean f(Object arg){
        return kind.isInstance(arg);
    }
    public static void main(String[] args){
        ClassTypeCapture ctc = new ClassTypeCapture(String.class);
        System.out.println(ctc.f("art")); // true
        System.out.println(ctc.f(1));  // false
    }
}

泛型数组

public class ArrayItem{};
public class Demo{
  private ArrayItem array;
  public Demo(int size){
    //this.array = (ArrayItem[])new Object[size];//运行时错误：ClassCastException
    this.array = (ArrayItem[])new ArrayItem[size];
  }
}

成功创建泛型数组的唯一方式就是创建一个被擦除类型的新数组，然后对其转型。

参考

• Java编程思想笔记四