Arbitrary casting between interfaces is allowed?

Question

hi,
i'm confused since i thought you could not do this
interface ITreePlanter {
     public void plantTree();
interface IMotorCycleRepairer {
     public void repairMotorCycle();
class foo {
     void bar() {
          ITreePlanter a = null;
          IMotorCycleRepairer b = (IMotorCycleRepairer) a;
          a = (ITreePlanter) b;
}but apparently you can!
changing the interfaces to abstract classes, or classes produces compilation errors. Anyone have any insights into why this is?
thanks,
asjf

Answer 1

JLS, 2nd ed, 5.5: The remaining cases involve conversion between reference types. The detailed rules
for compile-time correctness checking of a casting conversion of a value of compile-time
reference type S (source) to a compile-time reference type T (target) are as follows:
    * If S is a class type:
          o If T is a class type, then S and T must be related classes-that is, S and T must
            be the same class, or S a subclass of T, or T a subclass of S; otherwise a
            compile-time error occurs.
          o If T is an interface type:
                + If S is not a final class (�8.1.1), then the cast is always correct at compile
                  time (because even if S does not implement T, a subclass of S might).
                + If S is a final class (�8.1.1), then S must implement T, or a compile-time
                  error occurs.
          o If T is an array type, then S must be the class Object, or a compile-time error
            occurs.
    * If S is an interface type:
          o If T is an array type, then T must implement S, or a compile-time error occurs.
          o If T is a class type that is not final (�8.1.1), then the cast is always correct at
            compile time (because even if T does not implement S, a subclass of T might).
          o If T is an interface type and if T and S contain methods with the same signature
            (�8.4.2) but different return types, then a compile-time error occurs.
    * If S is an array type SC[], that is, an array of components of type SC:
          o If T is a class type, then if T is not Object, then a compile-time error occurs
            (because Object is the only class type to which arrays can be assigned).
          o If T is an interface type, then a compile-time error occurs unless T is the type
            java.io.Serializable or the type Cloneable, the only interfaces implemented by
            arrays.
          o If T is an array type TC[], that is, an array of components of type TC, then a
            compile-time error occurs unless one of the following is true:
                + TC and SC are the same primitive type.
                + TC and SC are reference types and type SC can be cast to TC by a
                  recursive application of these compile-time rules for casting. Your situation is that S and T are both interface types, so a compile-time error occurs only if T and S contain methods with the same signature but different return types.