java--多态

多态

为什么使用多态?

提高代码的可扩展性,可维护性
多态:同一个引用类型,使用不同的实例来执行不同的操作(父类引用指向子类对象)

2 . 特点

多态的前提1：是继承
多态的前提2：要有方法的重写

父类引用指向子类对象,如：Animal a = new Cat();
多态中，编译看左边，运行看右边

创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存
Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
/4.口诀2：编译看左边，运行看右边
* 解释：必须要在父类定义这个方法，才能通过编译，把多态对象看作是父类类型
* 必须要在子类重写这个方法，才能满足多态，实际干活的是子类/
a2.eat();//小猫爱吃小鱼干~，多态对象使用的是父类的定义，子类的方法体
//a2.jump();报错 父类对象不能去调用子类的方法

4. 多态的好处

1.多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
2.提高了程序的可扩展性和可维护性

5. 多态的使用

前提:多态对象把自己看做是父类类型
成员变量: 使用的是父类的
成员方法: 由于存在重写现象,所以使用的是子类的
静态成员: 随着类的加载而加载,谁调用就返回谁的

public abstract class Pet {
    //子类中共有的属性
    private String name;//昵称
    private int health;//健康状况值
    private int love;//亲密程度值
    //抽象方法 eat()
    public abstract void eat();

    public String getName() {
        return name;
    }

    public int getHealth() {
        return health;
    }

    public int getLove() {
        return love;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public Pet(String name, int health, int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }
    public Pet() {
    }
    public  void print(){
        System.out.println("昵称:"+this.name+"\t"+"健康值:"+this.health+"\t"+"亲密值:"+this.love);
    }
}

public class Penguin extends Pet {
   private String sex;//性别

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public void eat() {
        System.out.println("企鹅吃鱼!");
        int newHealth=super.getHealth()+20;
        System.out.println("健康值为:"+newHealth);
        super.setHealth(newHealth);
    }
    @Override
    public void print() {
        super.print();
        System.out.println("企鹅的性别是:"+this.getSex());
    }
    public Penguin(String name, int health, int love,String sex) {
        super(name, health, love);
        this.sex=sex;
    }
    public Penguin() {
    }
}

public class Dog extends Pet{
    //狗类的品种
    private String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    @Override
    public void eat() {
        System.out.println("狗狗吃狗粮!");
        //吃完狗粮之后 健康值要增加
        int newHealth=super.getHealth();
        newHealth+=10;
        System.out.println("健康值为:"+newHealth);
        super.setHealth(newHealth);
    }
    public void print(){
        super.print();
        System.out.println("狗狗的品种是:"+this.strain);
    }
    public Dog(String name, int health, int love,String strain) {
        super(name, health, love);
        this.strain=strain;
    }

    public Dog() {
    }
}

public class Master {
    public void feed(Dog dog){
        System.out.println("给狗类喂食");
        dog.eat();
    }
    public void feed(Penguin penguin){
        System.out.println("给企鹅类喂食");
        penguin.eat();
    }
    public void feed(Pet pet){
        if(pet instanceof Dog){
            System.out.println("给狗类喂食");
            Dog dog=(Dog) pet;
            dog.eat();
        }else if(pet instanceof Penguin){
            System.out.println("给企鹅类喂食");
            Penguin penguin=(Penguin)pet;
            penguin.eat();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        Penguin penguin=new Penguin();
        Master master=new Master();
        master.feed(dog);
        master.feed(penguin);
        System.out.println("=============");
        Pet pet=new Dog();
        master.feed(pet);
        System.out.println("===============");
        Pet pet1=new Penguin();
        master.feed(penguin);
    }
}