Java编程思想读书笔记——泛型(二)

最新推荐文章于 2018-01-28 22:11:06 发布

mzm1991

最新推荐文章于 2018-01-28 22:11:06 发布

阅读量327

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/baidu_21088863/article/details/78633286

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

15.7 擦除的神秘之处

泛型的类型与类型参数无关。

package com.mzm.chapter15;

import java.util.ArrayList;

/**
 * 泛型的类型不受类型参数的影响
 * 
 */
public class ErasedTypeEquivalence {

    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2);
    }
}

Class类的getTypeParameters()也无法获取类型参数。

package com.mzm.chapter15;

import java.util.*;

/**
 * Class类的getTypeParameters()方法也只是得到类型参数的占位符，无法获取类型参数
 * 
 */
public class LostInformation {

    public static void main(String[] args) {
        List<Frob> list = new ArrayList<>();
        Map<Frob, Fnorkle> map = new HashMap<>();
        Quark<Fnorkle> quark = new Quark<>();
        Particle<Long, Double> p = new Particle<>();
        System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
    }
}

class Frob {

}

class Fnorkle {

}

class Quark<Q> {

}

class Particle<POSITION, MOMENTUM> {

}

在泛型代码内部无法获取任何有关泛型参数类型的信息。
Java泛型是通过擦除来实现的，即当使用泛型时，任何具体的类型信息都被擦除了。

15.7.1 C++的方式

package com.mzm.chapter15;

/**
 * 
 */
public class Manipulation {

    public static void main(String[] args) {
        HasF hf = new HasF();
        Manipulator<HasF> manipulator = new Manipulator<>(hf);
        manipulator.manipulate();
    }
}

class Manipulator<T> {

    private T obj;

    public Manipulator(T x) {
        this.obj = x;
    }

    public void manipulate() {
        //由于类型擦除的存在，JVM不能确定T类型一定有f()方法。
        //obj.f();
    }
}

这一代码的C++版本是能通过编译的。

当指定泛型类的边界时，该代码能通过编译。

package com.mzm.chapter15;


/**
 * 
 */
public class Manipulator2<T extends HasF> {

    private T obj;

    public Manipulator2(T x) {
        this.obj = x;
    }

    public void manipulate() {
        //指定边界后，能通过编译
        obj.f();
    }
}

但这代码其实没什么意义，因为可以直接使用组合来实现。

package com.mzm.chapter15;

/**
 * 
 */
public class Manipulator3 {

    private HasF obj;

    public Manipulator3(HasF x) {
        obj = x;
    }

    public void manipulate() {
        obj.f();
    }
}

只有当希望代码能跨多个类工作时，使用泛型才有所帮助。

15.7.2 迁移兼容性

Java泛型采用擦除来实现的目的，就是为了兼容Java SE5之前的类库。

15.7.3 擦除的问题

擦除的代价是显著的。泛型不能用于显式地引用运行时类型的操作中。如

class Foo<T> {
    T var;
}

在创建Foo的实例时，

Foo<Cat> f = new Foo<Cat>();

Foo类中的代码应该作用于Cat上，但是实际上是Object上。

使用泛型并不是强制的。

15.7.4 边界处的动作

擦除在方法或类内部移除了有关实际类型的信息，但是编译器仍旧可以确保在方法或类中使用的类型的内部一致性。
非泛型代码

package com.mzm.chapter15;

/**
 * 
 */
public class SimpleHolder {

    private Object obj;

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

    public Object get() {
        return obj;
    }

    public static void main(String[] args) {
        SimpleHolder holder = new SimpleHolder();
        holder.set("Item");
        String s = (String) holder.get();
    }
}

泛型代码：

package com.mzm.chapter15;

/**
 * 
 */
public class GenericHolder<T> {

    private T obj;

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

    public T get() {
        return obj;
    }

    public static void main(String[] args) {
        GenericHolder<String> holder = new GenericHolder<>();
        holder.set("Item");
        String s = holder.get();
    }
}

两者产生的字节码是相同的，这可以从反编译这两个类看出。并且在泛型代码中，在get()方法处，编译器自动为我们插入了转型的操作。
非泛型版本：

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

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

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

  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 set:(Ljava/lang/Object;)V
      14: aload_1
      15: invokevirtual #7                  // Method get:()Ljava/lang/Object;
      18: checkcast     #8                  // class java/lang/String
      21: astore_2
      22: return
}

泛型版本

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

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

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

  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 set:(Ljava/lang/Object;)V
      14: aload_1
      15: invokevirtual #7                  // Method get:()Ljava/lang/Object;
      18: checkcast     #8                  // class java/lang/String
      21: astore_2
      22: return
}

15.8 擦除的补偿

因为在Java中泛型是通过擦除实现的，如果需要在泛型类内部获取泛型参数的类型信息，则可以通过类型标签来解决，即Class对象。

package com.mzm.chapter15;

/**
 * 利用类型标签，可以获取被擦除的类型信息
 * 
 */
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.class);
        System.out.println(ctt1.f(new Building()));
        System.out.println(ctt1.f(new House()));

        ClassTypeCapture<House> ctt2 = new ClassTypeCapture<>(House.class);
        System.out.println(ctt2.f(new Building()));
        System.out.println(ctt2.f(new House()));
    }
}

class Building {

}

class House extends Building {

}

15.8.1 创建类型实例

通过泛型类内置的Class对象，可以通过Class对象的newInstance()方法，来创建类型参数的对应类型的对象。但是却要求类型参数对应的类必须具有默认构造器，若无默认构造器则会创建失败。

package com.mzm.chapter15;

/**
 * 
 */
public class InstantiateGenericType {

    public static void main(String[] args) {
        ClassAsFactory<Employee> fe = new ClassAsFactory<>(Employee.class);
        System.out.println("ClassAsFactory<Employee> succeeded");
        //Integer类没有默认构造器，所以不能使用Class对象的newInstance()方法lauren创建对象。
        try {
            ClassAsFactory<Integer> fi = new ClassAsFactory<>(Integer.class);
        } catch (Exception e) {
            System.out.println("ClassAsFactory<Integer> failed");
        }
    }
}

class ClassAsFactory<T> {

    T x;

    public ClassAsFactory(Class<T> kind) {
        try {
            x = kind.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

class Employee {

}

这时，只能使用显式的工厂对象，并限制其类型。

package com.mzm.chapter15;


/**
 * 
 */
public class FactoryConstraint {

    public static void main(String[] args) {
        //创建显式的工厂
        new Foo2<Integer>(new IntegerFactory());
        new Foo2<Widget>(new Widget.Factory());
    }
}

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

class Foo2<T> {

    private T x;

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

class IntegerFactory implements FactoryI<Integer> {

    @Override
    public Integer create() {
        return new Integer(10);
    }
}

class Widget {

    public static class Factory implements FactoryI<Widget> {

        @Override
        public Widget create() {
            return new Widget();
        }
    }
}

另外还可以使用模板设计模式。

package com.mzm.chapter15;

/**
 * 
 */
public class CreatorWithGeneric {

    public static void main(String[] args) {
        Creator c = new Creator();
        c.f();
    }
}

/**
 * 抽象泛型类
 * @param <T>
 */
abstract class GenericWithCreate<T> {
    //类型参数对应类的对象
    final T element;

    GenericWithCreate() {
        element = create();
    }

    /**
     * 构建类型参数对应类的对应，由子类实现
     * @return
     */
    abstract T create();
}

class X {

}

/**
 * 该子类继承抽象泛型类，必须明确指定类型参数
 */
class Creator extends GenericWithCreate<X> {

    @Override
    X create() {
        return new X();
    }

    void f() {
        System.out.println(element.getClass().getSimpleName());
    }
}

15.8.2 泛型数组

创建泛型数组的唯一正确方式是，创建一个被擦除类型的新数组，然后转型。

package com.mzm.chapter15;

/**
 * 
 */
public class ArrayOfGeneric {

    static final int SIZE = 100;
    //声明引用可以，直接创建不行
    static Generic<Integer>[] gia;

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        //gia = (Generic<Integer>[]) new Object[SIZE];

        //创建泛型数组的正确方式是创建一个被擦除类型的新数组，然后对其转型。
        gia = (Generic<Integer>[]) new Generic[SIZE];
        System.out.println(gia.getClass().getSimpleName());
        gia[0] = new Generic<Integer>();
        //gia[1] = new Object();
        //gia[2] = new Generic<Double>();
    }
}

泛型类内部定义类型参数相关的数组，该数组在实际运行时是Object[]。

package com.mzm.chapter15;

/**
 * 
 */
public class GenericArray<T> {

    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArray(int sz) {
        //因为擦除，不能直接new T[sz]
        //只能先创建Object[]，然后再转型
        array = (T[]) new Object[sz];
    }

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

    public T get(int index) {
        return array[index];
    }

    /**
     * 实际运行时，因为擦除，其返回的类型是Object[]
     * @return
     */
    public T[] rep() {
        return array;
    }

    public static void main(String[] args) {
        GenericArray<Integer> gai = new GenericArray<>(10);
        //因为实际运行的是Object[]，所以无法使用Integer[]的引用来捕获。
        //Integer[] ia = gai.rep();
        Object[] oa = gai.rep();
    }
}

要确切地表示运行时的数组类型就是类型参数对应的数组类型，可以将类型标记引入

package com.mzm.chapter15;

import java.lang.reflect.Array;

/**
 * 
 */
public class GenericArrayWithTypeToken<T> {

    private T[] array;

    /**
     * 在引入类型标签后，类型信息实际上在擦除之后得到恢复，此时运行的数组不再是Object[]
     * 而是T[]
     * @param type 类型标签
     * @param sz
     */
    @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 get(int index) {
        return array[index];
    }

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

    public static void main(String[] args) {
        GenericArrayWithTypeToken<Integer> gai = new GenericArrayWithTypeToken<>(Integer.class, 10);
        //此时实际运行的就是Integer[]
        Integer[] ia = gai.rep();
    }
}

15.9 边界

使用边界的一个重要的效果就是可以按照自己的边界类型来调用方法，进而在一定程度抵消擦除带来的不便。
Java通过重用extends关键字来实现边界。

package com.mzm.chapter15;

import java.awt.*;

/**
 * 
 */
public class BasicBounds {

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

interface HasColor {
    Color getColor();
}

/**
 * 一个边界
 * @param <T>
 */
class Colored<T extends HasColor> {

    T item;

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

    T getItem() {
        return item;
    }

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

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


/**
 * 两个边界
 * @param <T>
 */
class ColoredDimension<T extends Dimension & HasColor> {

    T item;

    ColoredDimension(T item) {
        this.item = item;
    }

    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();
}

/**
 * 三个边界
 * @param <T>
 */
class Solid<T extends Dimension & HasColor & Weight> {

    T item;

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

    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;
    }
}

上述代码可以使用继承来简化

package com.mzm.chapter15;

import java.awt.*;

/**
 * 在继承的每个层次上添加边界限制
 * 
 */
public class InheritBounds {

    public static void main(String[] args) {
        Solid2<Bounded> solid2 = new Solid2<>(new Bounded());
        solid2.color();
        solid2.getY();
        solid2.weight();
    }
}

class HoldItem<T> {

    T item;

    HoldItem(T item) {
        this.item = item;
    }

    T getItem() {
        return item;
    }
}

class Colored2<T extends HasColor> extends HoldItem<T> {

    Colored2(T item) {
        super(item);
    }

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

class ColoredDimension2<T extends Dimension & HasColor> extends Colored2<T> {

    ColoredDimension2(T item) {
        super(item);
    }

    int getX() {
        return item.x;
    }

    int getY() {
        return item.y;
    }

    int getZ() {
        return item.z;
    }

}

class Solid2<T extends Dimension & HasColor & Weight> extends ColoredDimension<T> {

    Solid2(T item) {
        super(item);
    }

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

15.10 通配符

数组的协变性：

package com.mzm.chapter15;

/**
 * 数组具有协变性
 * 
 */
public class CovariantArrays {

    public static void main(String[] args) {

        Fruit[] fruits = new Apple[10];
        fruits[0] = new Apple();
        fruits[1] = new Jonathan();
        //fruits的运行时类型是Apple，即便它被向上转型成为Fruit
        try {
            //但是由于fruits是Fruit数组的引用，当然可以放置Fruit对象
            fruits[0] = new Fruit();
        } catch (Exception e) {
            System.out.println(e);
        }

        try {
            fruits[0] = new Orange();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

class Fruit {

}

class Apple extends Fruit {

}

class Jonathan extends Apple {

}

class Orange extends Fruit {

}

相较之下，泛型则不具备协变性：

package com.mzm.chapter15;

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

/**
 * 泛型不具备协变性
 * 
 */
public class NonCovariantGenerics {

    public static void main(String[] args) {
        //Apple的List不等价于Fruit的List
        //关注的应该是容器的类型，而非容器持有的类型
        //泛型中没有协变类型
        //List<Fruit> flist = new ArrayList<Apple>();
    }
}

通配符可以允许在泛型中，在两个类型之间建立某种类型的向上转型关系。

package com.mzm.chapter15;

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

/**
 * 通配符
 * 
 */
public class GenericsAndCovariance {

    public static void main(String[] args) {
        //List<? extends Fruit>表示，具有任何从Fruit继承类型的List
        //这并不意味着该List将持有任何类型的Fruit
        //但是被赋值的List（=右边）必须持有List或者其子类的某种指定类型。
        List<? extends Fruit> flist = new ArrayList<Apple>();

        //一旦执行了这个向上转型，将无法向该List添加对象
        //flist.add(new Apple());
        //flist.add(new Fruit());
        //flist.add(new Object());
        flist.add(null);

        //但从flist中取出的对象至少是Fruit类型
        Fruit f = flist.get(0);
    }
}

15.10.1 编译器有多聪明

package com.mzm.chapter15;

import java.util.Arrays;
import java.util.List;

/**
 * 
 */
public class CompilerIntelligence {

    public static void main(String[] args) {
        List<? extends Fruit> flist = Arrays.asList(new Apple());

        Apple a = (Apple) flist.get(0);

        //这两个方法能编译的原因是这两个方法的参数类型是Object类型
        flist.contains(new Apple());
        flist.indexOf(new Apple());
    }
}

当指定一个ArrayList

15.10.2 逆变

超类型通配符：

package com.mzm.chapter15;

import java.util.List;

/**
 * 
 */
public class SuperTypeWildcards {

    /**
     * 超类型通配符的存在使得List可以放置Apple及其子类对象
     * @param apples
     */
    static void writeTo(List<? super Apple> apples) {
        apples.add(new Apple());
        apples.add(new Jonathan());

        //apples.add(new Fruit());
    }
}

15.10.3 无界通配符

无界通配符

package com.mzm.chapter15;

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

/**
 * 
 */
public class UnboundedWildcards1 {

    static List list1;
    static List<?> list2;
    static List<? extends Object> list3;

    static void assign1(List list) {
        list1 = list;
        list2 = list;
        list3 = list;
    }

    static void assign2(List<?> list) {
        list1 = list;
        list2 = list;
        list3 = list;
    }

    static void assign3(List<? extends Object> list) {
        list1 = list;
        list2 = list;
        list3 = list;
    }

    public static void main(String[] args) {
        assign1(new ArrayList());
        assign2(new ArrayList());
        //出现警告
        //assign3(new ArrayList());

        assign1(new ArrayList<String>());
        assign2(new ArrayList<String>());
        assign3(new ArrayList<String>());

        //List<?>可接收泛型和非泛型
        List<?> wildList = new ArrayList();
        wildList = new ArrayList<String>();

        assign1(wildList);
        assign2(wildList);
        assign3(wildList);
    }
}

但是List

15.10.4 捕获转换

向一个使用

package com.mzm.chapter15;

/**
 * 捕获转换
 * 
 */
public class CaptureConversion {

    static <T> void f1(Holder<T> holder) {
        T t = holder.get();
        System.out.println(t.getClass().getSimpleName());
    }

    /**
     * 参数类型在f2()被捕获，之后在f1()的调用中使用
     * @param holder
     */
    static void f2(Holder<?> holder) {
        f1(holder);
    }

    public static void main(String[] args) {
        Holder raw = new Holder<Integer>(1);
        //产生警告，原生类型应用于具体泛型
        //f1(raw);
        //无警告
        f2(raw);

        Holder rawBasic = new Holder();
        //产生警告，原生类型应用于具体泛型
        rawBasic.set(new Object());
        f2(rawBasic);

        Holder<?> wildcarded = new Holder<Double>(1.0);
        f2(wildcarded);
    }
}

mzm1991

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java编程思想读书笔记——泛型(二)

15.7 擦除的神秘之处泛型的类型与类型参数无关。package com.mzm.chapter15;import java.util.ArrayList;/** * 泛型的类型不受类型参数的影响 * */public class ErasedTypeEquivalence { public static void main(String[] args) {
复制链接

扫一扫