一个非常简单的向下转型问题

Question

public class A{}
public class B extents A{
    A a = (B)new A();//这句话会抛出异常么 为什么？？
}

Answer 1

必须抛异常的，要满足a instanceof B 为true，才能向下转型的！

Answer 2

就是说怎样才算a instanceof b
还有就是既然a都是instanceof b了那还需要转型干嘛？

Answer 3

假如A类的子类有B、C，那么在使用A类对象的时候，需要判断A究竟是B还是C，也就是A instanceof B（或A instanceof C）。如果不进行此操作，直接进行转换，很容易造成类型转化的异常。

Answer 4

你这种向下转型的做法是错误的
应该这样
A a = new B();//
A c = (B)a;

Answer 5

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}

Answer 6

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦

Answer 7

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了

Answer 8

这样转型有什么用 直接A a = new B();A c = a;不是一样的么 都不需要转型

Answer 9

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了恩  这个理解了 那向下转型有什么作用 能举个例子体现一下么？

Answer 10

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了恩  这个理解了 那向下转型有什么作用 能举个例子体现一下么？
可以调用只有子类才就与的方法啊...
多态体现在动态绑定，这样才能确保能正确调用某个对象的覆盖父类某个方法的方法，子类可能还有其他方法，这是候当然是 谁的私有方法 由谁来调用了啊，这就是向下转型的目的...

Answer 11

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}

Answer 12

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}

这个不会错误吧....

Answer 13

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}

这个不会错误吧....
对不住，看错了，你说的注释的...

Answer 14

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了恩  这个理解了 那向下转型有什么作用 能举个例子体现一下么？
就是多态啊
比如我有一个车类 
是父类
他有跑的方法
然后我有一个汽车类
继承了车类
实现这个跑的方法
我还有一个单车类也继承他实现他这个方法
然后我有一个地方要调用一个方法
就是去某地
那么我调用去某地的时候只用吧参数写成车就行了
我想用汽车去就传汽车
想用单车去就传单车
随便扯的一个例子
不知道看得懂不 

Answer 15

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了恩  这个理解了 那向下转型有什么作用 能举个例子体现一下么？
就是多态啊
比如我有一个车类 
是父类
他有跑的方法
然后我有一个汽车类
继承了车类
实现这个跑的方法
我还有一个单车类也继承他实现他这个方法
然后我有一个地方要调用一个方法
就是去某地
那么我调用去某地的时候只用吧参数写成车就行了
我想用汽车去就传汽车
想用单车去就传单车
随便扯的一个例子
不知道看得懂不 多态是懂的  不明白的是向下转型的作用

Answer 16

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？

Answer 17

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？ if(a instanceof B){
B b = (B)a;
b.tell();
}

Answer 18

明白了 就是说向下转型前必须知道要转型的那个对象具体是b还是c的实例化对象。那么
public class A{
    public void fxh(){
        System.out.print("a fxh");
    }
}
public class B extents A{
    public void fxh(){
        System.out.print("b fxh");
    }
    B b = new B();
    A a = (A)b;
    a.fxh();//向上转型成功了 编译过了 为什么输出是：b fxh
}你new的是一个B对象 当然输出B的方法哦
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了恩  这个理解了 那向下转型有什么作用 能举个例子体现一下么？
可以调用只有子类才就与的方法啊...
多态体现在动态绑定，这样才能确保能正确调用某个对象的覆盖父类某个方法的方法，子类可能还有其他方法，这是候当然是 谁的私有方法 由谁来调用了啊，这就是向下转型的目的...谁的私有方法谁来调用需要用到向下转型么？不需要吧 有例子么？

Answer 19

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？ if(a instanceof B){
B b = (B)a;
b.tell();
}
谢谢  大概理解了 但是感觉向下转型没啥用

Answer 20

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？ if(a instanceof B){
B b = (B)a;
b.tell();
}
谢谢  大概理解了 但是感觉向下转型没啥用
哥么，你还不知道封装的重要性

Answer 21

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？ if(a instanceof B){
B b = (B)a;
b.tell();
}
谢谢  大概理解了 但是感觉向下转型没啥用
class Animal{
void eat(){

}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat fish");
}
public void catchMouse(){
System.out.println("Cat catch mouse");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat bone");
}
public void watchDoor(){
System.out.println("Dog watch door");
}
}public class Demo{
public static void main(String[] arg){
Animal a = new Animal();
testAnimal(a);
}
public static void testAnimal(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();
}
if(a instanceof Dog){
Dog d = (Dog)a;
d.watchDoor();
}
}
}

Answer 22

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？ if(a instanceof B){
B b = (B)a;
b.tell();
}
谢谢  大概理解了 但是感觉向下转型没啥用class Animal{
void eat(){

}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat fish");
}
public void catchMouse(){
System.out.println("Cat catch mouse");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat bone");
}
public void watchDoor(){
System.out.println("Dog watch door");
}
}public class Demo{
public static void main(String[] arg){
Animal a = new Animal();
testAnimal(a);
}
public static void testAnimal(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();
}
if(a instanceof Dog){
Dog d = (Dog)a;
d.watchDoor();
}
}
}这里就是向下转型

Answer 23

如果你想调用子类新增的方法，就必须向下转型！父类不能调用子类新增的方法吧  能举个例子么？class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误，无法调用此方法，因为父类中没有声明此方法
}
向下转型的作用就是使a.tell()正确吧  怎么做到？ if(a instanceof B){
B b = (B)a;
b.tell();
}
谢谢  大概理解了 但是感觉向下转型没啥用
这个看你以后项目需要了，如果项目中，子类不允许添加父类没有的方法，那么就不会用的，如果子类中添加了父类中没有的方法，那么就会遇到向下转型为更具体的子类，已调用子类自今的方法！