Java中的向下广播
Java中允许向上转换,但是向下转换会产生编译错误 可以通过添加强制转换来删除编译错误,但无论如何都会在运行时中断 在这种情况下,如果Java不能在运行时执行向下转换,为什么Java允许向下转换?Java中的向下广播,java,casting,Java,Casting,Java中允许向上转换,但是向下转换会产生编译错误 可以通过添加强制转换来删除编译错误,但无论如何都会在运行时中断 在这种情况下,如果Java不能在运行时执行向下转换,为什么Java允许向下转换? 这个概念有什么实际用途吗 public class demo { public static void main(String a[]) { B b = (B) new A(); // compiles with the cast,
这个概念有什么实际用途吗
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
当强制转换(如最后一个)在运行时失败时,将抛出一个
在其他情况下,它将起作用:
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.
我相信这适用于所有静态类型语言:
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
typecast实际上是这样说的:假设这是对cast类的引用,并使用它。现在,假设o实际上是一个整数,假设这是一个字符串是没有意义的,并且会给出意外的结果,因此需要进行运行时检查和异常,以通知运行时环境有问题
在实际使用中,您可以在更一般的类上编写代码,但如果您知道它是什么子类并且需要这样对待它,则可以将它转换为子类。一个典型的例子是重写Object.equals()。假设我们有一个汽车类:
@Override
boolean equals(Object o) {
if(!(o instanceof Car)) return false;
Car other = (Car)o;
// compare this to other and return
}
使用您的示例,您可以执行以下操作:
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();
}
在这种情况下,如果不能在运行时执行,为什么Java允许向下转换
我相信这是因为编译器无法在编译时知道强制转换是否成功。举个例子,很容易看出演员阵容会失败,但也有一些时候不太清楚
例如,假设类型B、C和D都扩展了类型A,然后方法
public A getSomeA()
根据随机生成的数字返回B、C或D的实例。编译器无法知道此方法将返回哪个确切的运行时类型,因此如果稍后将结果强制转换为B
,则无法知道强制转换是否成功(或失败)。因此,编译器必须假设强制转换将成功。我们都可以看到,您提供的代码在运行时无法工作。这是因为我们知道表达式newa()
永远不能是B
类型的对象
但编译器并不是这么看的。当编译器检查是否允许强制转换时,它只看到以下内容:
variable_of_type_B = (B)expression_of_type_A;
正如其他人所证明的那样,这种演员阵容是完全合法的。右边的表达式可以很好地计算为B
类型的对象。编译器看到A
和B
具有子类型关系,因此使用代码的“expression”视图,强制转换可能会起作用
编译器不考虑特殊情况,当它确切知道对象类型<代码> ApdioTyx A/<代码>时,将真正拥有什么。它只将静态类型视为
A
,并认为动态类型可以是A
或A
的任何后代,包括B
@原始海报-请参阅内联注释
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");
}
}
当我们处理向上投射的对象时,向下投射是有效的。 向上投射:
int intValue = 10;
Object objValue = (Object) intvalue;
所以现在这个objValue
变量总是可以向下转换为int
,因为被转换的对象是一个整数
int oldIntValue = (Integer) objValue;
// can be done
但是因为
objValue
是一个对象,所以不能将其强制转换为String
,因为int
不能强制转换为String向下转换在下面的代码段中非常有用,我一直都在使用它。因此,证明向下投射是有用的
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;
}
私有静态字符串printAll(LinkedList c)
{
对象arr[]=c.toArray();
字符串列表_String=“”;
对于(int i=0;i考虑以下示例
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 reference,而现在超类reference不知道
关于子类(即Bone)中的方法method2,在编译时。因此,我们需要将此超类引用向下转换为子类引用,以便生成的引用可以了解子类(即Bone)中存在的方法,对象的向下转换是不可能的。
只有
有可能
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;
}
在这里,动物是父类,狗是子类。
instanceof是一个关键字,用于检查引用变量是否包含给定类型的对象引用。一段示例代码加上错误,对于试图学习这些概念的人来说,这是一个更好的问题。我看到上面的示例已经有了一些很好的答案。@PhiLho-Joel的主要意图是将所有优秀的问题和答案放在一个共同的伞下。问题/代码/答案是否已经发布在其他网站上并不重要。我希望你明白这一点,否则请收听Joel的播客。请编辑此内容,使代码段都缩进四个空格。这将修复格式。B=(B)新的A();是非法的,您不应该将其称为向下转换。当我们讨论向上/向下转换时,实际对象没有改变,只是什么类型的变量引用该对象的问题。您不能使用子类型的变量引用基类型的对象。我刚刚了解了instanceof的重要性,当我的抽象类被multip扩展时le classes和我想在引用抽象类类型时使用这些类的独占方法。不使用instanceof我让类强制转换Exception我喜欢“真”这个词,我将编辑您的帖子,使其更明显Object o=new Object();String s=(String)o;
它对我来说工作正常….:o如何?@UnKnown:不应该。请仔细检查您是否确实编译并运行了该版本,以及是否可以
if (animal instanceof Dog) {
Dog dogObject = (Dog) animal;
}