13多态
2018-05-29 本文已影响0人
十一_2bef
问题
宠物饿了，需要主人给宠物喂食
-
不同宠物吃的东西不一样，狗吃骨头，企鹅吃鱼
-
不同宠物恢复后体力值不一样
-
狗狗类
增加狗狗吃食的方法 -
企鹅类
增加企鹅吃食的方法 -
创建主人类
编写给狗狗喂食的方法
编写给企鹅喂食的方法 -
编写测试方法
调用主人类给狗狗喂的方法
调用主人类给企鹅喂的方法
宠物父类、
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();
}
}
测试类的改变
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 {
String name;
public abstract int calcSalary();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
开发人员
public class Developer extends Employee {
int salary;//每月工资
public Developer(int salary)
{
this.salary = salary;
}
@Override
public int calcSalary() {
return salary;
}
}
硬件工程师
public class HardwareEngineer extends Employee{
int num;
public HardwareEngineer(int num)
{
this.num = num;
}
@Override
public int calcSalary() {
return 50*num;
}
}
小时工
public class HourWorker extends Employee {
int hours;
public HourWorker(int hours)
{
this.hours = hours;
}
@Override
public int calcSalary() {
return 30*hours;
}
}
销售
int base_sal;
int comm;
public SalesMan(int base_sal, int comm)
{
this.base_sal = base_sal;
this.comm = comm;
}
@Override
public int calcSalary() {
return base_sal + comm;
}
}
主类
public class Main {
public static void main(String[] args) {
int index = 0;
Employee[] employees = new Employee[6];
employees[index++] = new Developer(10000);
employees[index++] = new SalesMan(2000,5000);
employees[index++] = new HardwareEngineer(120);
employees[index++] = new HourWorker(200);
employees[index++] = new HourWorker(300);
employees[index] = new HourWorker(500);
int sum = 0;
for(Employee employee : employees)
{
sum += employee.calcSalary();
}
System.out.println(sum);
}
}
