引言:面向对象三大特征：封装，继承，多态，前面我们已经学习了封装和继承，本章节我们来详细讲解多态，该章节知识点需要使用继承知识点，如果你还未学习继承，请出门右转，学习完再回来。
一、为什么使用多态：
讲解多态之前，我们先来看一个问题，实际需求中有两种动物，狗和企鹅，现在我们需要编写一个程序实现动物饿了，动物主人喂食的过程：
经过分析，我们发现两种动物有相同的属性(昵称：name,健康值：health,亲密度:love)和相同的方法(属性对应的 set/get 方法及相关打印方法)，那么对系统进行优化我们可以将两者相同属性和方法进一步 抽取形成共同的父类动物类,但是我们发现不同动物吃的东西不同，不同宠物吃完以后恢复的体力值不同，如果我们把动物吃东西的过程看做一个方法，那么两个类的吃东西的方法是不同的。
通过分析，我们可以得到以下类：
代码如下：
父类：
package cn.hz;
/*** 宠物类，狗狗和企鹅的父类。 * * @author hz*/public class Pet { private String name = "无名氏";// 昵称 private int health = 100;// 健康值 private int love = 0;// 亲密度 /** * 有参构造方法。 * @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 + "。"); } }
复制代码
子类：
package cn.hz;
/** * 狗狗类，宠物的子类。 * * @author hz */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。"); } }}
复制代码
package cn.hz;
/** * 企鹅类，宠物的子类。 * * @author hz */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。"); } }}
复制代码
动物主人类：
package cn.hz;
/** * 主人类 * @author hz */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(); }}
复制代码
测试类：
package cn.hz;/** * 测试类，领养宠物并喂食。 * @author hz */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 喂食，怎么办？
这个时候我们就会发现问题了，对于上述代码，只要是有新的功能添加，我们就需要频繁修改代码，代码可扩展性、可维护性差，如何优化？ java 中提供了一种解决方法-多态。
二、多态：
1.定义：
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：
如我们上述的例子，动物主人需要给不同的动物喂食，都是实现喂食功能，但是喂食的对象实例不同，那么我们就可以使用多条进行实现。
2.多态存在的必然条件：
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
3.多态实现方式：
实现多态有两种方式：
使用父类作为方法形参实现多态
使用父类作为方法返回值实现多态
首先我们来看父类作为方法形参实现多态，以上述动物案例实现为例，添加新动物就需要对代码进行修改，例如我们添加一个新的宠物-猫的类，如果使用多态进行优化呢？
首先我们分析两种动物都需要有吃的方法，但是吃的东西和实现的结果不同，如果我们把吃东西看做方法，也就是方法体是不同的，如果我们把吃东西的方法在父类中定义成抽象方法，不同的子类去做不同的实现，那么我们在喂食的时候直接喂食父类，至于具体是子类我们不需要关系，等子类实例化以后，父类引用指向子类引用即可，这样我们的代码的扩展性就得到了极大的提升。
代码如下：
父类：定义为抽象类，编写抽象方法-吃东西的方法
package cn.hz;
/*** 宠物类，狗狗和企鹅的父类。 * @author hz*/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 + "。"); } }
复制代码
子类： 子类重写父类的抽象方法
package cn.hz;
/** * 企鹅类，宠物的子类。 * @author hz */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。"); } }}
复制代码
package cn.hz;
/** * 企鹅类，宠物的子类。 * @author hz */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。"); } }}
复制代码
package cn.hz;
/** * 狗狗类，宠物的子类。 * @author hz */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。"); } }}
复制代码
package cn.hz;/** * 猫类，宠物的子类。 * @author hz */public class Cat extends Pet { private String color;//颜色 public Cat(String name, String color) { super(name); this.color = color; } public void setColor(String color) { this.color = color; }
public String getColor() { return color; } /** * 实现吃饭方法 */ public void eat() { if(getHealth()>=100){ System.out.println("狗狗"+this.getName() +"吃饱了，不需要喂食了！"); }else{ this.setHealth(this.getHealth()+4); System.out.println("猫咪"+this.getName() + "吃饱啦！体力增加4。"); } }}
复制代码
宠物主人类： 喂食方法就一个，参数为父类
package cn.hz;
/** * 主人类。 * @author hz */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; } /** * 主人给宠物喂食。 */ public void feed(Pet pet) { pet.eat(); }}
复制代码
测试类： 父类引用指向子类对象
package cn.hz;/** * 测试类，领养宠物并喂食。 * @author hz */public class Test { public static void main(String[] args) { Dog dog = new Dog("欧欧", "雪娜瑞"); Penguin pgn = new Penguin("楠楠", "Q妹"); Cat cat=new Cat("Tomcat","黄色"); dog.setHealth(80); //设置健康值，以便正常喂食 pgn.setHealth(80); //设置健康值，以便正常喂食 cat.setHealth(80); //设置健康值，以便正常喂食 Master master=new Master("王先生",100); master.feed(dog);//主人给狗狗喂食 master.feed(pgn);//主人给企鹅喂食 master.feed(cat);//主人给猫喂食 }}
复制代码
通过对比我们可以发现，使用父类作为方法参数，使用时将具体子类传入，通过使用父类引用指向子类对象，这样可以极大减少代码的修改，从而提高代码的扩展性。
接着我们再来看父类作为返回值实现多态，如果我们现在有新的需求，编写代码实现动物的领养功能，如果按照传统方法，则我们需要在 master 类中定义不同动物的领养方法，如果用多态呢？那么我们只需要定义领养动物的方法的返回值为动物类，然后通过方法的具体判定返回不同的子类即可，代码相似，省略。
通过上述案例我们知道，不管是父类作为方法参数还是父类作为返回值实现多态，都极大的提高了代码的可扩展性，但是注意在使用多态时类型转换问题。
4.多态的优点：
消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性
评论