Java 泛型进阶

擦除

在泛型代码内部，无法获得任何有关泛型参数类型的信息。

例子1：

//这个例子表明编译过程中并没有根据参数生成新的类型
public class Main2 {
    public static void main(String[] args) {
        Class c1 = new ArrayList<Integer>().getClass();
        Class c2 = new ArrayList<String>().getClass();
        System.out.print(c1 == c2);
    }
}
/* output
true
*/

在 List<String> 中添加 Integer 将不会通过编译，但是List<Sring>与List<Integer>在运行时的确是同一种类型。

例子2：

//例子, 这个例子表明类的参数类型跟传进去的类型没有关系，泛型参数只是`占位符`
public class Table {
}
public class Room {
}
public class House<Q> {
}
public class Particle<POSITION, MOMENTUM> {
}
public class Main {
    public static void main(String[] args) {
        List<Table> tableList = new ArrayList<Table>();
        Map<Room, Table> maps = new HashMap<Room, Table>();
        House<Room> house = new House<Room>();
        Particle<Long, Double> particle = new Particle<Long, Double>();
        System.out.println(Arrays.toString(tableList.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(maps.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(house.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(particle.getClass().getTypeParameters()));
    }
}
/** output
[E]
[K, V]
[Q]
[POSITION, MOMENTUM]
*/

我们在运行期试图获取一个已经声明的类的类型参数，发现这些参数依旧是‘形参’，并没有随声明改变。也就是说在运行期，我们是拿不到已经声明的类型的任何信息。

编译器会虽然在编译过程中移除参数的类型信息，但是会保证类或方法内部参数类型的一致性。

例子：

List<String> stringList=new ArrayList<String>();
//可以通过编译
stringList.add("wakaka");
//编译不通过
//stringList.add(new Integer(0));

//List.java
public interface List<E> extends Collection<E> {
//...
boolean add(E e);
//...
}

List的参数类型是E，add方法的参数类型也是E，他们在类的内部是一致的，所以添加Integer类型的对象到stringList违反了内部类型一致，不能通过编译。

重用 extends 关键字。通过它能给与参数类型添加一个边界。

泛型参数将会被擦除到它的第一个边界（边界可以有多个）。编译器事实上会把类型参数替换为它的第一个边界的类型。如果没有指明边界，那么类型参数将被擦除到Object。下面的例子中，可以把泛型参数T当作HasF类型来使用。

例子：

/** * Created by yxf on 16-5-28. */
// HasF.java
public interface HasF {
    void f();
}

//Manipulator.java
public class Manipulator<T extends HasF> {
    T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

extend关键字后后面的类型信息决定了泛型参数能保留的信息。

Java中擦除的基本原理

刚看到这里可能有些困惑，一个泛型类型没有保留具体声明的类型的信息，那它是怎么工作的呢？在把《Java编程思想》书中这里的边界与上文的边界区分开来之后，终于想通了。Java的泛型类的确只有一份字节码，但是在使用泛型类的时候编译器做了特殊的处理。

这里根据作者的思路，自己动手写了两个类SimpleHolder和GenericHolder，然后编译拿到两个类的字节码，直接贴在这里：

// SimpleHolder.java
public class SimpleHolder {
    private Object obj;
    public Object getObj() {
        return obj;
    }
    public void setObj(Object obj) {
        this.obj = obj;
    }
    public static void main(String[] args) {
        SimpleHolder holder = new SimpleHolder();
        holder.setObj("Item");
        String s = (String) holder.getObj();
    }
}
// SimpleHolder.class
public class SimpleHolder {
  public SimpleHolder();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        

  public java.lang.Object getObj();
    Code:
       0: aload_0       
       1: getfield      #2                  // Field obj:Ljava/lang/Object;
       4: areturn       

  public void setObj(java.lang.Object);
    Code:
       0: aload_0       
       1: aload_1       
       2: putfield      #2                  // Field obj:Ljava/lang/Object;
       5: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class SimpleHolder
       3: dup           
       4: invokespecial #4                  // Method "<init>":()V
       7: astore_1      
       8: aload_1       
       9: ldc           #5                  // String Item
      11: invokevirtual #6                  // Method setObj:(Ljava/lang/Object;)V
      14: aload_1       
      15: invokevirtual #7                  // Method getObj:()Ljava/lang/Object;
      18: checkcast     #8                  // class java/lang/String
      21: astore_2      
      22: return        
}

//GenericHolder.java
public class GenericHolder<T> {
    T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
    public static void main(String[] args) {
        GenericHolder<String> holder = new GenericHolder<>();
        holder.setObj("Item");
        String s = holder.getObj();
    }
}

//GenericHolder.class
public class GenericHolder<T> {
  T obj;

  public GenericHolder();
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return        

  public T getObj();
    Code:
       0: aload_0       
       1: getfield      #2                  // Field obj:Ljava/lang/Object;
       4: areturn       

  public void setObj(T);
    Code:
       0: aload_0       
       1: aload_1       
       2: putfield      #2                  // Field obj:Ljava/lang/Object;
       5: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class GenericHolder
       3: dup           
       4: invokespecial #4                  // Method "<init>":()V
       7: astore_1      
       8: aload_1       
       9: ldc           #5                  // String Item
      11: invokevirtual #6                  // Method setObj:(Ljava/lang/Object;)V
      14: aload_1       
      15: invokevirtual #7                  // Method getObj:()Ljava/lang/Object;
      18: checkcast     #8                  // class java/lang/String
      21: astore_2      
      22: return        
}

经过一番比较之后，发现两分源码虽然不同，但是对应的字节码逻辑部分确是完全相同的。

在编译过程中，类型变量的信息是能拿到的。所以，set方法在编译器可以做类型检查，非法类型不能通过编译。但是对于get方法，由于擦除机制，运行时的实际引用类型为Object类型。为了‘还原’返回结果的类型，编译器在get之后添加了类型转换。所以，在GenericHolder.class文件main方法主体第18行有一处类型转换的逻辑。它是编译器自动帮我们加进去的。

所以在泛型类对象读取和写入的位置为我们做了处理，为代码添加约束。

擦除的缺陷

泛型类型不能显式地运用在运行时类型的操作当中，例如：转型、instanceof 和 new。因为在运行时，所有参数的类型信息都丢失了。

public class Erased<T> {
    private final int SIZE = 100;
    public static void f(Object arg) {
        //编译不通过
        if (arg instanceof T) {
        }
        //编译不通过
        T var = new T();
        //编译不通过
        T[] array = new T[SIZE];
        //编译不通过
        T[] array = (T) new Object[SIZE];
    }
}

擦除的补偿

1. 类型判断问题

例子：

class Building {}
class House extends Building {}
public 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<Building> ctt1 = new ClassTypeCapture<Building>(Building.class);
        System.out.println(ctt1.f(new Building()));
        System.out.println(ctt1.f(new House()));
        ClassTypeCapture<House> ctt2 = new ClassTypeCapture<House>(House.class);
        System.out.println(ctt2.f(new Building()));
        System.out.print(ctt2.f(new House()));
    }
}
//output
//true
//true
//false
//true

泛型参数的类型无法用instanceof关键字来做判断。所以我们使用类类型来构造一个类型判断器，判断一个实例是否为特定的类型。

2. 创建类型实例

Erased.java中不能new T()的原因有两个，一是因为擦除，不能确定类型；而是无法确定T是否包含无参构造函数。

为了避免这两个问题，我们使用显式的工厂模式：

例子：

interface IFactory<T> {
    T create();
}

class Foo2<T> {
    private T x;

    public <F extends IFactory<T>> Foo2(F factory) {
        x = factory.create();
    }
}

class IntegerFactory implements IFactory<Integer> {
    @Override
    public Integer create() {
        return new Integer(0);
    }
}

class Widget {
    public static class Factory implements IFactory<Widget> {
        @Override
        public Widget create() {
            return new Widget();
        }
    }
}

public class FactoryConstraint {
    public static void main(String[] args) {
        new Foo2<Integer>(new IntegerFactory());
        new Foo2<Widget>(new Widget.Factory());
    }
}

通过特定的工厂类实现特定的类型能够解决实例化类型参数的需求。

3. 创建泛型数组

一般不建议创建泛型数组。尽量使用ArrayList来代替泛型数组。但是在这里还是给出一种创建泛型数组的方法。

public class GenericArrayWithTypeToken<T> {
    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArrayWithTypeToken(Class<T> type, int sz) {
        array = (T[]) Array.newInstance(type, sz);
    }

    public void put(int index, T item) {
        array[index] = item;
    }

    public T[] rep() {
        return array;
    }

    public static void main(String[] args) {
        GenericArrayWithTypeToken<Integer> gai = new GenericArrayWithTypeToken<Integer>(Integer.class, 10);
        Integer[] ia = gai.rep();
    }
}

这里我们使用的还是传参数类型，利用类型的newInstance方法创建实例的方式。

边界

这里Java重用了 extend关键字。边界可以将类型参数的范围限制到一个子集当中。

interface HasColor {
    Color getColor();
}

class Colored<T extends HasColor> {
    T item;

    public Colored(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public Color color() {
        return item.getColor();
    }
}

class Dimension {
    public int x, y, z;
}

class ColoredDemension<T extends HasColor & Dimension> {
    T item;

    public ColoredDemension(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    Color color() {
        return item.getColor();
    }

    int getX() {
        return item.x;
    }

    int getY() {
        return item.y;
    }

    int getZ() {
        return item.z;
    }

}

interface Weight {
    int weight();
}

class Solid<T extends Dimension & HasColor & Weight> {
    T item;

    public Solid(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    Color color() {
        return item.getColor();
    }

    int getX() {
        return item.x;
    }

    int getY() {
        return item.y;
    }

    int getZ() {
        return item.z;
    }

    int weight() {
        return item.weight();
    }
}

class Bounded extends Dimension implements HasColor, Weight {
    @Override
    public Color getColor() {
        return null;
    }

    @Override
    public int weight() {
        return 0;
    }
}

public class BasicBound {
    public static void main(String[] args) {
        Solid<Bounded> solid = new Solid<Bounded>(new Bounded());
        solid.color();
        solid.weight();
        solid.getZ();
    }
}

extends关键字声明中，有两个要注意的地方：

  1. 类必须要写在接口之前；
  2. 只能设置一个类做边界，其它均为接口。

通配符

协变：

public class Holder<T> {
    private T value;

    public Holder(T apple) {
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object o) {
        return value != null && value.equals(o);
    }

    public static void main(String[] args) {
        Holder<Apple> appleHolder = new Holder<Apple>(new Apple());
        Apple d = new Apple();
        appleHolder.setValue(d);

        // 不能自动协变
        // Holder<Fruit> fruitHolder=appleHolder;

        // 借助 ？ 通配符和 extends 关键字可以实现协变
        Holder<? extends Fruit> fruitHolder = appleHolder;

        // 返回一个Fruit，因为添加边界之后返回的对象是 ? extends Fruit,
        // 可以把它转型为Apple，但是在不知道具体类型的时候存在风险
        d = (Apple) fruitHolder.getValue();

        //Fruit以及Fruit的父类，就不需要转型
        Fruit fruit = fruitHolder.getValue();
        Object obj = fruitHolder.getValue();

        try {
            Orange c = (Orange) fruitHolder.getValue();
        } catch (Exception e) {
            System.out.print(e);
        }

        // 编译不通过，因为编译阶段根本不知道子类型到底是什么类型
        //        fruitHolder.setValue(new Apple());
        //        fruitHolder.setValue(new Orange());

        //这里是可以的因为equals方法接受的是Object作为参数，并不是 ? extends Fruit
        System.out.print(fruitHolder.equals(d));
    }
}

在Java中父类型可以持有子类型。如果一个父类的容器可以持有子类的容器，那么我们就可以称为发生了协变。在java中，数组是自带协变的，但是泛型的容器没有自带协变。我们可以根据利用边界和通配符?来实现近似的协变。

Holder<? extends Fruit>就是一种协变的写法。它表示一个列表，列表持有的类型是Fruit或其子类。

这个Holder<? extends Fruit>运行时持有的类型是未知的，我们只知道它一定是Fruit的子类。正因为如此，所以我们无法向这个holder中放入任何类型的对象，Object类型的对象也不可以。但是，调用它的返回方法却是可以的。因为边界明确定义了它是Fruit类型的子类。

逆变：

package wildcard;

import java.util.ArrayList;
import java.util.List;

public class GenericWriting {
    static <T> void writeExact(List<T> list, T item) {
        list.add(item);
    }

    static List<Apple> apples = new ArrayList<Apple>();
    static List<Fruit> fruits = new ArrayList<Fruit>();

    static void f1() {
        writeExact(apples, new Apple());
        //this cannot be compile,said in Thinking in Java
        writeExact(fruits, new Apple());
    }

    static <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item);
    }

    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruits, new Apple());
    }

    static <T> readWithWildcard(List<? super T> list, int index) {
        //Compile Error, required T but found Object
        return list.get(index);
    }
    public static void main(String[] args) {
        f1();
        f2();
    }
}

如果一个类的父类型容器可以持有该类的子类型的容器，我们称这种关系为逆变。声明方式List<? super Integer>, List<? super T> list。

不能给泛型参数给出一个超类型边界；即不能声明List<T super MyClass>。

上面的例子中，writeExact(fruits,new Apple());在《Java编程思想》中说是不能通过编译的，但我试了一下，在Java1.6，Java1.7中是可以编译的。不知道是不是编译器比1.5版本升级了。

由于给出了参数类型的‘下界’，所以我们可以在列表中添加数据而不会出现类型错误。但是使用get方法获取返回类型的时候要注意，由于声明的类型区间是Object到T具有继承关系的类。所以返回的类型为了确保没有问题，都是以Object类型返回回来的。比如过例子中list.get(index)的返回类型就是Object。

无界通配符

无界通配符<?> 意味着可以使用任何对象，因此使用它类似于使用原生类型。但它是有作用的，原生类型可以持有任何类型，而无界通配符修饰的容器持有的是某种具体的类型。举个例子，在List<?>类型的引用中，不能向其中添加Object, 而List类型的引用就可以添加Object类型的变量。

一些需要注意的问题

1. 任何基本类型都不能作为类型参数

2. 实现参数化接口

例子：

interface Payable<T>{}
class Employee implements Payable<Employee> {}
//Compile Error
class Hourly extends Employee implements Payable<Hourly> {}

因为擦除的原因，Payable<Employee> 与 Payable<Hourly>简化为相同的Payable<Object>，例子中的代码意味着重复两次实现相同的接口。但他们的参数类型却是不相同的。

3. 转型和警告

使用带有泛型类型参数的转型或者instanceof不会有任何效果。因为他们在运行时都会被擦除到上边界上。所以转型的时候用的类型实际上是上边解对应的类型。

4. 重载

//Compile Error. 编译不能通过
public class UseList<W,T>{
    void f(List<T> v){}
    void f(List<W> v){}
}

由于擦除的原因，重载方法将产生相同的类型签名。避免这种问题的方法就是换个方法名。

5. 基类劫持接口

例子：

public class ComparablePet implements Comparable<ComparablePet>{
    public int compareTo(ComparablePet arg) {return 0;}
}
class Cat extends ComparablePet implements Comparable<Cat>{
    // Error: Comparable connot be inherited with
    // different arguments: <Cat> and <ComparablePet>
    public int compareTo(Cat arg);
}

父类中我们为Comparable确定了ComparablePet参数，那么其它任何类型都不能再与ComparablePet之外的对象再比较。子类中不能对同一个接口用不同的参数实现两次。这有点类似于第四点中的重载。
但是我们可以在子类中覆写父类中的方法。

关于泛型问题就先了解这么多，有什么不对的地方还请大家指正。也欢迎小伙伴们一起交流。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 201,924评论 5赞 474
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 84,781评论 2赞 378
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 148,813评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,264评论 1赞 272
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,273评论 5赞 363
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,383评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,800评论 3赞 393
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,482评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,673评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,497评论 2赞 318
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,545评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,240评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,802评论 3赞 304
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,866评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,101评论 1赞 258
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,673评论 2赞 348
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,245评论 2赞 341

推荐阅读更多精彩内容

  • Java泛型
    开发人员在使用泛型的时候，很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List作为形式参数，那么如果尝试...
    时待吾阅读 1,038评论 0赞 3
  • Java梳理之理解泛型
    在之前的文章中分析过了多态，可以知道多态本身是一种泛化机制，它通过基类或者接口来设计，使程序拥有一定的灵活性，但是...
    _小二_阅读 676评论 0赞 0
  • Java泛型的学习和使用
    前面，由于对泛型擦除的思考，引出了对Java-Type体系的学习。本篇，就让我们继续对“泛型”进行研究： JDK1...
    贾博岩阅读 5,129评论 3赞 28
  • Effective Java 2.0_Java中的泛型_Item 1知识点
    文章作者：Tyan博客：noahsnail.com 1. 什么是泛型 Java泛型（Generics）是JDK 5...
    SnailTyan阅读 769评论 0赞 3
  • 不远万里来见你
    刚才洗完脸照镜子，突然发现自己眼角有褶子了。定了定睛，发现是看错了。 石站长也说我长得着急，我笑笑。如果可以，我也...
    sorry_TheWorld阅读 767评论 0赞 0