3.多态

测试类：

package cn.jbit.epettest;

import cn.jbit.epetshop.Dog;
import cn.jbit.epetshop.Master;
import cn.jbit.epetshop.Penguin;

/**
 * 测试类
 * 
 * @author kyaccp
 * 
 */
public class EpetTest {

	/**
	 * 程序入口
	 * 
	 * @param args
	 *            输入的参数
	 */
	public static void main(String[] args) {
		// 创建一个狗狗对象
		Dog dog = new Dog("欧欧", 100, 0, "娜娜雪瑞");
		// 创建一个企鹅对象
		Penguin penguin = new Penguin("楠楠", 100, 0, "Q仔");
		// 创建一个主人对象
		Master master = new Master();
		master.feed(dog); // 调用喂食方法
		master.play(dog); // 调用玩耍方法
		master.feed(dog); // 调用喂食方法

		System.out.println();
		master.feed(penguin); // 调用喂食方法
		master.play(penguin); // 调用玩耍方法
		master.feed(penguin); // 调用喂食方法

	}
}

 

实体类：

package cn.jbit.epetshop;

/**
 * 宠物类
 * 
 * @author chaoyi
 * @2013-10-17 上午09:25:09
 */
public abstract class Pet {
	/**
	 * 无参构造函数
	 */
	public Pet() {

	}

	/**
	 * 带参构造函数
	 * 
	 * @param name
	 *            昵称
	 * @param health
	 *            健康值
	 * @param love
	 *            亲密度
	 */
	public Pet(String name, int health, int love) {
		this.setName(name);
		this.setHealth(health);
		this.setLove(love);
	}

	private String name; // 昵称

	/**
	 * 读取昵称
	 * 
	 * @return 昵称
	 */
	public String getName() {
		return name;
	}

	/**
	 * 指定昵称
	 * 
	 * @param name
	 *            昵称
	 */
	public void setName(String name) {
		this.name = name;
	}

	private int health = 100; // 健康值

	/**
	 * 读取健康值
	 * 
	 * @return 健康值
	 */
	public int getHealth() {
		return health;
	}

	/**
	 * 指定健康值
	 * 
	 * @param health
	 *            健康值
	 */
	public void setHealth(int health) {
		if (health >= 0 && health <= 100) {
			this.health = health;
		} else {
			health = 40;
			System.out.println("健康值应该在0~100之间，默认值是40");
		}

	}

	private int love = 0; // 亲密度

	/**
	 * 读取亲密度
	 * 
	 * @return 亲密度
	 */
	public int getLove() {
		return love;
	}

	/**
	 * 指定亲密度
	 * 
	 * @param love
	 *            亲密度
	 */
	public void setLove(int love) {
		this.love = love;
	}

	/**
	 * 输出信息
	 */
	public abstract void print();

	/**
	 * 实现吃的方法
	 */
	public abstract void eat();
}

 

 

package cn.jbit.epetshop;

/**
 * 主人类
 * 
 * @author kyaccp
 * 
 */
public class Master {
	/**
	 * 主人给宠物喂食方法
	 * 
	 * @param pet
	 *            宠物对象
	 */
	public void feed(Pet pet) {
		pet.eat(); // 调用吃的方法
	}

	/**
	 * 宠物玩耍方法
	 * 
	 * @param pet
	 *            宠物对象
	 */
	public void play(Pet pet) {
		if (pet instanceof Dog) { // 如果传入的是狗狗
			Dog dog = (Dog) pet;
			dog.catchingFly(); // 调用狗狗玩飞盘游戏方法
		} else if (pet instanceof Penguin) { // 如果传入的是企鹅
			Penguin penguin = (Penguin) pet;
			penguin.swimming(); // 调用企鹅游泳方法

		}
	}
}

 

package cn.jbit.epetshop;

/**
 * 宠物狗狗类
 * 
 * @author Administrator
 * 
 */
public class Dog extends Pet {

	private String strain; // 品种

	/**
	 * 读取品种
	 * 
	 * @return 品种
	 */
	public String getStrain() {
		return strain;
	}

	/**
	 * 指定品种
	 * 
	 * @param love
	 *            品种
	 */
	public void setStrain(String strain) {
		this.strain = strain;
	}

	/**
	 * 无参构造函数
	 */
	public Dog() {
	}

	/**
	 * 带参构造函数
	 * 
	 * @param name
	 *            昵称
	 * @param health
	 *            健康值
	 * @param love
	 *            亲密度
	 * @param strain
	 *            品种
	 */
	public Dog(String name, int health, int love, String strain) {
		super(name, health, love);
		this.setStrain(strain);
	}

	/**
	 * 输出狗狗信息
	 */
	public void print() {
		System.out.println("宠物 的自白：\n我的名字叫" + super.getName() + "，健康值是"
				+ super.getHealth() + "，和主人的亲密度是" + super.getLove() + "，我是一只"
				+ this.strain + "。");
	}

	/**
	 * 实现狗狗吃饭的方法
	 */
	public void eat() {
		int health; // 健康值
		if (super.getHealth() <= 95) {
			health = super.getHealth() + 5;
			if (health > 100) // 表示健康值大于100
				health = 100;
			super.setHealth(health);// 设置健康值
			System.out.println("狗狗" + super.getName() + "吃饱啦！健康值增加5。");
		} else {
			System.out.println("狗狗" + super.getName() + "已经吃饱啦！不需要再喂食了。");
		}
	}

	/**
	 * 狗狗玩飞盘游戏
	 */
	public void catchingFly() {
		super.setHealth(getHealth() - 10); // 健康值减少10
		if (getHealth() < 0)
			setHealth(0);
		super.setLove(getLove() + 5); // 亲密度增加5
		System.out.println("狗狗" + super.getName() + "正在接飞盘。");
	}

}

 

package cn.jbit.epetshop;

/**
 * 宠物企鹅类
 * 
 * @author Administrator
 * 
 */
public class Penguin extends Pet {

	public final static String SEX_MALE = "Q仔"; // 性别
	public final static String SEX_FEMALE = "Q妹"; // 性别
	private String sex = SEX_FEMALE; // 性别

	/**
	 * 读取性别
	 * 
	 * @return 性别
	 */
	public String getSex() {
		return sex;
	}

	/**
	 * 指定性别
	 * 
	 * @param love
	 *            性别
	 */
	public void setSex(String sex) {
		this.sex = sex;
	}

	/**
	 * 无参构造方法
	 */
	public Penguin() {
	}

	/**
	 * 带参构造方法
	 * 
	 * @param name
	 *            昵称
	 * @param health
	 *            健康值
	 * @param love
	 *            亲密度
	 * @param sex
	 *            性别
	 */
	public Penguin(String name, int health, int love, String sex) {
		super(name, health, love);
		this.setSex(sex);
	}

	/**
	 * 输出企鹅信息
	 */
	public void print() {
		System.out.println("宠物 的自白：\n我的名字叫" + super.getName() + "，健康值是"
				+ super.getHealth() + "，和主人的亲密度是" + super.getLove() + "，性别是"
				+ this.sex + "。");
	}

	/**
	 * 实现企鹅吃饭的方法
	 */
	public void eat() {
		int health; // 健康值
		if (super.getHealth() <= 95) {
			health = super.getHealth() + 5;
			if (health > 100) // 表示健康值大于100
				health = 100;
			super.setHealth(health); // 设置健康值
			System.out.println("企鹅" + super.getName() + "吃饱啦！健康值增加5。");
		} else {
			System.out.println("企鹅" + super.getName() + "已经吃饱啦！不需要再喂食了。");
		}
	}

	/**
	 * 企鹅游泳方法
	 */
	public void swimming() {
		super.setHealth(getHealth() - 10); // 健康值减少10
		super.setLove(getLove() + 5); // 亲密度增加5
		System.out.println("企鹅" + super.getName() + "正在游泳。");
	}

}

 

多态（Polymorphism）是具有表现多种形态的能力的特征。更专业化的说法是：同一个实 现接口，使用不同的实例而执行不同的操作。

instanceof运算符
对象 instanceof 类或接口
该运算符用来判断一个对象是否属于一个类或者实现了一个接口 ，结果为true或false。在强制类型转换之前通过instanceof运算符检查对象的真实类型，然后再进行相应的强制类型转换，这 样就可以避免类型转换异常，从而提高代码健壮性。

通过多态可以减少类中代码量，可以提高代码的可扩展性和可维护性。继承是多态的基础，没有继承就没有多态。

把子类转换为父类，称为向上转型，自动进行类型转换。把父类转换为子类，称为向下转型，必须进行强制类型转换。

向上转型后可以访问子类特有的方法。必须转换为父类指向的真实子类类型，否则将出现类型转换异常ClassCastException 。

instanceof运算符用于判断一个对象是否属于一个类或实现了一个接口。

instanceof运算符通常和强制类型转换结合使用，首先通过instanceof进行类型判断，然后进行相应的强制类型转换。

使用父类作为方法形参是使用多态的常用方式。 

个人E-mail：chaoyi77@163.com