10.多态

生活中的多态：客观事物在人脑中的主观反应；也就是说对象与某个类间存在“is a”关系
              例如：大黄是一条狗，也是一个动物，这种关系就是多态的形成 

程序中的多态：父类引用指向子类对象，在程序中形成了多态
       用法： 可以调用父类的方法，但是不能调用子类独有的方法
   

===========================多态核心===========================

案例：大黄是一条狗，也是一个动物
分析： 类： 狗类     动物类    对象： 大黄       方法：  动物类-吃    狗类-跑
  

class Animal{
    public void eat() {
        System.out.println("动物正在吃...");
    }
}

class Dog extends Animal{
    public void run() {
        System.out.println("大黄正在跑...");
    }
}

public class Test1 {
    public static void main(String[] args) {
        /*
        Dog dog = new Dog();  //把狗当成狗类看待-->可以调子类自身方法，也可以根据继承调父类方法
        dog.run();
        dog.eat();
        */
        
        Animal animal = new Dog(); //多态的核心-->把狗当成动物来看待，可以调动物类的方法，但狗类独有方法不能调用
        animal.eat();  
        //animal.run();   //不能调子类独有方法
    }
}

===========================多态直接引用===========================

案例：大黄是一条狗，也是一个动物
分析： 类： 狗类     动物类    对象： 大黄       方法：  动物类-吃    狗类-跑

升级：狗类重写父类的方法，应该如何调用？

多态的应用： 父类引用指向子类对象，优先调用子类重写的方法
方式1：子类对象直接赋值给父类

class Animal2{
    public void eat() {
        System.out.println("动物正在吃...");
    }
}

class Dog2 extends Animal2{
    public void run() {
        System.out.println("大黄正在跑...");
    }
    
    @Override
    public void eat() {
        System.out.println("大黄正在吃...");
    }
}

public class Test2 {
    public static void main(String[] args) {
        Animal2 animal2 = new Dog2();
        animal2.eat();  //父类引用指向子类对象，优先调用子类重写的方法
    }
}

===========================多态以传参方式出现===========================

案例： 老师开着法拉利牌自行车去上班
分析： 
类：    老师类     自行车类
对象：   new         new    
属性：   姓名        品牌   
方法：   开          运转

 案例： 老师开着法拉利牌自行车去上班
分析： 
类：    老师类     自行车类
对象：   new         new    
属性：   姓名        品牌   
方法：   开          运转

升级： 老师法拉利牌开汽车..

问题：当我们扩展了开地铁类，飞机类，大炮，那么在Teacher类中需要增加很多开的方法（冗余太多，麻烦，可维护性不强）
改造： 自行车，汽车，地铁，飞机等都是交通工具，都具备运转功能

多态的好处： 使得程序的扩展性，可维护性更强

class JiaoTongTool{
    public void run() {
        System.out.println("交通工具在运转...");
    }
}

class Bike extends JiaoTongTool{
    @Override
    public void run() {
        System.out.println("自行车运转: 轮子转啊转，以每小时50公里速度~");
    }
}

class Car extends JiaoTongTool{
    @Override
    public void run() {
        System.out.println("汽车运转：以每小时100公里速度前进~");
    }
    
}

class Teacher{
    //重写  VS 重载
    //重载： 在同一个类中，方法名相同，参数个数或类型不同
    //重写：在继承关系中，子类返回值，方法名，参数类型和父类完全一致，且子类权限大于等于父类
          
    //-----------重载方法----------
    /*
    public void start(Bike bike) {//Bike bike = new Bike();
        bike.run();  //自行车的运转
    }
    
    public void start(Car car) {
        car.run();  //自行车的运转
    }*/

    //面向对象的设计原则：ocp原则,开闭原则
    //o-open: 对外新增的代码持开放状态-扩展性  (升级新增飞机类，大炮等)
    //c:close:对内修改的代码持关闭状态-灵活性，可维护性 (Teacher类的start方法不要变更，只需用交通工具类接收)
    
    //以传参形式实现多态：
    //应用：父类引用指向子类对象，可调用子类重写方法
    public void start(JiaoTongTool tool) {
        tool.run();  //不要看谁调的，要看谁传的
    }

}

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.start(new Bike());  //1.老师开自行车
        teacher.start(new Car());     //2.老师开汽车
        
        //new Bike().run();  //等价Teacher的start方法里面bike对象的调用
    }
}

===========================传参方式实现多态案例2===========================
案例：主人喂养动物，狗是动物，猫是动物，以传参形式实现多态
抽取： 父类引用指向子类对象，调子类重写方法--->狗，猫是动物，具备吃的行为
类： 主人类    动物类    狗类    猫类      
行为： 主人类： 喂养       动物类：吃      狗，猫： 重写吃

class Animal{
    public void eat() {
        System.out.println("动物在吃...");
    }
}


class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗在吃...");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫在吃...");
    }
}

class Master{
    public void feed(Animal animal) {//多态
        animal.eat();  //谁传给我，就是谁在吃
    }
}

public class Test2 {
    public static void main(String[] args) {
        Master master = new Master();
        master.feed(new Dog()); //主人喂狗，狗在吃
        master.feed(new Cat()); //主人喂猫，猫在吃 
    }
}

===========================多态以返回值形式出现===========================
案例：主人购买动物，选择购买编号：1.买狗    2.买鸟

分析： 
类：  主人类             动物类   狗类   鸟类      
行为：购买                      叫
 

class Animal{
    public void bark() {
        System.out.println("动物在叫..");
    }
}

class Dog extends Animal{
    @Override
    public void bark() {
        System.out.println("狗在叫..");
    }
}

class Bird extends Animal{
    @Override
    public void bark() {
        System.out.println("鸟在叫...");
    }
}

class Master{
    public Animal buy(int num) {
        switch (num) {
            case 1:
                return new Dog();  //多态以返回值方式出现
            case 2:
                return new Bird();
            default:
                return null;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("请输入你要购买的宠物： 1.狗   2.鸟");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        Master master = new Master();
        //多态以返回值方式出现
        Animal animal = master.buy(num);  //Animal a = new Dog(); 
        if(animal!=null) {
            animal.bark();  //调重写方法
        }else {
            System.out.println("没有这个购买的宠物");
        }
        
    }
}