java多态 -- 猫狗案列

我们用猫狗案例来表明在java中使用多态的好处：

　　　　

 class Animal{
     public Animal(){}
     public void eat(){
         System.out.println("吃饭");
     }
     public void sleep(){
         System.out.println("睡觉");
     }
 }
 class Cat extends Animal{
     public Cat(){}
     public void eat(){
         System.out.println("猫吃鱼");
     }
     public void sleep(){
         System.out.println("猫趴着睡觉");
     }
 }
 class Dog extends Animal{
     public Dog(){}
     public void eat(){
         System.out.println("狗吃肉");
     }
     public void sleep(){
         System.out.println("狗站着睡觉");
     }
 }
 class Pig extends Animal{
     public Pig(){}
     public void eat(){
         System.out.println("猪吃草");
     }
     public void sleep(){
         System.out.println("猪也趴着睡觉");
     }
 }
 
 class AnimalTool{
     //总结： 使用static方法与priva的原因是，避免有些笨蛋
     //直接使用创建工具类对象的方式来访问工具类中的方法
     private AnimalTool(){}
     /*public static void useCat(Cat c){
         c.eat();
         c.sleep();
     }
     public static void useDog(Dog d){
         d.eat();
         d.sleep();
     }
     public static void usePig(Pig p){
         p.eat();
         p.sleep();
     }
     */
     public static void useAnimal(Animal a){
         a.eat();
         a.sleep();
     }
 
 }
 class DuoTaiDemo2{
     public static void main(String []args){
         Cat c=new Cat();
         c.eat();
         c.sleep();
 
         Cat c2=new Cat();
         c2.eat();
         c2.sleep();
 
         Cat c3=new Cat();
         c3.eat();
         c3.sleep();
         System.out.println("----------------");
         //接下来是狗
         Dog d=new Dog();
         d.eat();
         d.sleep();
 
         Dog d2=new Dog();
         d2.eat();
         d2.sleep();
 
         Dog d3=new Dog();
         d3.eat();
         d3.sleep();
         System.out.println("----------------");
 
         //接下来是 猪
         Pig p=new Pig();
         p.eat();
         p.sleep();
 
         Pig p2=new Pig();
         p2.eat();
         p2.sleep();
 
         Pig p3=new Pig();
         p3.eat();
         p3.sleep();
         /*
         System.out.println("----------接下来利用工具类实现以上效果----------");
 
         AnimalTool.useCat(c);
         AnimalTool.useCat(c2);
         AnimalTool.useCat(c3);
 
         System.out.println("-------------");
 
         AnimalTool.useDog(d);
         AnimalTool.useDog(d2);
         AnimalTool.useDog(d3);
 
         System.out.println("-------------");
 
         AnimalTool.usePig(p);
         AnimalTool.usePig(p2);
         AnimalTool.usePig(p3);
         */
         System.out.println("----------接下来利用【多态性】类实现以上效果----------");
         Animal cc=new Cat();
         AnimalTool.useAnimal(cc);
 
         Animal dd=new Dog();
         AnimalTool.useAnimal(dd);
 
         Animal pp=new Pig();
         AnimalTool.useAnimal(pp);
     }
 }

　　　　在这个案例中，我们分别使用了三种方法逐渐优化。

　　第一种---笨方式

　　　　直接利用猫狗类创建对象，多次进行调用eat sleep方法，导致存在大量冗余代码。

　

　　　　第二种---创建工具类，将每个动物的eat sleep方法放在各自静态方法中，并将工具类构造方法声明为private，使其仅可通过类名调用。

　　　　　　　　　　

　　　　　　在这种方法中，AnimalTool.useCat（c）；这个语句相当于之前的  c.eat();    两句，按之前方法，如果我们定义非常多猫，那代码岂不是冗余巨大？

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  c.sleep() ;

　　第三种------  将工具类中各自的方法优化为一个：useAnimal(Animal  a)， 并在主函数中通过多态的方式创建对象，如 Animal a=new Cat（）；

　　　　　　　　　这样减少的是工具类中的冗余代码。

　　以上。