时间戳

首页 > 解决方案 > 为什么Java中没有删除成员字段的这种通用类型信息？

java - 为什么Java中没有删除成员字段的这种通用类型信息？

问题描述

import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class Foo<T> {

    public List<Integer> aGenericList;
    
    public T item;
    
    public Foo() {
        aGenericList = new ArrayList<>();
    }

    public static void main(String[] args) throws NoSuchFieldException {
        Foo foo = new Foo<String>();
        System.out.println(foo.aGenericList.getClass());

        Field testField = Foo.class.getField("aGenericList");
        Type genericType1 = testField.getGenericType();
        System.out.println(genericType1.getTypeName());
    }
}

结果是：

class java.util.ArrayList
java.util.List<java.lang.Integer>

这意味着使用反射方法，可以获得擦除的类型信息。

现在我的问题是：

  1. 这种行为是在 JLS/JVMS 规范中正式定义的（如果是，在哪里？），还是由实现该语言的不同供应商决定？
  2. 是否可以将反射方法应用于局部变量foo以获得类似的东西Foo<java.lang.String>？

标签： javagenericstype-erasure

解决方案

你的问题

1. 这种行为是在 JLS/JVMS 规范中正式定义的（如果是，在哪里？），还是由实现该语言的不同供应商决定？

Java 语言规范似乎没有专门描述反射：

因此，本规范没有详细描述反射。

而是将反射的全部行为留给 API 记录（即在 Javadoc 中）。

但是，Java 虚拟机规范确实解释了通用信息必须由编译器发出：

4.7.9。Signature属性_

该Signature属性是 a 、 或 结构（§4.1、§4.5、§4.6）的属性表中的固定ClassFile长度field_info属性method_info。属性记录类Signature、接口、构造函数、方法或字段的签名（第 4.7.9.1 节），其在 Java 编程语言中的声明使用类型变量或参数化类型。有关这些结构的详细信息，请参阅Java 语言规范，Java SE 15 版。

[...]

4.7.9.1。签名

签名对用 Java 编程语言编写的声明进行编码，这些声明使用 Java 虚拟机类型系统之外的类型。它们支持反射和调试，以及只有class文件可用时的编译。

Java 编译器必须为其声明使用类型变量或参数化类型的任何类、接口、构造函数、方法或字段发出签名。具体来说，Java 编译器必须发出：

  • 任何类或接口声明的类签名，它要么是泛型的，要么具有作为超类或超接口的参数化类型，或两者兼而有之。

  • 任何方法或构造函数声明的方法签名，它要么是泛型的，要么具有类型变量或参数化类型作为返回类型或形式参数类型，或者在throws子句中具有类型变量，或其任意组合。

    如果throws方法或构造函数声明的子句不涉及类型变量，则编译器可能会将声明视为没有throws子句以发出方法签名。

  • 其类型使用类型变量或参数化类型的任何字段、形式参数或局部变量声明的字段签名。

[...]

2.是否可以将反射方法应用于局部变量foo以获得类似的东西Foo<java.lang.String>？

不，因为局部变量不可反射访问。至少不是直接由 Java 语言编写的。但是让我们说他们是。你有：

Foo foo = new Foo<String>();

反映的是左侧。那是一个原始类型，所以你只知道类型foo是Foo. 您将无法判断右侧创建的实例是用 参数化的String。

一些澄清（希望）

当我们说“泛型在运行时被擦除”时，我们并不是指在这种情况下。静态定义的反射可访问结构类型，例如字段，保存在字节码中。例如，以下内容：

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.List;

public class Main {

  private static List<? extends Number> list = new ArrayList<Integer>();

  public static void main(String[] args) throws Exception {
    Field field = Main.class.getDeclaredField("list");

    // Due to List being a generic type the returned Type is actually
    // an instance of java.lang.reflect.ParameterizedType
    Type genericType = field.getGenericType();
    System.out.println("Generic Type  = " + genericType);

    // The raw type can be gotten from the ParameterizedType. Here the
    // returned Type will actually be an instance of java.lang.Class
    Type rawType = ((ParameterizedType) genericType).getRawType();
    System.out.println("Raw Type      = " + rawType);

    // The ParameterizedType gives us access to the actual type
    // arguments declared. Also, since a bounded wildcard was used
    // the returned Type is actually an instance of
    // java.lang.reflect.WildcardType
    Type typeArgument = ((ParameterizedType) genericType).getActualTypeArguments()[0];
    System.out.println("Type Argument = " + typeArgument);

    // We know in this case that there is a single upper bound. Here
    // the returned Type will actually be an instance of java.lang.Class
    Type upperBound = ((WildcardType) typeArgument).getUpperBounds()[0];
    System.out.println("Upper Bound   = " + upperBound);
  }
}

将输出：

Generic Type  = java.util.List<? extends java.lang.Number>
Raw Type      = interface java.util.List
Type Argument = ? extends java.lang.Number
Upper Bound   = class java.lang.Number

所有这些信息都在源代码中。请注意，我们正在反思性地观察该list 领域。我们不是在查看由所述字段引用的实例（即运行时对象）。知道该字段的泛型类型实际上与知道该字段的名称没有什么不同list。

我们不知道的是ArrayList被参数化了Integer。将上述更改为：

import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.List;

public class Main {

  private static List<? extends Number> list = new ArrayList<Integer>();

  public static void main(String[] args) {
    Class<?> clazz = list.getClass();
    System.out.println("Class          = " + clazz);

    TypeVariable<?> typeParameter = clazz.getTypeParameters()[0];
    System.out.println("Type Parameter = " + typeParameter);
  }
}

输出：

Class          = class java.util.ArrayList
Type Parameter = E

我们可以看到我们知道引用的list实例是 的实例java.util.ArrayList。但是从那里我们可以确定的是ArrayList该类是泛型的并且具有单个类型参数E。我们无法确定该list字段是否被分配了ArrayList一个类型参数为 的Integer。换句话说，ArrayList实例本身不知道它被声明包含什么类型的元素——该信息已被删除。

换句话说，该list字段的类型在运行时是已知的，但ArrayList实例（即在运行时创建的对象）只知道它是一个ArrayList.

推荐阅读