面向对象--多态--多态的好处

多态的好处

• 代码扩展性很好(由继承所带来的好处)
• 代码的维护性很好(由多态所带来的好处)

例题多态练习 

class Animal2{
    String name;
    int age;

    Animal2(){

    }

    Animal2(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }
}

class Dog2 extends Animal2{

    Dog2(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void sleep() {
        System.out.println("狗侧着睡");
    }
}

class Alpaca extends Animal2{

    Alpaca(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public void eat() {
        System.out.println("羊驼吃草");
    }

    @Override
    public void sleep() {
        System.out.println("羊驼卧着睡");
    }
}

class Panda extends Animal2{
    Panda(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public void eat() {
        System.out.println("熊猫吃竹子");
    }

    @Override
    public void sleep() {
        System.out.println("熊猫随便睡");
    }
}

//用工具类改进
class AnimalTool{
  
  //构造方法私有化
    private AnimalTool(){

    }
  
/*
 将来再想养新的动物，只要在工具类中添加一个新的动物方法就可以了
 
    //访问狗的方法
    public static void useDog(Dog2 dog2){
        dog2.eat();
        dog2.sleep();
    }

    //访问羊驼的方法
    public static void useAlpaca(Alpaca alpaca){
        alpaca.eat();
        alpaca.sleep();
    }

    //访问熊猫的方法

    //访问老虎的方法
    //...
    
 但是呢，工具理论上是不允许修改的，所以我们需要再次改进
 因为AnimalTool中的狗、羊驼、熊猫、老虎等等都属于动物，使用多态改进。
*/
  
    public static void useAnimal(Animal2 animal){  // Animal2 animal2 = new Panda("团团", 2);//多态
        animal.eat();
        animal.sleep();
    }
}


public class CatDogDemo {
    public static void main(String[] args) {
      
      
//        现在我想养一只狗
        Dog2 d1 = new Dog2("小花", 3);
//        d1.eat();
//        d1.sleep();
      
      //使用方法改进后
//        useDog(d1);
      
      //使用工具类改进后
//        AnimalTool.useDog(d1);
      
      //使用多态改进之后
        AnimalTool.useAnimal(d1);

      
        //我想再养一条狗
        Dog2 d2 = new Dog2("奶糖", 4);
//        d2.eat();
//        d2.sleep();
      
      //使用方法改进后
//        useDog(d2);
      
      //使用工具类改进后
//        AnimalTool.useDog(d2);
      
      //使用多态改进之后
        AnimalTool.useAnimal(d2);

      
        //我还想养一条狗
        Dog2 d3 = new Dog2("旺财", 2);
//        d3.eat();
//        d3.sleep();
      
      //使用方法改进后
//        useDog(d3);
      
      //使用工具类改进后
//        AnimalTool.useDog(d3);
      
      //使用多态改进之后
        AnimalTool.useAnimal(d3);

      
        //你不觉得每次调用方法都需要写一遍eat()和sleep有重复的吗？
        //使用方法改进

      
        //我又想养羊驼
        Alpaca a1 = new Alpaca("小白", 2);
//        a1.eat();
//        a1.sleep();
      
      //使用方法改进后
//        useAlpaca(a1);
      
      //使用工具类改进后
//        AnimalTool.useAlpaca(a1);
      
      //使用多态改进之后
        AnimalTool.useAnimal(a1);

      
        //再养只羊驼
        Alpaca a2 = new Alpaca("小黄", 3);
//        a2.eat();
//        a2.sleep();
      
      //使用方法改进后
//        useAlpaca(a2);
      
      //使用工具类改进后
//        AnimalTool.useAlpaca(a2);
      
      //使用多态改进之后
        AnimalTool.useAnimal(a2);

      
        //再养只羊驼
        Alpaca a3 = new Alpaca("小黑", 3);
//        a3.eat();
//        a3.sleep();
      
      //使用方法改进后
//        useAlpaca(a3);
      
      //使用工具类改进后
//        AnimalTool.useAlpaca(a3);
      
      //使用多态改进之后
        AnimalTool.useAnimal(a3);
      
      
      //有重复的和狗一样也使用方法改进
      
      
/*
        如果我现在不想养羊驼了，想养熊猫
        是不是养n只熊猫，要new出n次
        每个熊猫也有吃和睡的方法
        按照上面的写代码的习惯，再额外新增一个熊猫的方法
        但是，将来我还有可能养老虎，狮子，豹子等等。。。
        这些动物按照上面的写代码的习惯,是不是应该都需要写一个方法，最后会发现这个程序非常臃肿杂乱
        回想一下，我们之前将多个方法操作同一类型的时候，我们用工具类进行改进的
        用工具类改进之后，将来再想养新的动物，只要在工具类中添加一个新的动物方法就可以

        但是呢，工具理论上不允许修改的
        所以我们需要再次改进
        怎么改进呢？使用多态改进
*/
      
      
      //使用多态改进之后
      //利用的是多态访问成员方法的特点：编译看左，运行看右
        Panda p1 = new Panda("团团", 2);
        AnimalTool.useAnimal(p1);
        Panda p2 = new Panda("圆圆", 3);
        AnimalTool.useAnimal(p2);
        Panda p3 = new Panda("平平", 4);
        AnimalTool.useAnimal(p3);
    }

//    //访问狗的方法
//    public static void useDog(Dog2 dog2){
//        dog2.eat();
//        dog2.sleep();
//    }
//
//    //访问羊驼的方法
//    public static void useAlpaca(Alpaca alpaca){
//        alpaca.eat();
//        alpaca.sleep();
//    }
//
//    //访问熊猫的方法
//
//    //访问老虎的方法
//    //...
}