多态的两种声明

1.参数传递的形式：

        多态的语法：  父类    变量名     =       new     子类名（）；

package Test;

import domin.Cat;
import domin.Master;
import domin.Per;

public class test {
    public static void main(String[] args) {
        // 多态实现
        Per per =  new Cat();
        Master master = new Master();
        master.feet(per);
    }
}

主类中，需要通过多态的方式进行声明化，声明的语法方式为：

父类    变量名     =       new     子类名（）；

同时对master进行实例化，调用master中的喂养方法。

package domin;

public class Master {
    public void feet(Per  per){
        per.eat();
        per.health();
    }
}

这一步是通过主人类调用带有继承关系的父类，对父类中抽象的方法进行调用。

package domin;

public abstract class Per {
    public abstract  void  eat();
    public abstract void  health();
}

父类方法的调用。

package domin;

public class Cat extends Per {
    private int healthValue=61;//猫健康值,快饿了

    public int getHealthValue() {
        return healthValue;
    }

    public void setHealthValue(int healthValue) {
        this.healthValue = healthValue;
    }

    
    @Override
    public void  eat() {
        System.out.println("小猫吃猫粮，还吃鱼罐头");;
    }

    @Override
    public void health() {
        System.out.println("小猫的饱食度增加90%,健康值在原有的"+healthValue+"的基础上增加4，现在" +
                "健康值为："+(healthValue+4));
    }

}

子类只需要实现对应的抽象方法的创建即可。

2.返回值形式的调用（与第一种方法类似）

完整代码如下：

package com.isc.test;

import com.isc.domin.Dog;
import com.isc.domin.Master;
import com.isc.domin.Penigun;
import com.isc.domin.Per;

public class Test {
    public static void main(String[] args) {
        // 多态的声明
        Master master = new Master();
        Per per =  new Dog(60,60) ;
        master.Play(per);
        per = new Penigun(80,80);
        master.Play(per);


    }
}

package com.isc.domin;

public class Master {
    public Per Play(Per per){
        if(per instanceof Dog){
            Dog dog = (Dog)per;
            dog.setHealth(dog.getHealth()-10);
            dog.setInitmate(dog.getInitmate()+5);
            dog.DogPlay();
        }else if(per instanceof Penigun){
            Penigun penigun = (Penigun)per;
            penigun.setHealth(penigun.getHealth()-10);
            penigun.setInitmate(penigun.getInitmate()+5);
            penigun.PenigunPlay();
        }

        return per;
    }
}

package com.isc.domin;

public class Per {
    private int health;
    private int initmate;

//    public Per(int health, int initmate) {
//        this.health = health;
//        this.initmate = initmate;
//    }


    public int getHealth() {
        return health;
    }

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

    public int getInitmate() {
        return initmate;
    }

    public void setInitmate(int initmate) {
        this.initmate = initmate;
    }
}

package com.isc.domin;

public class Penigun extends  Per{
    public Penigun(int health, int initmate) {
        this.setHealth(health);
        this.setInitmate(initmate);
    }

    public void  PenigunPlay() {
        System.out.println("主人和企鹅玩游泳游戏，企鹅的健康值减少10，与主人的亲密度增加5");
        System.out.println("企鹅现在的健康值为："+ super.getHealth()+",与主人的亲密度为："+super.getInitmate());
    }

}

package com.isc.domin;

public class Dog extends Per{

    public Dog(int health, int initmate) {
        this.setHealth( health);
        this.setInitmate( initmate);
    }

    public void  DogPlay() {
        System.out.println("主人和狗狗玩飞盘游戏，狗狗的健康值减少10，与主人的亲密度增加5");
        System.out.println("狗狗现在的健康值为："+ super.getHealth()+",与主人的亲密度为："+super.getInitmate());
    }

}

第二种方式主要涉及到面向对象（三大特性）和构造函数的用法。

总结：

1. 参数传递：把 Cat 当 Per 传给 Master 的 feed。

2. 返回值：Master 接收 Dog/Penguin（Per 型），处理后仍以 Per 返回。