在Java中向下倾斜

Java中允许向上转换,但是向下转换会产生编译错误.

可以通过添加强制转换来删除编译错误,但无论如何都会在运行时中断.

在这种情况下,为什么Java允许向下转换,如果它不能在运行时执行？
这个概念有什么实际用途吗？

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");
  }
}

Joachim Saue.. 288

如果在运行时有可能成功,则允许向下转换:

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

在某些情况下,这不会成功:

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

在其他人,它将工作:

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

当一个演员(例如最后一个)在运行时失败时,ClassCastException将抛出.

请注意,在编译时将禁止某些强制转换,因为它们永远不会成功:

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

---

Rolf Rander.. 16

使用您的示例,您可以:

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();
}

---

Rolf Rander.. 15

我相信这适用于所有静态类型的语言:

String s = "some string";
Object o = s; // ok
String x = o; // gives compile-time error, o is not neccessarily a string
String x = (String)o; // ok compile-time, but might give a runtime exception if o is not infact a String

类型转换有效地说:假设这是对类型的引用并使用它.现在,假设o 实际上是一个整数,假设这是一个没有意义的字符串并且会给出意想不到的结果,因此需要运行时检查和异常来通知运行时环境有问题.

在实际使用中,您可以编写一个更通用的类的代码,但如果您知道它是什么子类并且需要将其视为子类,则将其强制转换为子类.一个典型的例子是重写Object.equals().假设我们有一个Car类:

@Override
boolean equals(Object o) {
    if(!(o instanceof Car)) return false;
    Car other = (Car)o;
    // compare this to other and return
}

---

Rob Kennedy.. 5

我们都可以看到您提供的代码在运行时不起作用.这是因为我们知道,表达new A()可以永远是类型的对象B.

但这不是编译器看到它的方式.当编译器检查是否允许转换时,它只是看到:

variable_of_type_B = (B)expression_of_type_A;

正如其他人所证明的那样,这种演员表是完全合法的.右边的表达式可以很好地评估类型的对象B.编译器看到A并且B具有子类型关系,因此使用代码的"表达式"视图,强制转换可能有效.

当编译器确切知道expression_of_type_A实际具有哪种对象类型时,编译器不会考虑这种特殊情况.它只是看到静态类型,A并认为动态类型可以是A或任何后代A,包括B.

1> Joachim Saue..：

---

如果在运行时有可能成功,则允许向下转换:

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

在某些情况下,这不会成功:

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

在其他人,它将工作:

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

当一个演员(例如最后一个)在运行时失败时,ClassCastException将抛出.

请注意,在编译时将禁止某些强制转换,因为它们永远不会成功:

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

2> Rolf Rander..：

---

使用您的示例,您可以:

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();
}

3> Rolf Rander..：

---

我相信这适用于所有静态类型的语言:

String s = "some string";
Object o = s; // ok
String x = o; // gives compile-time error, o is not neccessarily a string
String x = (String)o; // ok compile-time, but might give a runtime exception if o is not infact a String

类型转换有效地说:假设这是对类型的引用并使用它.现在,假设o 实际上是一个整数,假设这是一个没有意义的字符串并且会给出意想不到的结果,因此需要运行时检查和异常来通知运行时环境有问题.

在实际使用中,您可以编写一个更通用的类的代码,但如果您知道它是什么子类并且需要将其视为子类,则将其强制转换为子类.一个典型的例子是重写Object.equals().假设我们有一个Car类:

@Override
boolean equals(Object o) {
    if(!(o instanceof Car)) return false;
    Car other = (Car)o;
    // compare this to other and return
}

4> Rob Kennedy..：

---

我们都可以看到您提供的代码在运行时不起作用.这是因为我们知道,表达new A()可以永远是类型的对象B.

但这不是编译器看到它的方式.当编译器检查是否允许转换时,它只是看到:

variable_of_type_B = (B)expression_of_type_A;

正如其他人所证明的那样,这种演员表是完全合法的.右边的表达式可以很好地评估类型的对象B.编译器看到A并且B具有子类型关系,因此使用代码的"表达式"视图,强制转换可能有效.

当编译器确切知道expression_of_type_A实际具有哪种对象类型时,编译器不会考虑这种特殊情况.它只是看到静态类型,A并认为动态类型可以是A或任何后代A,包括B.