Why does the JVM allow be to pass a B[] to a method that expects an A[]?

Question

I have the following generic test class:

public class BrokenGenerics<T> {

    private T[] genericTypeArray;

    public BrokenGenerics(T... initArray) {
        genericTypeArray = initArray;
    }

    public void setArray(T[] newArray) {
        genericTypeArray = newArray;
    }

    public T get(int idx) {
        return genericTypeArray[idx];
    }

    public Class getType() {
        return genericTypeArray.getClass().getComponentType();
    }



    public static boolean breakThis(BrokenGenerics any) {
        any.setArray(new B[]{new B(2)});
        return false;
    }

    public static void main(String[] args) {
        BrokenGenerics<A> aBreaker = new BrokenGenerics<A>(new A("1"));
        System.out.println(aBreaker.get(0));
        System.out.println(aBreaker.getType());
        breakThis(aBreaker);
        System.out.println(aBreaker.get(0));
        System.out.println(aBreaker.getType());
    }

    private static class A {

        public String val;

        public A(String init) {
            val = init;
        }

        @Override
        public String toString() {
            return "A value: " + val;
        }
    }

    private static class B {

        public int val;

        public B(int init) {
            val = init;
        }

        @Override
        public String toString() {
            return "B value: " + val;
        }
    }
}

When I run it, I get this output, and no errors:

A value: 1
class BrokenGenerics$A
B value: 2
class BrokenGenerics$B

Now, I understand why this compiles; it can't know at compile-time that breakThis is being passed a generic of a bad type. However, once it runs the line any.setArray(new B[]{new B(2)});, shouldn't it throw a ClassCastException (NOTE THAT IT DOES NOT! Try it yourself!) because I'm trying to pass a B[] to a method that expects an A[]? And after that, why does it allow me to get() back the B?

Answer 1

After Type Erasure, T will be turned into Object since you didn't specify a bound on T. So, there is no problem at runtime assigning any type of array to genericTypeArray, which is now of type Object[] or calling the function setArray(...), which now also accepts an argument of type Object[]. Also, your get(...) method will simply return an Object.

Trouble starts when you access elements in the array with a wrong type expectation, since this might lead to (implicit or explicit) illegal type casts, for example by assigning the value returned by get(...) to a variable of type A.

You can also get a run-time ClassCastException if you try to type-cast the array itself, but, in my experience, that is a case that tends to come up less often, although it can be very obscure to find or even understand if it does happen. You can find some examples below.

All generics-checking happens only at compile-time. And if you use raw types, these checks can not be performed rigorously, and thus the best the compiler can do is to issue a warning to let you know that you are giving up an opportunity for more meaningful checks by omitting the type argument.

Eclipse with its standard settings (and probably the java compiler with the correct flags) shows these warnings for your code:

• "Class is a raw type" where you define getType() (somewhat unrelated to your question)
• "BrokenGenerics is a raw type" where you define breakThis(...)
• "Type safety: The method setArray(Object[]) belongs to the raw type BrokenGenerics" where you call setArray(...) inside breakThis(...).

Examples for causing ClassCastException due to illegal type-cast of the array:

You can get ClassCastExceptions at runtime if you expose the array to the outside world (which can often be a dangerous thing to do, so I try to avoid it) by adding the following to BrokenGenerics<T>:

public T[] getArray() {
    return genericTypeArray;
}

If you then change your main method to:

BrokenGenerics<A> aBreaker = new BrokenGenerics<A>(new A("1"));
A[] array = aBreaker.getArray();
System.out.println(array[0]);
System.out.println(aBreaker.getType());
breakThis(aBreaker);
array = aBreaker.getArray(); // ClassCastException here!
System.out.println(array[0]);
System.out.println(aBreaker.getType());

You get the ClassCastException at runtime at the indicated position due to a cast of the array itself rather than one of its elements.

The same thing can also happen if you set the variable genericTypeArray to protected and use it from code that subclasses your generic class with a fixed type argument:

private static class C extends BrokenGenerics<A> {

    public C(A... initArray) {
        super(initArray);
    }

    public void printFirst() {
        A[] result = genericTypeArray; // ClassCastException here!
        System.out.println(result[0]);
    }
}

To trigger the exception, add the following to you main method:

C cBreaker = new C(new A("1"));
cBreaker.printFirst();
breakThis(cBreaker);
cBreaker.printFirst();

Imagine this case coming up in a bigger project... How on earth would you even begin to understand how that line of code could possible fail?!? :) Especially since the stack trace might be of very little help trying to find the breakThis(...) call that is actually responsible for the error.

For more in-depth example cases, you can take a look at some tests I did a little while back.

Answer 2

shouldn't it throw a ClassCastException because I'm trying to pass a B[] to a method that expects an A[]?

No. As this post explains, your invocation of setArray in

public static boolean breakThis(BrokenGenerics any) {
    any.setArray(new B[]{new B(2)});
    return false;
}

is done on a reference expression of the raw type BrokenGenerics. When interacting with raw types, all corresponding generic parameters are erased. So setArray is actually expecting a Object[]. A B[] is a Object[].

why does it allow me to get() back the B?

Assuming you're asking about this

System.out.println(aBreaker.get(0));

PrintStream#println(Object) expects an Object, not an A. As such, there is no reason for the compiler to insert a cast here. Since there is no cast, there is no ClassCastException.

If you had instead done

A a = aBreaker.get(0);

or had a method like

void println(A a) {}
...
println(aBreaker.get(0));

then these would cause ClassCastException. In other words, the compiler will insert a cast (checkcast) anywhere a type needs to be converted from a generic type parameter. That was not the case with PrintStream#println.

Similarly,

System.out.println(aBreaker.getType());

doesn't even involve the generic parameter declared in BrokenGenerics

public Class getType() {...}

and also returns a value of the raw type Class. The compiler has no reason to add a checkcast to A.