1. class Fu
   
2. {
   
3. void method1()
   
4. {
   
5. System.out.println("fu---1");
   
6. }
   
7. void method2()
   
8. {
   
9. System.out.println("fu---2");
   
10. }
    
11. }
    
12. 
    
13. class Zi extends Fu
    
14. {
    
15. void method1()
    
16. {
    
17. System.out.println("zi---1");
    
18. }
    
19. void method3()
    
20. {
    
21. System.out.println("zi---3");
    
22. }
    
23. }
    
24. 
    
25. class Demo14
    
26. {
    
27. public static void main(String[] args)
    
28. {
    
29. Fu f = new Zi();
    
30. Zi z = (Zi)f;
    
31. z.method1();
    
32. z.method2();
    
33. z.method3();
    
34. }
    
35. }
    

复制代码

在内存中是怎样执行的顺序...求解......

我的理解是这样子的

1. public class Demo14 {
   
2.         public static void main(String[] args) {
   
3.                 //在栈中声明一个Fu类型的f变量，指向一个由Zi new出来的堆地址
   
4.                 Fu f = new Zi();
   
5.                 //将f强制转型为子类Zi类型，然后赋值给一个在栈中声明的Zi类型的z变量，z和f指向同一个堆地址
   
6.                 Zi z = (Zi) f;
   
7.                 //调用子类重写方法method1()
   
8.                 z.method1();
   
9.                 //调用父类的方法method2()
   
10.                 z.method2();
    
11.                 //调用子类的方法method3()
    
12.                 z.method3();
    
13.         }
    
14. }
    
15. 
    
16. class Fu {
    
17.         void method1() {
    
18.                 System.out.println("fu---1");
    
19.         }
    
20. 
    
21.         void method2() {
    
22.                 System.out.println("fu---2");
    
23.         }
    
24. }
    
25. 
    
26. class Zi extends Fu {
    
27.         void method1() {
    
28.                 System.out.println("zi---1");
    
29.         }
    
30. 
    
31.         void method3() {
    
32.                 System.out.println("zi---3");
    
33.         }
    
34. }

复制代码

如果将子类类型的对象，赋给父类类型的引用，那他会得到提升，就像
int a=10;
double b=a;
你又把父类，强制转换为子类类型，它向下转型，它可以调用子类特有的方法，子类继承了父类，拥有父类的方法，你的代码中子类覆盖了父类的两个方法，父类的第二个方法没有覆盖，所以调用的时候，会显示父类创建的内容。而覆盖掉的方法显示就是覆盖后的方法。

和老毕那样画个图就o了........求图

解释的很清楚了