类型 List<Integer> 是编译时常量。当这种情况发生时，编译器将烘焙类型。

你的问题

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

java语言规范似乎没有具体描述反射：
因此，本说明书不详细描述反射。
但是，将反射的全部行为留给api（即javadoc）来记录。
但是，java虚拟机规范确实解释了编译器必须发出一般信息：

4.7.9. 签名属性

这个 Signature 属性是属性表中的固定长度属性 ClassFile , field_info ，或 method_info 结构(§4.1, §4.5, §4.6). 一 Signature 属性记录签名(§4.7.9.1）对于类、接口、构造函数、方法或字段，其在java编程语言中的声明使用类型变量或参数化类型。有关这些构造的详细信息，请参阅java语言规范JavaSE15版。
[...]

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 .