Java泛型绑定中的原始类型

Question

Are raw types allowed in generics bounds? What is their exact meaning?

class Foo<T>{}
class Bar<T extends Foo>{}

instead of writing

class Bar<U, T extends Foo<U>> {}

the second version is less convenient at the use site; can be the first considered somehow equivalent, albeit different?

class Bar<T extends Foo<?>> {}

is this the type-safe version of the first case?

Answer 1

Using raw types instead of wildcarded types as type parameter bounds doesn't change the type arguments allowed for the class ( Bar<Foo> , Bar<Foo<?>> , Bar<Foo<String>> , etc.), but it does affect the use of the type parameter within the class. For example, using List as the bound:

class Bar1<T extends List<?>> {
    void m(T t) {
        t.add("abc"); // type error
        t.add(123); // type error
    }
}

class Bar2<T extends List> { // warning about raw List
    void m(T t) {
        t.add("abc"); // warning about raw List
        t.add(123); // warning about raw List
    }
}

Since the type argument E of List<E> is unknown in both cases, it isn't safe to add anything to the list, and the first class correctly raises compiler errors. However, using a raw type bound disables this type checking and treats the add(E) method as add(Object) , allowing anything. The problem becomes apparent when a List<Integer> is passed to the second class:

Bar2<List<Integer>> bar2 = new Bar2<>();
List<Integer> list = new ArrayList<>();
bar2.m(list);
System.out.println(list); // prints [abc, 123]
Integer i = list.get(0); // throws ClassCastException

The List<Integer> ends up with a String element, leading to a ClassCastException at runtime when it tries to set the String to an Integer . This is why raw types are dangerous.

Answer 2

Are raw types allowed in generics bounds? What is their exact meaning?

Yes, they are allowed in generics bounds. They mean exactly the same thing as raw types mean elsewhere.

To quote user John Feminella :

---

• List : A list with no type parameter. It is a list whose elements are of any type -- the elements may be of different types.
• List<?> : A list with an unbounded type parameter. Its elements are of a specific, but unknown, type; the elements must all be the same type.
• List<T extends E> : A list with a type parameter called T. The supplied type for T must be of a type that extends E, or it is not a valid type for the parameter.

---

The general purpose of generic types is to cause compile errors rather than ClassCastExceptions at runtime.

Here's a bunch of examples with comments. Let me know if you have questions.

class Foo<U> extends ArrayList<U> {}

---

class BarRaw<T extends Foo> {
    void doSomething(T t) {
        // all you know is that `t` extends ArrayList holding any kinds of Objects

        // raw types are dangerous because..
        // the types are only checked at runtime, rather than compile time.

        // warnings about raw types, but no compile error
        t.set(0, Integer.valueOf(1));
        t.set(1, "someString");

        Object obj0 = t.get(0); // obj0 is truly an `Integer`
        Object obj1 = t.get(1); // obj1 is truly a `String`

        // valid, casting a true `Integer` to a `Integer`
        Integer int0 = (Integer) t.get(0);

        // valid, but ClassCastException at runtime! Casting a true `String` to a `Integer`
        Integer int1 = (Integer) t.get(1);
    }
}

---

class BarParam1<U, T extends Foo<U>> {
    void doSomething(T t, U u) {
        // `t` extends ... `ArrayList<U>`, can only add elements of type `U`
        // and the elements you get are guaranteed to be of type `U`

        t.set(0, u); // valid
        t.set(1, new Object()); // compile err, can only set elements of type `U`
        t.set(1, (U) new Object()); // valid, but ClassCastException at runtime
        t.set(2, Integer.valueOf(0)); // compile err, can only set elements of type `U`

        U u0 = t.get(0); // valid
        Object obj0 = t.get(0); // valid, any Object can be an Object..

        Integer int0 = t.get(0); // compile err, can't convert from `U` to `Integer`
        Integer int1 = (Integer) t.get(0); // valid but DANGER

        if (obj0 instanceof Integer) {
            Integer int2 = (Integer) obj0; // valid and safe since you checked
        }
    }
}

---

class BarParam2<U extends Number, T extends Foo<U>> {
    void doSomething(T t, U u) {
        // `T` extends ... `ArrayList<U extends Number>`
        // can only add elements of type `U extends Number`
        // and the elements you get are guaranteed to be of type `U extends Number`

        t.set(0, u); // valid
        t.set(1, new Object()); // compile err, can only set elements of type `U` exactly
        t.set(1, (U) new Object()); // valid, but ClassCastException at runtime
        t.set(2, Integer.valueOf(0)); // compile err, can only set elements of type `U` exactly

        U u0 = t.get(0); // valid
        Object obj0 = t.get(0); // valid, any Object can be an Object..

        Integer int0 = t.get(0); // compile err, can't convert from `U` to `Integer`
        Number num0 = t.get(0); // valid, `U` is guaranteed to extend `Number`
        Integer int1 = (Integer) t.get(0); // valid but DANGER

        if (obj0 instanceof Integer) {
            Integer int2 = (Integer) obj0; // valid and safe since you checked
        }
    }
}

---

class BarWild1<U, T extends Foo<?>> {
    void doSomething(T t, Number u) {
        // all compile err, no idea what `?` is
        t.set(0, u);
        t.set(1, new Object());
        t.set(1, (String) new Object());

        String u0 = t.get(0); // compile err, no idea what `?` is other than some Object
        Object obj0 = t.get(0); // valid, `?` extends `Object` since all objects do.
    }
}

---

class BarWild2<T extends Foo<? extends Number>> {
    void doSomething(T t, Number u) {
        // `t` extends ... `ArrayList<? extends Number>`
        // can only add elements of type `? extends Number`
        // and the elements you get are guaranteed to be of type `? extends Number`

        // all compile err, no idea what exact type `?` is
        t.set(0, u);
        t.set(1, new Object());
        t.set(1, (Number) new Object());
        t.set(2, Integer.valueOf(0));

        Number num0 = t.get(0); // valid, we know that the elements extend `Number`
        Object obj0 = t.get(0); // valid, any Object can be an Object..

        Integer int0 = t.get(0); // compile err, all we know is that the elements extend `Number`
        Integer int1 = (Integer) t.get(0); // valid but DANGER

        if (obj0 instanceof Integer) {
            Integer int2 = (Integer) obj0; // valid and safe since you checked
        }
    }
}