Downcasting in Java

Question

Upcasting is allowed in Java, however downcasting gives a compile error.

The compile error can be removed by adding a cast but would anyway break at the runtime.

In this case why Java allows downcasting if it cannot be executed at the runtime?
Is there any practical use for this concept?

public class demo {   public static void main(String a[]) {       B b = (B) new A(); // compiles with the cast,                           // but runtime exception - java.lang.ClassCastException   } }  class A {   public void draw() {     System.out.println("1");   }    public void draw1() {     System.out.println("2");   } }  class B extends A {   public void draw() {     System.out.println("3");   }   public void draw2() {     System.out.println("4");   } } 

Answer 1

Downcasting is allowed when there is a possibility that it succeeds at run time:

Object o = getSomeObject(), String s = (String) o; // this is allowed because o could reference a String 

In some cases this will not succeed:

Object o = new Object(); String s = (String) o; // this will fail at runtime, because o doesn't reference a String 

When a cast (such as this last one) fails at runtime a ClassCastException will be thrown.

In other cases it will work:

Object o = "a String"; String s = (String) o; // this will work, since o references a String 

Note that some casts will be disallowed at compile time, because they will never succeed at all:

Integer i = getSomeInteger(); String s = (String) i; // the compiler will not allow this, since i can never reference a String. 

Answer 2

Using your example, you could do:

public void doit(A a) {     if(a instanceof B) {         // needs to cast to B to access draw2 which isn't present in A         // note that this is probably not a good OO-design, but that would         // be out-of-scope for this discussion :)         ((B)a).draw2();     }     a.draw(); }