概念术语解释：

type variable 类型变量：常用的 T、M、K、V 这些都是，用于代表某个类型，非具体的。

parameterized type 参数化类型：拥有具体类型参数的泛型，它用另外一个类型作为参数；如 List<Integer> 。

什么是 raw type ?

JLS（ Java Language Specification） 给出如下定义：

raw type 被定义为如下情况：

1. 带有泛型类型声明的名称而没有类型参数列表的类型，如 List
2. 元素类型是 raw type 类型的数组
3. raw type R 的非 static 成员类型，不继承于R 的父类或父接口。

下面是一些示例：

public class MyType<E> {
    class Inner { }
    static class Nested { }
    public static void main(String[] args) {
        MyType mt;          //符合定义①  MyType is a raw type， 
        MyType.Inner inn;   //符合定义③  MyType.Inner is a raw type
        MyType.Nested nest; //违反定义③  not parameterized type
        MyType<Object> mt1; //违反定义①  type parameter given
        MyType<?> mt2;      //违反定义①  type parameter given (wildcard OK!)
    }
}

泛型是 invariant

Object o = "someString"; // 正常!
Class<Object> klazz = String.class; // 编译错误!
// cannot convert from Class<String> to Class<Object>

依赖于你需要什么类型，你能够用有限界的通配符来代替上面的Object。

Class<? extends Number> klazz = Integer.class; // 编译通过!

甚至你还可以这样：

Class<List<String>> klazz =
   (Class<List<String>>) new ArrayList<String>().getClass();
// WARNING! Type safety: Unchecked cast from
//   Class<capture#1-of ? extends ArrayList> to Class<List<String>>

下面是一段来自 Java Tutorials on Generics 的解释, 很好的描述了：泛型类被所有它的调用者共享；

下面的代码片段打印什么结果？

List <String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());

你可能以为是 false 。实际打印 true , 因为所有的泛型实例有相同的运行时类型， 不管他们实际的类型参数是什么。

也就是说没有这种类， List<String>.class 、 List<Integer>.class ，只有 List.class 。

JLS 15.8.2 Class Literals 中也提到了：

类字面量是一个表达式，它由 class 、 interface 、 array 、或者 primitive type 、 void 后面跟着 .class 组成。

:::warning 注意 类型和 .class 之间不可以有泛型类型参数，此外， :::

如果出现下面的使用方式，将会产生编译错误： 类型名是类型变量（ type variable ）或者参数化类型( parameterized type )，抑或是元素类型是类型变量、参数化类型的数组。

也就是说，下面的也编译不通过

void <T> test() {
    Class<?> klazz = T.class; // 编译失败！
    //Demo<Integer>.class, List<T>.class , List<Integer>.class,
    //Demo<Integer>[].class, Demo<T>[].class 这些同样编译失败！
    // Illegal class literal for the type parameter T
}

因此，你不能在类字面量上使用泛型，那样没有意义。

raw type 和 用 <Object> 作为类型参数有什么区别？

下面说明引用自《Effective Java 2nd Edition》，不要在新代码中使用 raw type :

raw type List 和参数化类型 List<Object> 之前的区别是什么， 不严格的讲， 前者丢弃了泛型类型检查，而后者告诉编译器他能够持有任何类型的对象。你能够赋值 List<String> 到类型 List , 但是你无法赋值给 List<Object> . 泛型的子类型 规则中， List<String> 是 raw type List 的子类型，且不是 List<Object> 的子类型.

void appendNewObject(List<Object> list) {
   list.add(new Object());
}
void appendObject(List list) {
   list.add(new Object());
}
List<String> names = new ArrayList<String>();
appendNewObject(names); //❌ 编译错误
appendObject(names); //✅ 失去类型检查
List ss = new ArrayList<Integer>();
Integer i = ss.get(0); //❌ 编译错误 
Object o = ss.get(0); //✅ raw type 放入是没有类型检查，无法知道元素类型，只能取出 Object

由于前面提到的泛型是 invariant ,所以 List<String 和 List<Object> 不兼容，会产生编译错误。

:::info 总结起来就是，如果你用 raw type 如 List ,你将失去类型安全检查；但如果你用参数化类型，如 List<Object> ,或者更具体的如 List<Integer> ,则不会。

1. raw type 可以添加任何元素，只能取出Object 类型，可以引用任何参数化类型。