在多态的体现当中，父类的引用也可以接收自己的子类对象是什么意思？麻烦举个例子说明下

3楼正解，顺便水一下分

1. public class Fu
   
2. {
   
3.     public void Name()
   
4.     {
   
5.         System.out.println("fu");
   
6.     }
   
7.      
   
8.      
   
9. }
   
10. 
    
11. public class Zi extends Fu
    
12. {
    
13.     public void Name()
    
14.     {
    
15.         System.out.println("zi");
    
16.     }
    
17. }
    
18. 
    
19. 
    
20. public class Test
    
21. {
    
22.     public static void main(String[] args)
    
23.     {
    
24.         Fu p = new Zi();
    
25.         p.Name();
    
26. 
    
27.                 //这时候程序执行结果是"zi";
    
28.                 //虽然是用父类p引用，但是方法是指向子类的方向
    
29.     }
    
30. }

复制代码

程序执行结果是"zi"
虽然是用父类p引用，但是方法是指向子类的方向

Student 继承Person 然后 Person p = new Studnet();这就是多态父类引用指向子类对现的体现，也叫向上转型.

根据你的问题写了个小代码说明一下：

1. /*
   
2. 说明多态
   
3. 在多态的体现当中，父类的引用也可以接收自己的子类对象是什么意思？
   
4. */
   
5. 
   
6. abstract class Animal
   
7. {
   
8.         abstract public void eat();
   
9.         public void sleep()
   
10.         {
    
11.                 System.out.println("闭眼睡觉");
    
12.         }
    
13. }
    
14. class Dog extends Animal
    
15. {
    
16.         public void eat()
    
17.         {
    
18.                 System.out.println("吃骨头");
    
19.         }
    
20. }
    
21. class Cat extends Animal
    
22. {
    
23.         public void eat()
    
24.         {
    
25.                 System.out.println("吃鱼");
    
26.         }
    
27. }
    
28. 
    
29. class DuoTaiDemo
    
30. {
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 eat(new Dog());
    
34.                 eat(new Cat());
    
35.         }
    
36. /*
    
37. 需要一个动物，但是给了一个狗接收进来也是可以啊，
    
38. 当然，这里有个类型提升，狗提升为动物，如果要使用狗的特有方法，则要强转一下，一般用到instanceof先判断一下
    
39. */
    
40.         public static void eat(Animal a)//相当于：Animal a = new Dog(); 即是父类引用接收了一个子类对象。
    
41.         {
    
42.                 a.eat();
    
43.         }
    
44. }
    

复制代码