昨天看到个问题是这样的：

1. class Parent {
   
2.      private int eatID=0;
   
3.      public Parent(){
   
4.          System.out.println("Parent is creating..");
   
5.          eat();
   
6.      }
   
7.      public void eat(){
   
8.         System.out.println("Parent is eat: "+eatID);
   
9.      }
   
10. 
    
11. }
    
12. 
    
13. class Son extends Parent {
    
14.      private int eatID=1;
    
15.      public Son(){
    
16.          System.out.println("Son is creating..");
    
17.          eat();
    
18.      }
    
19.      public void eat(){
    
20.          System.out.println("Son is eat: "+eatID);
    
21.      }
    
22.    
    
23. 
    
24. }
    
25. 
    
26. class Test {
    
27.   @SuppressWarnings(value={"unused"})
    
28.      public static void main(String[] args){
    
29.          Parent p;
    
30.                  p=new Son();
    
31.      }
    
32. }

复制代码

这个运行的输出是：
Parent is creating..
Son is eat: 0
Son is creating..
Son is eat: 1


这个问题很典型，在很多时候如果我们不注意就会犯很大的错误。
这里涉及到父类引用指向子类对象的问题。

在子类对象生成时，构造器会默认调用父类的构造器产生一个隐藏父类对象，所以会打印第一行。
父类引用指向一个子类对象：
       首先，他是一个父类引用，所以拥有的是父类中的方法，如果子类重写了父类的方法，则会自动调用子类方法。
       其次，成员变量是不可继承的，所以父类构造器中调用的eat方法使用的eatID是父类中的变量，值是0,。
所以打印了第二行。
第三行和第四行相信不用解释啦。

最后详细解释一下Parent p=new Son() ；
这样的写法满足java语言的多态，为我们开发带来很大便利。p既有子类对象的强大功能，又保证了父类的共性。

对于多态，可以总结以下几点：

一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；
四、变量不能被重写

简单的说就是：
       当父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
       对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。


       直观的记法是：在家中，父亲对于有把握让儿子做的事情就交给儿子去做，如果儿子太小了做不了，就自己亲自做。但如果儿子想尝试新科技，而自己又不懂了，就不允许儿子去做，很简单，父亲就是这么封建，自己不会的也不让儿子做。但至于吃饭的时候爱吃什么，就各自去决定吧，也就是变量不继承。


        这样解释，以后还会犯错误么~

昨天看到个问题是这样的：

1. class Parent {
   
2.      private int eatID=0;
   
3.      public Parent(){
   
4.          System.out.println("Parent is creating..");
   
5.          eat();
   
6.      }
   
7.      public void eat(){
   
8.         System.out.println("Parent is eat: "+eatID);
   
9.      }
   
10. 
    
11. }
    
12. 
    
13. class Son extends Parent {
    
14.      private int eatID=1;
    
15.      public Son(){
    
16.          System.out.println("Son is creating..");
    
17.          eat();
    
18.      }
    
19.      public void eat(){
    
20.          System.out.println("Son is eat: "+eatID);
    
21.      }
    
22.    
    
23. 
    
24. }
    
25. 
    
26. class Test {
    
27.   @SuppressWarnings(value={"unused"})
    
28.      public static void main(String[] args){
    
29.          Parent p;
    
30.                  p=new Son();
    
31.      }
    
32. }

复制代码

这个运行的输出是：
Parent is creating..
Son is eat: 0
Son is creating..
Son is eat: 1


这个问题很典型，在很多时候如果我们不注意就会犯很大的错误。
这里涉及到父类引用指向子类对象的问题。

在子类对象生成时，构造器会默认调用父类的构造器产生一个隐藏父类对象，所以会打印第一行。
父类引用指向一个子类对象：
       首先，他是一个父类引用，所以拥有的是父类中的方法，如果子类重写了父类的方法，则会自动调用子类方法。
       其次，成员变量是不可继承的，所以父类构造器中调用的eat方法使用的eatID是父类中的变量，值是0,。
所以打印了第二行。
第三行和第四行相信不用解释啦。

最后详细解释一下Parent p=new Son() ；
这样的写法满足java语言的多态，为我们开发带来很大便利。p既有子类对象的强大功能，又保证了父类的共性。

对于多态，可以总结以下几点：

一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；
四、变量不能被重写

简单的说就是：
       当父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
       对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。


       直观的记法是：在家中，父亲对于有把握让儿子做的事情就交给儿子去做，如果儿子太小了做不了，就自己亲自做。但如果儿子想尝试新科技，而自己又不懂了，就不允许儿子去做，很简单，父亲就是这么封建，自己不会的也不让儿子做。但至于吃饭的时候爱吃什么，就各自去决定吧，也就是变量不继承。


        这样解释，以后还会犯错误么~