一个引用强制转换的问题！！

Question

有哪位高手给我解释一下这个运行结果为什么不是apple呢
class fruit{
        void type(){
                System.out.println("apple");
        }
}
class fruit2 extends fruit{
        void type(){
                System.out.println("banana");
        }
        void over(){
                System.out.println("over");
        }
public class CastClass{
        public static void main(String[] args){
                fruit2 f2_obj = new fruit2();
                fruit f_obj = f2_obj;
                f_obj.type();
        }
}
这个结果是输出了"banana"，f_obj的类型已经是fruit了，为什么不是输出"apple"呢？ 谢谢！！ 

Answer 1

仅仅是类型，实际上呢？
不还是fruit2 的实例吗？要切合实际才行，那些虚名，不要也罢。
这是哲学。

Answer 2

你这没有强制转换....你只是声明一个f_obj变量，该变量引用f2_obj，强制转换应该这样fruit f_obj = （fruit）f2_obj; 

Answer 3

fruit2  f2_obj = new fruit2();这个只是指明fr_obj这个引用指向内存的某块地址，
而fruit f_obj = f2_obj;是将f2_obj的这个对地址的引用赋给f_obj，所以他还指向的是f2_obj,也就是说f_obj实际还是指向的f2_obj的内容。所以它仍然输出banana。
以上仅供参考，如有不对，，请指正！

Answer 4

这不是典型的多态么
1.有继承；                  class fruit2 extends fruit
2，有重写（type()方法）；  void type(){  System.out.println("banana"); 
3，父类引用指向子类对象。     fruit f_obj = f2_obj; 

Answer 5

次句等于public class CastClass{ 
        public static void main(String[] args){ 
                fruit f_obj = new fruit2(); 
                f_obj.type(); 
        } 
} 就是个多态问题，在有继承的情况下，java是从基类到父类查找方法的

Answer 6

次句等于
Java codepublicclass CastClass{publicstaticvoid main(String[] args){ 
                fruit f_obj=new fruit2(); 
                f_obj.type(); 
        } 
}就是个多态问题，在有继承的情况下，java是先基类在到父类查找方法的

Answer 7

fruit f_obj = f2_obj
这紧紧是个引用而已

Answer 8

多态，new什么就是调用什么的

Answer 9

多态，子类重写父类type()方法。
子类的对象使用这个重写方法时，将调用子类中的定义，对它而言，父类同名方法被"屏蔽"了。因为：fruit f_obj = f2_obj; 
所以：f_obj.type(); 调用的是子类的方法。

Answer 10

为了解释清楚：
package com.linqing.test;class 父类 {
void type() {
System.out.println("apple");
}
}
class 子类 extends 父类 {
void type() {
System.out.println("banana");
} void over() {
System.out.println("over");
}
}
public class CastClass {
public static void main(String[] args) {
子类 f2_obj = new 子类();
父类 f_obj = f2_obj;
f_obj.type();
System.out.println(f2_obj.getClass());
System.out.println(f_obj.getClass());
}
}
结果：
banana
class com.linqing.test.子类
class com.linqing.test.子类所以，调用的是子类的方法。

Answer 11

有：继承、多态、重写（覆盖）不是强转public class CastClass{
        public static void main(String[] args){
            fruit2 f2_obj = new fruit2();  /** 声明fruit2对象 f2_obj  */
            fruit f_obj = f2_obj;  //声明fruit对象 f_obj，并引用 f2_obj
            f_obj.type();  //对象 f_obj 调用type()方法,继承关系 ，type()方法覆盖
                           //了父类的type()方法，就直接打印 banana
        }
} 

Answer 12

因为f_obj的引用是fruit2生成的实例，所以调用的是fruit2的方法；但如果调用的是属性的话，则使用父类（fruit）的属性

Answer 13

fruit2 f2_obj = new fruit2();
fruit f_obj = f2_obj; 可以理解为 fruit f_obj = new fruit2();  这是多态，不需要强制类型转化，直接自动向上转型。f_obj 的引用类型虽然是fruit，但是实际类型确实子类fruit2。f_obj.type()  JVM会根据动态绑定机制调用实际类型fruit2中的type()方法。关于动态绑定机制，详见吧《java动态绑定机制实现多态》

Answer 14

明显是个多态会调用重写后的type()方法

Answer 15

是多态，fruit2复写了fruit中的type()方法，建议楼主看看多态