13 多态-阿里云开发者社区

配套视频教程

问题

宠物饿了，需要主人给宠物喂食

不同宠物吃的东西不一样，狗吃骨头，企鹅吃鱼
不同宠物恢复后体力值不一样
狗狗类
增加狗狗吃食的方法
企鹅类
增加企鹅吃食的方法
创建主人类
编写给狗狗喂食的方法
编写给企鹅喂食的方法
编写测试方法
调用主人类给狗狗喂的方法
调用主人类给企鹅喂的方法

宠物父类

public abstract class Pet {
    private String name = "无名氏";// 昵称
    private int health = 100;// 健康值
    private int love = 0;// 亲密度
    /**
     * 抽象方法eat(),负责宠物吃饭功能。
     */
    public abstract void eat();
    /**
     * 有参构造方法。
     * @param name  昵称
     */
    public Pet(){
    }
    public Pet(String name) {
        this.name = name;
    }
    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 String getName() {
        return name;
    }
    public int getHealth() {
        return health;
    }
    public int getLove() {
        return love;
    }
    /**
     * 输出宠物信息。
     */
    public void print() {
        System.out.println("宠物的自白：\n我的名字叫" + this.name + 
                "，健康值是" + this.health + "，和主人的亲密度是"
                + this.love + "。");
    }   
}

狗类

public class Dog extends Pet {
    private String strain;// 品种
    /**
     * 有参构造方法。
     * @param name   昵称
     * @param strain   品种
     */
    public Dog(String name, String strain) {
        super(name); 
        this.strain = strain;
    }
    public String getStrain() {
        return strain;
    }
    /**
     * 重写父类的print方法。
     */
    public void print(){
        super.print(); //调用父类的print方法
        System.out.println("我是一只 " + this.strain + "。");
    }
    /**
     * 实现吃食方法。 
     */
    public void eat() {
        if(getHealth()>=100){
            System.out.println("狗狗"+this.getName() +"吃饱了，不需要喂食了！");
        }else{
            this.setHealth(this.getHealth()+3);
            System.out.println("狗狗"+this.getName() + "吃饱啦！健康值增加3。");
        }
    }
}

企鹅类

public class Penguin extends Pet {
    private String sex;// 性别
    /**
     * 有参构造方法。
     * @param name 昵称
     * @param sex 性别
     */
    public Penguin(String name, String sex) {
        super(name);
        this.sex = sex;
    }
    public String getSex() {
        return sex;
    }
    /**
     * 重写父类的print方法。
     */
    public void print() {
        super.print();
        System.out.println("性别是 " + this.sex + "。");
    }
    /**
     * 实现吃食方法。 
     */
    public void eat() {
        if(getHealth()>=100){
            System.out.println("企鹅"+this.getName() +"吃饱了，不需要喂食了！");
        }else{
            this.setHealth(this.getHealth()+5);
            System.out.println("企鹅"+this.getName() + "吃饱啦！健康值增加3。");
        }
    }
}

主人类

public class Master {
    private String name = "";// 主人名字
    private int money = 0; // 元宝数
    /**
     * 有参构造方法。
     * @param name 主人名字
     * @param money 元宝数
     */
    public Master(String name, int money) {
        this.name = name;
        this.money = money;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
    public String getName() {
        return name;
    }
    /**
     * 主人给Dog喂食。
     */
    public void feed(Dog dog) {
        dog.eat();
    }
    /**
     * 主人给Penguin喂食。
     */
    public void feed(Penguin pgn) {
        pgn.eat();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("欧欧", "雪娜瑞");
        dog.setHealth(80); //设置健康值，以便正常喂食
        Penguin pgn = new Penguin("楠楠", "Q妹");
        Master master=new Master("王先生",100);
        master.feed(dog);//主人给狗狗喂食
        master.feed(pgn);//主人给企鹅喂食
        pgn.setHealth(80); //设置健康值，以便正常喂食
        master.feed(pgn);//主人再次给企鹅喂食
    }
}

如果再领养新种类XXX的宠物，就需要给XXX喂食，怎么办？

添加XXX类，继承Pet类，实现吃食方法
修改Master类，添加给XXX喂食的方法

public class Master {
       public void feed( Dog dog ) {
              dog.eat();
       } 
    public void feed( Penguin pgn ) {
               pgn.eat();
        }
    public void feed( XXX xxx ) {
               xxx.eat();
        }
        … …
}

频繁修改代码，代码可扩展性、可维护性差，如何优化？

使用多态优化设计

参数都是Pet类的子类

可否使用一个feed(Pet pet)实现对所有宠物的喂食？

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

使用多态实现思路

编写父类
编写子类，子类重写父类方法
运行时，使用父类的类型，子类的对象
Pet pet = new Dog();

使用父类作为方法形参实现多态

使用多态优化主人给宠物喂食

public class Master {
//使用父类作为方法形参 
    public void feed( Pet pet ) {
           pet.eat();         
    }
}

测试类的改变

Pet pet = new Dog();
Master master = new Master();
master.feed( pet );//同一种操作方式，不同的操作对象

练习

使用多态实现喂养宠物功能

增加宠物猫并喂食，其健康值增加4

计算一次租赁多辆汽车的总租金

在继承章节汽车租赁系统的基础上，实现计算多种车辆总租金的功能

现在有客户租用

2辆宝马

1辆别克商务舱

1辆金龙（34）座

租5天共多少租金？

解题思路

1、创建车的对象，放在数组中

MotoVehile[] motos = new MotoVehile[4];
motos[0] = new Car("宝马550i","京NY28588");
motos[1] = new Car("宝马550i","京NNN328");
motos[2] = new Car("别克林荫大道","京NY28588");
motos[3] = new Bus("金龙",34);

2 循环调用calcRent()方法，计算总租金

public int calcTotalRent(MotoVehile[] motos,int days){
       int totalRent = 0; 
       for(int i=0;i<motos.length;++i){
            totalRent += motos[i].calRent(days);
       } 
       return totalRent;
}

假设新增了一种对外出租的车辆类型

新购置了卡车，根据吨位，租金每吨每天50

对系统进行扩展，计算汽车租赁的总租金

解题思路

1.创建卡车类，实现calcRent ()方法

2.修改统计租金代码

public abstract class MotoVehicle {
    private String no;//车牌号
    private String brand;//品牌
    abstract int calRent(int days);//计算租金
    public MotoVehicle()
    {
    }
    public MotoVehicle(String no, String brand)
    {
        this.no = no;
        this.brand = brand;
    }
    public String getNo() {
        return no;
    }
    public void setNo(String no) {
        this.no = no;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
}

public class Car extends MotoVehicle{
    public Car(String no, String brand)
    {
        super(no,brand);
    }
    @Override
    int calRent(int days) {
        if(getBrand().equals("宝马"))
        {
            return 500 * days;
        }
        else
        {
            return 600 * days;
        }
    }
}

public class Kache extends MotoVehicle {
    private int dunwei;//吨位
    public Kache(int dunwei)
    {
        this.dunwei = dunwei;
    }
    @Override
    int calRent(int days) {
        return 50*dunwei*days;
    }
}

不用多态的实现方式

Car[] cars = new Car[3];
        cars[0] = new Car("辽A12345","宝马");
        cars[1] = new Car("辽B22222","别克");
        cars[2] = new Car("辽A62222","奔驰");
        Kache[] kaches = new Kache[2];
        kaches[0] = new Kache(1);//150
        kaches[1] = new Kache(4);//600
        int total = 0;
        for(int i = 0; i < cars.length; i++)
        {
            total += cars[i].calRent(3);
        }
        for(int i = 0; i < kaches.length; i++)
        {
            total += kaches[i].calRent(3);
        }
        System.out.println("总租金" + total);//5850

使用多态实现

MotoVehicle[] motoVehicles = new MotoVehicle[5];
        motoVehicles[0] = new Car("辽A12345","宝马");
        motoVehicles[1] = new Car("辽B22222","别克");
        motoVehicles[2] = new Car("辽A62222","奔驰");
        motoVehicles[3] = new Kache(1);
        motoVehicles[4] = new Kache(4);
        int total = 0;
        for(int i = 0; i < motoVehicles.length; i++)
        {
            total += motoVehicles[i].calRent(3);
        }
        System.out.println("总租金" + total);

一个练习

工资支付系统

定义一个Employee抽象基类（name）

公司有以下几种员工：

开发人员：工资计算方式，每月固定工资

销售人员：底薪+提成

硬件工程师：生产零件，每个50元

小时工：按工作时间付工资，每小时30元

主类（测试类）

创建不同类型的6名员工对象，计算他们应付的月工资之和

public abstract class Employee {
    private String name;
    public Employee(String name)
    {
        this.name = "@" + name + "@" ;
    }
    protected abstract int paySalary();
}

//开发人员
public class Developer extends Employee{
    private int salary;
    public Developer(String name, int salary)
    {
        super(name);
        this.salary = salary;
    }
    @Override//方法重写注解
    protected int paySalary() {
        return salary;
    }
}

//销售人员
public class SaleMan extends Employee{
    private int salary;
    private int comm;//提成
    public SaleMan(String name, int salary, int comm)
    {
        super(name);
        this.salary = salary;
        this.comm = comm;
    }
    @Override
    protected int paySalary() {
        return salary + comm;
    }
}

//硬件工程师
public class HardwareEngineer extends Employee {
    private int productCount;//每月生产的零件数量
    public HardwareEngineer(String name, int productCount)
    {
        super(name);
        this.productCount = productCount;
    }
    @Override
    protected int paySalary() {
        return 50*productCount;
    }
}

//小时工
public class HourlyWorker extends Employee{
    private int hours;//这个月工作了多少小时
    public HourlyWorker(String name, int hours)
    {
        super(name);
        this.hours = hours;
    }
    @Override
    protected int paySalary() {
        return 30*hours;
    }
}

public class Boss extends Employee {
    public Boss(String name)
    {
        super(name);
    }
    @Override
    protected int paySalary() {
        return 200000;
    }
}

public class Main {
    public static void main(String[] args) {
    // write your code here
        Employee[] employees = new Employee[6];
        employees[0] = new Developer("张二",5000);
        employees[1] = new Developer("张三",5000);
        employees[2] = new SaleMan("李四", 2000, 500);
        employees[3] = new HardwareEngineer("王五", 200);
        employees[4] = new HourlyWorker("冯六",200);
        employees[5] = new Boss("赵本山");
        //计算总工资
        int total = 0;
        for(int i = 0; i < employees.length; i++)
        {
            total += employees[i].paySalary();
        }
        System.out.println("总共需要支付" + total);
    }
}

13 多态

配套视频教程

问题

如果再领养新种类XXX的宠物，就需要给XXX喂食，怎么办？

练习

计算一次租赁多辆汽车的总租金

解题思路

假设新增了一种对外出租的车辆类型

解题思路

使用多态实现

一个练习

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

13 多态

配套视频教程

问题

如果再领养新种类XXX的宠物，就需要给XXX喂食，怎么办？

练习

计算一次租赁多辆汽车的总租金

解题思路

假设新增了一种对外出租的车辆类型

解题思路

使用多态实现

一个练习

热门文章

最新文章

相关电子书