About casting

[Jack Lau]

Could anyone tell me why runtime error occur ?

 
interface I1 {}
interface I2 {}
class Base implements I1 {}
class Sub extends Base implements I2 {}
public class Orange {
  public static void main(String args[]) {
    Base base = new Base();
    I1 i1 = base;
    Sub sub = (Sub)base;   // Runtime error
  }
}

[Dan Chisholm]

The following code example demonstrates why a base class can not be cast to a sub class.

class Animal {
  void eat() {}
  void sleep() {}
}
class Dog extends Animal {
  void bark() {}
}
class A {
  public static void main(String[] args) {
    Animal a = new Animal();
    Dog eddy = (Dog)a; // Can not cast Animal to Dog.
    eddy.bark(); // There is no Animal.bark method
  }
}

A sub class is more specialized than a base class. Since the base class does not have the specialized behavior of the sub class it is not possible to cast an instance of a base class to a sub class type.

[Dan Chisholm]

It is important to remember that when you cast an instance of an object from one type to another the object instance is not modified in any way. Instead, the only thing that changes is the view of the object. For example, when a subclass such as Dog is cast to the base class, Pet, the view of the Dog instance is narrowed to a Pet base class view. A reference of type Pet can only access the members of the Dog subclass that are declared in the Pet base class.

class Pet {
  private String name;
  String name() {return name;}
  String eat() {return "eating";}
  String sleep() {return "sleeping";}
  Pet (String name) {this.name = name;}
}
class Dog extends Pet {
  void bark() {}
  Dog(String name) {super(name);}
}
class A {
  public static void main(String[] args) {
    Dog eddy = new Dog("eddy");
    Pet pet = (Pet)eddy;
    System.out.println("My name is " + pet.name());
    System.out.println(pet.eat());
    System.out.println(pet.sleep());
    // Even though the reference "pet" refers to an object
    // of type Dog, the Dog.bark method is not visible
    // using a reference of type "pet".
    System.out.println(pet.bark()); // Compiler error.
  }
}

Of course, the rules of member inheritance and hiding apply as demonstrated by the following code.

class A {
  String s1 = "A.s1";
  String m1() {return "A.m1";}
  static String m2() {return "A.m2";}
}
class B extends A {
  String s1 = "B.s1";
  String m1() {return "B.m1";}
  static String m2() {return "B.m2";}
}
class C {
  public static void main (String[] args) {
    B b = new B();
    A a = (A)b;
    System.out.print(a.s1 + "," + a.m1() + "," + a.m2());
  }
}

Prints: A.s1,B.m1,A.m2

[Barkat Mardhani]

In a line, upcast is legal but downcast is not...

[Jack Lau]

Thank you very much !!
All are very good and easy understanding examples for me.