[英]Downcasting in 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");
}
}
当有可能在运行时成功时,向下转换是允许的:
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
当强制转换(例如最后一个)在运行时失败时,将抛出ClassCastException
。
在其他情况下,它会起作用:
Object o = "a String";
String s = (String) o; // this will work, since o references a String
请注意,在编译时将不允许某些强制转换,因为它们根本不会成功:
Integer i = getSomeInteger();
String s = (String) i; // the compiler will not allow this, since i can never reference a String.
使用您的示例,您可以执行以下操作:
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();
}
我相信这适用于所有静态类型语言:
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
}
我们都可以看到您提供的代码在运行时不起作用。 那是因为我们知道表达式new A()
永远不可能是B
类型的对象。
但这不是编译器的看法。 当编译器检查是否允许强制转换时,它只会看到:
variable_of_type_B = (B)expression_of_type_A;
正如其他人所证明的那样,这种类型的演员是完全合法的。 右边的表达式可以很好地评估为类型B
的对象。 编译器看到A
和B
具有子类型关系,因此使用代码的“表达式”视图,转换可能会起作用。
当编译器确切地知道expression_of_type_A
将真正具有什么对象类型时,它不会考虑特殊情况。 它只是看到静态类型为A
,并认为动态类型可以是A
或任何后代A
,包括B
。
在这种情况下,如果 Java 不能在运行时执行,为什么它允许向下转换?
我相信这是因为编译器无法在编译时知道转换是否成功。 对于您的示例,很容易看出强制转换将失败,但在其他情况下则不太清楚。
例如,假设类型 B、C 和 D 都扩展了类型 A,然后方法public A getSomeA()
根据随机生成的数字返回 B、C 或 D 的实例。 编译器无法知道此方法将返回哪种确切的运行时类型,因此如果稍后将结果转换为B
,则无法知道转换是否成功(或失败)。 因此编译器必须假设强制转换会成功。
当我们处理向上转换的对象时,向下转换有效。 上行:
int intValue = 10;
Object objValue = (Object) intvalue;
所以现在这个objValue
变量总是可以向下转换为int
因为被转换的对象是一个Integer
,
int oldIntValue = (Integer) objValue;
// can be done
但是因为objValue
是一个 Object 它不能转换为String
因为int
不能转换为String
。
@ 原始海报 - 见内嵌评论。
public class demo
{
public static void main(String a[])
{
B b = (B) new A(); // compiles with the cast, but runtime exception - java.lang.ClassCastException
//- A subclass variable cannot hold a reference to a superclass variable. so, the above statement will not work.
//For downcast, what you need is a superclass ref containing a subclass object.
A superClassRef = new B();//just for the sake of illustration
B subClassRef = (B)superClassRef; // Valid downcast.
}
}
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");
}
}
在我一直使用的以下代码片段中,向下转换非常有用。 因此证明向下转换是有用的。
private static String printAll(LinkedList c)
{
Object arr[]=c.toArray();
String list_string="";
for(int i=0;i<c.size();i++)
{
String mn=(String)arr[i];
list_string+=(mn);
}
return list_string;
}
我将字符串存储在链接列表中。 当我检索链接列表的元素时,返回对象。 要将元素作为字符串(或任何其他类对象)访问,向下转换对我有帮助。
Java 允许我们编译低级代码,相信我们做错了。 尽管如此,如果人类犯了错误,它会在运行时被捕获。
考虑下面的例子
public class ClastingDemo {
/**
* @param args
*/
public static void main(String[] args) {
AOne obj = new Bone();
((Bone) obj).method2();
}
}
class AOne {
public void method1() {
System.out.println("this is superclass");
}
}
class Bone extends AOne {
public void method2() {
System.out.println("this is subclass");
}
}
这里我们创建了子类 Bone 的对象并将其分配给超类 AOne 引用,现在超类引用在编译时不知道子类中的方法 method2,即 Bone。因此我们需要将此超类引用向下转换为子类引用,以便结果引用可以知道子类中方法的存在,即 Bone
对象的向下转换是不可能的。 仅有的
DownCasting1 _downCasting1 = (DownCasting1)((DownCasting2)downCasting1);
是可能的
class DownCasting0 {
public int qwe() {
System.out.println("DownCasting0");
return -0;
}
}
class DownCasting1 extends DownCasting0 {
public int qwe1() {
System.out.println("DownCasting1");
return -1;
}
}
class DownCasting2 extends DownCasting1 {
public int qwe2() {
System.out.println("DownCasting2");
return -2;
}
}
public class DownCasting {
public static void main(String[] args) {
try {
DownCasting0 downCasting0 = new DownCasting0();
DownCasting1 downCasting1 = new DownCasting1();
DownCasting2 downCasting2 = new DownCasting2();
DownCasting0 a1 = (DownCasting0) downCasting2;
a1.qwe(); //good
System.out.println(downCasting0 instanceof DownCasting2); //false
System.out.println(downCasting1 instanceof DownCasting2); //false
System.out.println(downCasting0 instanceof DownCasting1); //false
DownCasting2 _downCasting1= (DownCasting2)downCasting1; //good
DownCasting1 __downCasting1 = (DownCasting1)_downCasting1; //good
DownCasting2 a3 = (DownCasting2) downCasting0; // java.lang.ClassCastException
if(downCasting0 instanceof DownCasting2){ //false
DownCasting2 a2 = (DownCasting2) downCasting0;
a2.qwe(); //error
}
byte b1 = 127;
short b2 =32_767;
int b3 = 2_147_483_647;
// long _b4 = 9_223_372_036_854_775_807; //int large number max 2_147_483_647
long b4 = 9_223_372_036_854_775_807L;
// float _b5 = 3.4e+038; //double default
float b5 = 3.4e+038F; //Sufficient for storing 6 to 7 decimal digits
double b6 = 1.7e+038;
double b7 = 1.7e+038D; //Sufficient for storing 15 decimal digits
long c1 = b3;
int c2 = (int)b4;
//int 4 bytes Stores whole numbers from -2_147_483_648 to 2_147_483_647
//float 4 bytes Stores fractional numbers from 3.4e−038 to 3.4e+038. Sufficient for storing 6 to 7 decimal digits
float c3 = b3; //logic error
double c4 = b4; //logic error
} catch (Throwable e) {
e.printStackTrace();
}
}
}
要在 Java 中进行向下转换并避免运行时异常,请参考以下代码:
if (animal instanceof Dog) {
Dog dogObject = (Dog) animal;
}
这里,Animal 是父类,Dog 是子类。
instanceof是一个关键字,用于检查引用变量是否包含给定类型的对象引用。
我会告诉你为什么会这样。 首先,您必须了解 JVM 在我们使用向下转换将父 class 分配给子 class 时如何支持,因为reference
。 例如考虑以下代码。
A is the super type any class that extends from it and can store the reference B class.
A a =new B();
When you assign a reference variable into the child class jvm will understand that since A can store the reference of B class that is why you can do it.
B b=(B)b;
extends
的键上,这就是您收到编译时错误的原因。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.