JAVA面向对象(六)--多态

引言:面向对象三大特征：封装，继承，多态，前面我们已经学习了封装和继承，本章节我们来详细讲解多态，该章节知识点需要使用继承知识点，如果你还未学习继承，请出门右转，学习完再回来。

一、为什么使用多态：

讲解多态之前，我们先来看一个问题，实际需求中有两种动物，狗和企鹅，现在我们需要编写一个程序实现动物饿了，动物主人喂食的过程：

经过分析，我们发现两种动物有相同的属性(昵称：name,健康值：health,亲密度:love)和相同的方法(属性对应的set/get方法及相关打印方法)，那么对系统进行优化我们可以将两者相同属性和方法进一步 抽取形成共同的父类动物类,但是我们发现不同动物吃的东西不同，不同宠物吃完以后恢复的体力值不同，如果我们把动物吃东西的过程看做一个方法，那么两个类的吃东西的方法是不同的。

通过分析，我们可以得到以下类：

• 动物类：属性(共同属性),方法(共同方法)
• 狗类：属性(xx)，方法(狗吃食的方法)
• 企鹅类：属性(xx)，方法(企鹅吃食的方法)
• 动物主人类：属性(xx)，方法(给狗狗喂食的方法,给企鹅喂食的方法)
• 编写测试类：动物主人给狗喂食的方法，动物主人给企鹅喂食的方法

代码如下：

父类：

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喂食，怎么办？

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

这个时候我们就会发现问题了，对于上述代码，只要是有新的功能添加，我们就需要频繁修改代码，代码可扩展性、可维护性差，如何优化？ java中提供了一种解决方法-多态。

二、多态：

1.定义：

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

如我们上述的例子，动物主人需要给不同的动物喂食，都是实现喂食功能，但是喂食的对象实例不同，那么我们就可以使用多条进行实现。

2.多态存在的必然条件：

• 继承：编写具有继承关系的父类和子类
• 重写：子类重写父类方法
• 父类引用指向子类对象：Parent p = new Child(); -自动向上转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

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.多态的优点：

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性