在第八天讲多态的时候,有这样一段代码:

1. 
   
2. abstract class Animal
   
3. {
   
4.         public abstract void eat();
   
5. }
   
6. class Cat extends Animal
   
7. {
   
8.         public void eat()
   
9.         {
   
10.                 System.out.println("eat fish");
    
11.         }
    
12.         public void catchMouse()
    
13.         {
    
14.                 System.out.println("catch mouse");
    
15.         }
    
16. }
    
17. class Dog extends Animal
    
18. {
    
19.         public void eat()
    
20.         {
    
21.                 System.out.println("eat bone");
    
22.         }
    
23.         public void watchHome()
    
24.         {
    
25.                 System.out.println("watch home");
    
26.         }
    
27. }
    
28. class PolymorphismDemo
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 function(new Cat());
    
33.                 function(new Dog());
    
34.         }
    
35.         public static void function(Animal a)
    
36.         {
    
37.                 a.eat();
    
38.         }
    
39. }

复制代码

疑问1.倒数第三行的a.eat()这个a调用的eat()方法为什么是子类的方法,而不是父类的?
2.我百度了下,查到说是引用变量a有2个类型,编译的时候类型为Animal,运行的时候类型为子类,所以在代码编译过程中,a调用的是Animal的eat()方法, 在运行代码的时候调用的是子类的eat()方法,这就是多态,那么我的第一个问题应该这样解释吗?这个方法的调用顺序是java的特性吗?

1. 
   
2.         public static void main(String[] args)
   
3. 
   
4.         {
   
5. 
   
6.                 function(new Cat());
   
7. 
   
8.                 function(new Dog());
   
9. 
   
10.         }
    
11. 
    
12.         public static void function(Animal a)//相当于Animal a=new Cat(); Animal a=new Dog();
    
13. 
    
14.         {
    
15. 
    
16.                 a.eat();
    
17. 
    
18.         }
    
19. 
    
20. }

复制代码

所以就是创建了子类的对象

因为多态的特点：成员函数，在多态调用时，编译看左边，运行看右

我是这么理解java多态的，多态的条件
1.继承
2.重写某个方法
3.父类引用指向子类对象
这里的继承可以是继承某个父类(抽象类也可以)，或者实现某个接口，重写某个方法是指子类和父类（或接口中）中相同参数名，以及参数类型，参数个数相同，从新定义一个方法体，这样在使用父类 f = new子类()创建对象时，f引用只能调用父类中特有的方法，但如果子类将父类中的方法覆写的话，执行的语句就是子类的方法体

楼主，其实楼上的张文彬回答的很好，如果这样你还不明白，说明你没有理解多态！
class PolymorphismDemo

{

        public static void main(String[] args)

        {

                function(new Cat());
//你这里调用function(Animal a) 方法，传递进去的是子类对象new Cat()和子类对象new Dog()
//也就是说父类引用指向子类对象，你要记住一点，在继承多态中，调用方法有个特点
//能调用哪个方法看引用，具体调用哪个看引用所指向的实例对象，就拿这个例子来说，
//function(new Cat())其实就是  Animal a = new Cat();
//那么首先我们看引用a，他有没有eat（）这个方法，有，那么说明能调用，那么接下来再看实力对象
//实例对象是new Cat(),那么调用的就是Cat的eat()方法。  其实多态就这么简单，只要记住我前面那句话就
//好，不过楼主还要注意，静态和私有修饰的方法没有多态，没事自己多敲代码验证一下就OK了！！！
                function(new Dog());

        }

        public static void function(Animal a)

        {

                a.eat();

        }

}

   

谢谢我明白了

请勿复制他人帖子，技术分不是入学的门槛而是为了帮助大家学习而存在的。

请勿再次发此类帖子了！

此贴就关闭了。此后如有再次发现直接封禁处理，请看到此贴的会员也加以注意。