class Foo{
ppublic int a;
public Foo(){
a=3;
}

public void addFive(){
a+=5;
}
}

class Bar extends Foo{
public int a;
public Bar(){
a=8;
}
public void addFive(){
this.a+=5;
}
}

public class TestFoo{
public static void main(String [] args){
   Foo foo=new Bar();
   foo.addFive();
System.out.prinfln(foo.a);
}
}

输出的结果我认为是：13 可是正确的结果并不是，why?

原因是你子类Bar里面又定义了字段a，
Bar里的public int a；并未复写父类Foo的public int a；
也即构造时，有两个a，这两个a是不同的。主方法改成如下这般，可以直观显示：
public static void main(String[] args) {
                Foo foo = new Bar();
                System.out.println(foo.a);
                foo.addFive();
                System.out.println(foo.a);
                Bar bar = (Bar)foo;
                System.out.println(bar.a);
        }


结果为：
3
3
13


修改后的代码：

1. class Foo {
   
2.         public int a;
   
3. 
   
4.         public Foo() {
   
5.                 a = 3;
   
6.         }
   
7. 
   
8.         public void addFive() {
   
9.                 a += 5;
   
10.                 System.out.println("Foo a = " +a);
    
11.         }
    
12. 
    
13.         public int getA() {
    
14.                 return a;
    
15.         }
    
16. }
    
17. 
    
18. class Bar extends Foo {
    
19.         public Bar() {
    
20.                 a = 8;
    
21.         }
    
22.         @Override
    
23.         public void addFive() {
    
24.                 this.a += 5;
    
25.                 System.out.println("Bar a = " +a);
    
26.         }
    
27. }
    
28. 
    
29. public class TestFoo {
    
30.         public static void main(String[] args) {
    
31.                 Foo foo = new Bar();
    
32.                 System.out.println(foo.a);
    
33.                 foo.addFive();
    
34.                 System.out.println(foo.a);
    
35.         }
    
36. }

复制代码

运行结果：8
Bar a = 13
13

首先,你那println写成ptinfln了,  你new Bar()时, 有条隐式的super(); 调用父类的构造函数,这是foo.a=3, 然后子类的a=8, 在复写父类的方法,调用子类的方法a+=5, 那么输出 bar a=13,  你foo.a则是调用是父类的a,, 所以成员变量不存在覆盖.      

1.在多态中成员函数的特点：
        在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
        在运行时期：参阅对象所属的类中是否有调用的方法。
        简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
2.在多态中，成员变量的特点：
        无论编译和运行，都参考左边(引用型变量所属的类)。
3.在多态中，静态成员函数的特点：
        无论编译和运行，都参考做左边。

按照你的意思代码改成这样你看看：

1. class Foo{
   
2.         public int a;
   
3.         public Foo(){
   
4.                 a=3;
   
5.         }
   
6. 
   
7.         public void addFive(){
   
8.                 a+=5;
   
9.         }
   
10. }
    
11. 
    
12. class Bar extends Foo{
    
13.         public int a;
    
14.         public Bar(){
    
15.                 super.a=8;
    
16.         }
    
17.         public void addFive(){
    
18.                 super.a+=5;
    
19.         }
    
20. }
    
21. 
    
22. public class TestFoo{
    
23. public static void main(String [] args){
    
24.         Foo foo=new Bar();
    
25.         foo.addFive();
    
26.         System.out.println(foo.a);
    
27. }
    
28. }

复制代码

成员变量编译运行都左边，知道吗，成员函数编译看左边运行看右边，希望对你有记忆