1. class A {
   
2.                  void fun1() {
   
3.                        System.out.println(fun2());
   
4.                  }
   
5.   
   
6.                  int fun2() {
   
7.                          return 123;
   
8.                  }
   
9.          }
   
10.   
    
11.           public class B extends A {
    
12.                  int fun2() {
    
13.                           return 456;
    
14.                   }
    
15.   
    
16.                  public static void main(String args[]) {
    
17.                          B b = new B();
    
18.                          b.fun1();   //456  这我知道，是B重写fun2()的缘故吧
    
19.                          A a = b;
    
20.                          a.fun1();   //456   但这a 指向A类去了，为什么还会使用子类的呢？
    
21.                  }
    
22.          }

复制代码

子类覆盖了父类的方法，运行时参考的是对象所属的类中是否有调用的方法，a=b，a中存放的是new B()的引用，会调用B中的方法

对象还是同一个对象，A a=b；这句没有改变b对象，只是把a 指向了b对象，但是这里的a，只能使用A里面声明的方法，不能使用在B里面声明的特有的方法

1. /**
   
2. *
   
3. */
   
4. package com.itheima.test;
   
5. 
   
6. /**
   
7. * @author Administrator
   
8. *
   
9. */
   
10. 
    
11. class A{
    
12.         void fun1(){
    
13.                 System.out.println(fun2());
    
14.         }
    
15.         int fun2(){
    
16.                 return 123;
    
17.         }
    
18. }
    
19. class B extends A{
    
20.         /* (non-Javadoc)
    
21.          * @see com.itheima.test.A#fun2()
    
22.          */
    
23.         @Override
    
24.         int fun2() {
    
25.                 // TODO Auto-generated method stub
    
26.                 return 456;
    
27.         }
    
28.         int fun3(){
    
29.                 return 3;
    
30.         }
    
31. }
    
32. 
    
33. public class ExtendsTest {
    
34.         public static void main(String[] args) {
    
35.                 B b=new B();
    
36.                 b.fun1();
    
37.                 b.fun3();
    
38.                 A a=b;
    
39.                 a.fun1();
    
40.                 a.fun2();
    
41.                 //a.fun3();不能调用
    
42.         }
    
43. }
    

复制代码

这是我的测试代码

这个是java 当时设计思想而定的，我推荐那本书 有个地方叫 find the right method  里就有，而且在里面也讲述了这个问题，如果真的是调用B中的方法，那对于将来的编程拓展是个很大的问题。很难想象 A中的实现过程 为什么要调用子类的实现方法呢？这也是为了安全的角度，万一子类来个System.exit(0); 那虚拟机不是挂掉了。。。我感觉 为什么当时只设计了  super this 关键字 而没设计lower 关键字。。。。。

chslzj 发表于 2013-7-13 08:39
这是我的测试代码

是不是只能够使用A中的方法，而A的方法内部与B的方法有关联的也可以调用，但不能显式使用B类，这又是为什么？既然是B对象了不能使用B的方法吗？

在乎.. 发表于 2013-7-13 11:00
是不是只能够使用A中的方法，而A的方法内部与B的方法有关联的也可以调用，但不能显式使用B类，这又是为什 ...

在对象a里面，因为定义是类A，在A的字节码内容里面没有子类B特有的方法的定义，对象a只能使用类A的方法，在类A里面写的代码不能有B的方法在里面，但是你可以在B方法内部重写方法，使其包含B特有的方法；
既然是B对象了不能使用B的方法吗？对于这个问题，因为你把它定义成A了，A哪里有B的特有方法啊

下面是测试代码

1. /**
   
2. *
   
3. */
   
4. package com.itheima.test;
   
5. 
   
6. /**
   
7. * @author Administrator
   
8. *
   
9. */
   
10. 
    
11. class A{
    
12.         void fun1(){
    
13.                 System.out.println(fun2());
    
14.         }
    
15.         int fun2(){
    
16.                 return 123;
    
17.         }
    
18. }
    
19. class B extends A{
    
20. 
    
21.         /* (non-Javadoc)
    
22.          * @see com.itheima.test.A#fun1()
    
23.          */
    
24.         @Override
    
25.         //这里我们重写了fun1方法，使其包含了B类特有的fun3方法
    
26.         void fun1() {
    
27.                 // TODO Auto-generated method stub
    
28.                 System.out.println(fun3());
    
29.         }
    
30.         /* (non-Javadoc)
    
31.          * @see com.itheima.test.A#fun2()
    
32.          */
    
33.         @Override
    
34.         int fun2() {
    
35.                 // TODO Auto-generated method stub
    
36.                 return 456;
    
37.         }
    
38.         int fun3(){
    
39.                 return 3;
    
40.         }
    
41. }
    
42. 
    
43. public class ExtendsTest {
    
44.         public static void main(String[] args) {
    
45.                 B b=new B();
    
46.                 b.fun1();
    
47.                 b.fun3();
    
48.                 A a=b;
    
49.                 a.fun1();
    
50.                 a.fun2();
    
51.                 //a.fun3();不能调用
    
52.         }
    
53. }
    

复制代码

为了执行后期绑定，Java使用一小段特殊的代码来替代绝对地址调用。这段代码使用在对象中存储的信息来计算方法体的地址。这样，根据这一小段代码的内容，每一个对象都可以具有不同的行为表现。当你向一个对象发送消息时，该对象就能够知道对这条消息应该做些什么。