运行程序时出错，但编译时不出错

Question

Why isn't there an error at line marked with //1 when you compile the program, but there is one when you run it. I am new to Java so I try to better understand how classes work.

class A{
private int x;
}

class B extends A{
private int a;
void exec(){
    System.out.println("test");
}

static void function(A a){
    ((B)a).exec();//1
}

public static void main(String argv[]){
    B.function(new A());
    B.function(new B());
}
}

Answer 1

You say you get an error runnning the application, I am guessing the error in this case is ClassCastException as A is not a B

Note this is a Runtime Exception :

see: https://docs.oracle.com/javase/7/docs/api/java/lang/ClassCastException.html

Read more about Checked and UnChecked Exceptions here :

https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html

http://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/

Answer 2

The problem is that every B is an A (since B extends A ), but the converse is not true: not every A is a B . Therefore, sometimes, you may be able to cast an A to a B as you did in your code above. The compiler can however identify issues when there is a clear casting violation. For example, consider the case of trying to cast a BufferedReader to an Integer : Since Integer is not in the class hierarchy of BufferedReader , the cast will fail with the error:

Cannot cast from Stage to Integer

The reason you receive an exception only at runtime is that a ClassCastException is a RuntimeException . Any exception that extends RuntimeException is not checked at compile time. From the JavaDoc for Exception :

The class Exception and any subclasses that are not also subclasses of RuntimeException are checked exceptions. Checked exceptions need to be declared in a method or constructor's throws clause if they can be thrown by the execution of the method or constructor and propagate outside the method or constructor boundary.

Answer 3

Basically, Java allows you to cast a reference type to another reference type if it is possible that the cast will succeed, ie it's possible that it won't throw a ClassCastException . It can't guarantee that it will succeed, of course, because as you've seen, a reference to an A could be referring to a B object, but it might not be a B object.

Section 5.5.1 of the JLS elaborates on what causes the compiler error if both the original reference type (S) and the casting type (T) are class types:

Given a compile-time reference type S (source) and a compile-time reference type T (target), a casting conversion exists from S to T if no compile-time errors occur due to the following rules.

If S is a class type:

• If T is a class type, then either |S| <: |T|, or |T| <: |S|. Otherwise, a compile-time error occurs.

(The notation <: in the JLS means "is a subtype of".)

Because B is a subtype of A , your cast of a A to a B is legal, because it is possible for it to succeed. By contrast, casting to an unrelated type, eg String , will generate a compiler error; that cast cannot succeed.