多态（Java)

同一事物，由于条件的不同，产生的结果不同。

多态：同一引用类型，使用不同的实例而执行不同的操作。

1.实现多态的必要条件：

        继承：有继承关系的子类和父类；

        重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

        向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

2.实现多态的主要方式：

        使用父类作为方法的形参，是java中实现和使用多态的主要方式。
        使用父类作为方法的返回值，也是java中实现和使用多态的主要方式。

3.代码实现：

1.Pet类：声明name、health、love属性，并定义了kanBing（）方法等方法.

​
public class Pet {
    private String name;
    private int health;
    private int love;

    public Pet(String name, int health, int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }

    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

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

    public int getLove() {
        return love;
    }

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

    public void kanBing(){

    }
}

​

2.Dog类和Penguin类：定义了独有属性type和sex，重写了kanBing（）方法。

public class Dog extends Pet{
    private String type;

    public Dog(String name, int health, int love, String type) {
        super(name, health, love);
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public void kanBing() {
        if(this.getHealth()<60){
            this.setHealth(80);
            System.out.println(this.getType()+"打针吃药...");
            System.out.println("健康值："+this.getHealth());
        }
    }
}

public class Penguin extends Pet{
    private String sex;

    public Penguin(String name, int health, int love, String sex) {
        super(name, health, love);
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

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

    @Override
    public void kanBing() {
        if (this.getHealth()<50){
            this.setHealth(90);
            System.out.println(this.getSex()+"吃药疗养...");
            System.out.println("健康值："+this.getHealth());
        }
    }
}

3.Master类：使用父类作为方法的形参，是java中实现和使用多态的主要方式

public class Master {
    public void cure(Pet pet){
        pet.kanBing();
    }
}

4.测试类：

public class Test {
    public static void main(String[] args) {
        Pet pet;
        pet = new Dog("小小",40,70,"萨摩耶");
        Master master = new Master();
        master.cure(pet);
        System.out.println();

        pet = new Penguin("笑笑",30,90,"Q妹");
        master.cure(pet);
    }
}

运行结果：

4.向上转型和向下转型

1.向上转型：父类的引用指向子类对象（子类转父类），自动进行类型转换。

<父类型> <引用变量名> = new <子类型>();

通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。

通过父类引用变量无法调用子类特有的方法。

2.向下转型：将一个指向子类对象的父类引用赋给一个子类引用，（父类转换为子类）需要强制类型转换。

<子类型> <引用变量名> =(<子类型>) <父类型应用变量>;

在向下转型的时候，如果没有转换为真实的子类类型，会出现转换异常。

3.instanceof运算符：Java中为了提高向下转换的安全性，引入了instanceof。如果表达式为true，则可以安全转换。

5.实例：

（父类）Animals类：

public class Animals {
    public String type;//动物的类型
    public String food;
    public Animals() {
    }

    public Animals(String type,String food) {
        this.type = type;
        this.food = food;
    }
    public void eat(){
        System.out.println(type+"吃"+food);
    }
}

（子类）Dog类：

public class Dog extends Animals{
    public String action;
    public Dog() {
        super();
    }

    public Dog(String type, String food,String action) {
        super(type, food);
        this.action =action;
    }

    @Override
    public void eat() {
        System.out.println(type+"爱吃"+food);
    }
    public void run(){
        System.out.println(type+"爱"+action);
    }
}

（子类）Cat类：

public class Cat extends Animals{
    public String action;

    public Cat() {
        super();
    }

    public Cat(String type, String food, String action) {
        super(type, food);
        this.action = action;
    }
    @Override
    public void eat() {
        System.out.println(type+"爱吃"+food);
    }
    public void tiao(){
        System.out.println(type+"爱"+action);
    }
}

（测试类）AnimalsTest类：

public class AnimalsTest {
    public static void main(String[] args) {

        Animals animals1 = new Dog("狗","骨头","奔跑");
        Animals animals2 = new Cat("猫","鱼","跳");
        Animals animals3 = new Animals("动物","食物");

        //向上转型
        animals1.eat();
        animals2.eat();
        animals3.eat();
        System.out.println();
        //向下转型<子类型> <引用变量名> =(<子类型>) <父类型应用变量>;
        Dog dog = (Dog) animals1;
        ((Dog) animals1).run();


        Cat cat = (Cat) animals2;
        ((Cat)animals2).tiao();
        System.out.println();
        //instanceof
        /*if (animals1 instanceof DuoTaiZhuanXing.Dog) {
            DuoTaiZhuanXing.Dog dog = (DuoTaiZhuanXing.Dog) animals1;
            ((DuoTaiZhuanXing.Dog) animals1).run();
        }else{
            System.out.println("Animals无法向下转型为Dog!");
        }

        if (animals2 instanceof DuoTaiZhuanXing.Cat) {
            DuoTaiZhuanXing.Cat cat = (DuoTaiZhuanXing.Cat) animals2;
            ((DuoTaiZhuanXing.Cat)animals2).tiao();
        }else{
            System.out.println("Animals无法向下转型为Cat!");
        }*/
    }
}

运行结果：