什么是原始类型，为什么我们不应该使用它? [英] What is a raw type and why shouldn't we use it?

问题描述

• Java 中的原始类型是什么?为什么我经常听说它们不应在新代码中使用?
• 如果我们不能使用原始类型，有什么替代方法，如何更好?

推荐答案

什么是原始类型?

Java 语言规范定义了一个原始类型，如下所示:

原始类型定义为以下之一:

A raw type is defined to be one of:

• 引用类型是通过采用没有伴随类型参数列表的泛型类型声明的名称形成的.

• The reference type that is formed by taking the name of a generic type declaration without an accompanying type argument list.

元素类型为原始类型的数组类型.

An array type whose element type is a raw type.

原始类型 R 的非 static 成员类型，它不是从 R 的超类或超接口继承的.

A non-static member type of a raw type R that is not inherited from a superclass or superinterface of R.

这里有一个例子来说明:

Here's an example to illustrate:

public class MyType<E> {
    class Inner { }
    static class Nested { }
    
    public static void main(String[] args) {
        MyType mt;          // warning: MyType is a raw type
        MyType.Inner inn;   // warning: MyType.Inner is a raw type

        MyType.Nested nest; // no warning: not parameterized type
        MyType<Object> mt1; // no warning: type parameter given
        MyType<?> mt2;      // no warning: type parameter given (wildcard OK!)
    }
}

这里，MyType 是一个参数化类型(JLS 4.5).通常将这种类型简单地简称为 MyType，但技术上的名称是 MyType.

Here, MyType<E> is a parameterized type (JLS 4.5). It is common to colloquially refer to this type as simply MyType for short, but technically the name is MyType<E>.

mt 有一个原始类型(并生成编译警告)在上述定义中的第一个要点；inn 也有第三个要点的原始类型.

mt has a raw type (and generates a compilation warning) by the first bullet point in the above definition; inn also has a raw type by the third bullet point.

MyType.Nested 不是参数化类型，即使它是参数化类型 MyType 的成员类型，因为它是 static>.

MyType.Nested is not a parameterized type, even though it's a member type of a parameterized type MyType<E>, because it's static.

mt1 和 mt2 都是用实际类型参数声明的，所以它们不是原始类型.

mt1, and mt2 are both declared with actual type parameters, so they're not raw types.

本质上，原始类型的行为就像它们在引入泛型之前一样.也就是说，以下内容在编译时是完全合法的.

Essentially, raw types behaves just like they were before generics were introduced. That is, the following is entirely legal at compile-time.

List names = new ArrayList(); // warning: raw type!
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // not a compilation error!

上面的代码运行得很好，但假设您还有以下代码:

The above code runs just fine, but suppose you also have the following:

for (Object o : names) {
    String name = (String) o;
    System.out.println(name);
} // throws ClassCastException!
  //    java.lang.Boolean cannot be cast to java.lang.String

现在我们在运行时遇到了麻烦，因为 names 包含的东西不是 instanceof String.

Now we run into trouble at run-time, because names contains something that isn't an instanceof String.

大概，如果您希望 names 只包含 String，您可以也许仍然使用原始类型并手动检查每个 add 自己，然后手动转换到String names 中的每一项.更好，不过不是使用原始类型，而是让编译器为您完成所有工作，利用 Java 泛型的强大功能.

Presumably, if you want names to contain only String, you could perhaps still use a raw type and manually check every add yourself, and then manually cast to String every item from names. Even better, though is NOT to use a raw type and let the compiler do all the work for you, harnessing the power of Java generics.

List<String> names = new ArrayList<String>();
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // compilation error!

当然，如果您DO希望names允许Boolean，那么您可以将其声明为List