explain this output about Object reference casting?

Question

interface I {
}
class A {
}
class B {
}
public class Test {
    public static void main(String args[]) {
        A a = null;
        B b = (B)a; // error: inconvertible types

        I i = null;
        B b1 = (B)i;
    }
}

i know why a can not be cast to B, because of B is not inherit from A.
my question is about, why B b1 = (B)i; is allowed since B is not implements from I ?
and why B b1 = (B)i; this line will not force a runtime exception since i is null?

Answer 1

The compiler doesn't know everything about your class hierarchy. As far as it's concerned, there could be class B2 extends B implements I, in which case the above cast would need to work.

Answer 2

it is a Narrowing Reference Conversion.. according to java spec $5.1.5 following is allowed.

From any interface type J to any non-parameterized class type C that is not final.

this conversion will not show any compile time error but will be checked at run time. it would throw a ClassCastException according to $5.5.3 if the interface was initialized with a proper class which is not related to B. but it is not throwing now as the interface is null and as we know

A value of the null type (the null reference is the only such value) may be assigned to any reference type, resulting in a null reference of that type.

N.B. .. i was not acknowledged about all the above terms... I just feel interest to search after seeing the question. so please correct me if my finding is wrong or i misunderstood anything

Answer 3

When the compiler comes across B b = (B)a; it knows without doubt that a is type A and it does not legally cast to a B.

However, when the compiler is compiling B b1 = (B)i; it only knows that i is an object that implements I - it could be:

class C extends B implements I {
}

and so the cast to B could be legal so it cannot treat it as an error.

This is really just a re-statement of Jaffrey's answer with a little more narrative.

Answer 4

Consider:

interface I { }
class A { }
class B { }
class A2 extends A implements I { }
class B2 extends B implements I { }

void castToB(I i) {
    B b1 = (B)i;  // (HERE)
}

void foo() {
    A2 a2 = new A2();
    castToB(a2);  // legal, since a2 implements I, but the cast to B will throw an
                  // exception at runtime
    B2 b2 = new B2();
    castToB(b2);  // legal, since b2 implements I; the cast to B now succeeds, since
                  // a B2 is a B
}

This shows why the cast in the line marked HERE must be legal, because there are scenarios in which it can succeed. Java would flag the cast as an error only if there's absolutely no possible way it could succeed.

Answer 5

I believe the other answers are missing one important detail: it is possible because the compiler simply doesn't bother looking into interfaces.

The arguments that are supposed to explain this have been phrased as

there could be class B2 extends B implements I

and

The compiler knows here that A and B are not related

These are very true, but it doesn't explain why the compiler knows that these two classes aren't related and not why it can't know if an interface has been implemented.

In the end, these two situations should be rather similar: if it can check at compile time if two classes have a relation, then it should be able to check at compile time if an interface is implemented in that class since both of these situations have their information available at compile time.

Therefore I agree with the comment of Hot Licks in the duplicate:

Because. Even though Cat may not directly implement Furniture, some superclass of Cat may. And the compiler chooses to not dig into such ugly details, since the rules for interfaces are pretty convoluted. (Thank you, Sun.) And there is no general rule requiring the compiler to detect an inevitable runtime exception (such as divide by zero) -- it's more of a "service" it provides.

Checking the interface at compile time should be possible, it's just not done by the compiler for reasons that we can only guess at. that are discussed in the comments.

After an extensive (and very interesting) discussion in the comments below, I believe this has been cleared up.

It is easy and cheap to check if two classes have a relationship, you just look at both their hierarchies. Interfaces on the other hand, require you to have knowledge about all classes and interfaces in the project (including external resources like libraries) in order to determine if there is a relationship between the interface and the class.

This leads me to the conclusion that while it is theoretically possible, it's just not feasible because it would require two things:

1. Recompiling your source code and all included libraries.
2. Very expensive checks that have to go through the hierarchies of each class.

Answer 6

Here is some good information on Upcasting and Down casting. http://forum.codecall.net/topic/50451-upcasting-downcasting/

Because every Class inherits from Object you can always Upcast to Object and Downcast to some other Type (B)(Object)a. Not that this is a good idea but it is valid. If you had actually instantiated A you would get a runtime exception java.lang.ClassCastException the same as if you instantiated and instance of I i = new I(){}

interface I {
}
class A {
}
class B {
}
class Test {
    public static void main(String args[]) {
        A a = null;
        B b = (B)(Object)a;

        I i = null;
        B b1 = (B)i;
    }
}