Java泛型进阶

最新推荐文章于 2024-05-03 21:17:45 发布

Carmelo_Z

最新推荐文章于 2024-05-03 21:17:45 发布

阅读量358

点赞数

分类专栏： Java编程思想

Java编程思想专栏收录该内容

5 篇文章 0 订阅

订阅专栏

原文链接

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

“在泛型代码内部，无法获得任何有关泛型参数类型的信息”，这并不是说使用泛型代码时给定的类型参数会消失（要不然泛型就没有存在的意义了，外部将T定为比如String类型后，之后的T就被定为String类型了），而是说我们只知道这是个泛型类型，可以代表多种类型，即我们不能通过T访问与某种特定类有关的方法，属性等（当然，有泛型边界的是个例外）。

2.关于擦除：擦除：List<T>被擦除为List，T被擦除为Object

//这个例子表明编译过程中并没有根据参数生成新的类型
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>在运行时的确是同一种类型。

//例子, 这个例子表明类的参数类型跟传进去的类型没有关系，泛型参数只是`占位符`
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]
*/

我们在运行期试图获取一个已经声明的类的类型参数，发现这些参数依旧是‘形参’，并没有随声明改变。也就是说在运行期，我们是拿不到已经声明的类型的任何信息。（只是被擦除，让你编写代码时不知道泛型T是什么，但编写完了后使用这个泛型类或泛型方法时一旦将T具体化了后，就能知道了）

只要涉及到List<T>，不管是编写泛型类，还是使用泛型类都会被擦除，所以看下面的图：List<Shape>被擦除为List，尽管知道这是Shape类型，但是就能用s.draw（不能知道详细类型信息）（加个泛型边界可以解决这个错误，因为加了后就是被擦除为泛型边界而不是Object）

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

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类型来使用。

// 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行有一处类型转换的逻辑。它是编译器自动帮我们加进去的。

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

3.擦除的缺陷

泛型类型不能显式地运用在运行时类型的操作当中，例如：转型、instanceof 和new。因为在运行时，所有参数的类型信息都丢失了。（例如下面的代码中，编译不通过是因为都规定了在编写泛型代码时不让你知道T的类型信息，你还想用instanceof T去判断，所以编译会报错）

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

4.擦除的补偿

①类型判断问题：

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关键字来做判断。所以我们使用类类型来构造一个类型判断器，判断一个实例是否为特定的类型。

②创建类型实例：

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

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

③创建泛型数组：

一般不建议创建泛型数组。尽量使用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方法创建实例的方式。