java基础——多态

1. 什么是多态？

一种对象的多种形态

2. 多态的体现

1. 方法的重载和重写
2. 继承和接口的实现：子类对象的多态性：父类的引用指向子类的实例 Pet p=new Dog（）

3. 程序分为两种状态，编译时状态，运行时状态

对多态来说，编译期间看左边，讲变量类型看做是宠物类对象
运行时，看右边，真正执行的对象，也就是子类对象，执行时会把p1看做dog对象，调用就是子类重写父类后的方法

4. 上转型和下转型

上转型：将子类对象交给父类引用，可以自动转
下转型：把父类转成子类，强制类型转换

pet类

//宠物类
public class Pet {
	
	private String name;//名称
	protected int  health=100;//健康值
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public Pet() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Pet(String name, int health) {
		super();
		this.name = name;
		this.health = health;
	}
	public Pet(String name) {
		super();
		this.name = name;
	}
	public Pet(int health) {
		super();
		this.health = health;
	}
	
	//输出宠物信息
	public void info(){
		System.out.println("我的名字叫："+this.name+",我的健康值是："+this.health);
	}
	//宠物吃饭
	public void eat(){
		System.out.println("宠物吃饭");
	
	}
}

dog类

//狗类
public class Dog extends Pet {
	
	private String strain;//品种

	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}

	public Dog(String strain,String name) {
		super(name);
		this.strain = strain;
	}

	public Dog() {
		super();
	}
	
	//重写吃饭方法
	public void eat(){
		super.health+=3;
		System.out.println("狗狗吃饭了，健康值加3，健康值为："+this.health);
	}
	
	//重写输出的方法
	public void info(){
		super.info();
		System.out.println("我的品种是："+this.strain);
	}
	
	public  void sleep(){
		System.out.println("狗在呼呼大睡");
	}

}

penguin类

//企鹅
public class Penguin extends Pet {
	
	private String sex;//性别

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public Penguin(String name, String sex) {
		super(name);
		this.sex = sex;
	}

	public Penguin() {
		super();
	}
	
	//重写吃饭方法
	public void eat(){
		super.health+=5;
		System.out.println("企鹅吃饭了，健康值加5，健康值为："+this.health);
	}
		
	//重写输出的方法
	public void info(){
		super.info();
		System.out.println("我的性别是："+this.sex);
	}
	
	public  void swimming(){
		System.out.println("企鹅游泳");
	}

}

master类

//主人类
public class Master {
	
	private String hostName;

	public String getHostName() {
		return hostName;
	}

	public void setHostName(String hostName) {
		this.hostName = hostName;
	}

	public Master(String hostName) {
		super();
		this.hostName = hostName;
	}

	public Master() {
		super();
	}
	
	//给狗喂食
	public void feed(Dog dog){
		dog.eat();
	}
	
	//给企鹅喂食
	public void feed(Penguin p){
		p.eat();
	}
}

测试类

public class Test {

	public static void main(String[] args) {
		//创建一个宠物类
		Pet pet=new Pet("小金");
		pet.info();
		pet.eat();
		
		System.out.println("================================");
		//创建一个狗类对象
		Dog dog=new Dog("金毛", "小毛");
		//dog.eat();
		dog.info();
		
		//创建一个企鹅
		Penguin p=new Penguin("Q仔", "女");
		p.info();
		//p.eat();
		
		System.out.println("========================");
		Master m=new Master();
		m.feed(dog);//给狗喂食
		m.feed(p);
		System.out.println("=========================================");
		//子类对象的多态性:父类的引用指向子类的实例
		Pet p1=new Dog("泰迪", "小迪");//向上转型
		p1.info();
		//p1对象可不可以调用狗类独有的方法？
		//编译期间，程序会把p1看成是宠物类型，而宠物类里面没有sleep方法
		//p1.sleep();
		//现在就想通过p1调用sleep()怎么办呢？可以强制类型转换
		Dog dog1=(Dog)p1;//向下转型
		dog1.sleep();
		
		//p1转成了狗类对象
//		Penguin pe=(Penguin)p1;
//		pe.swimming();
		
		//instanceof:用于判断对象类型是否匹配
		if(p1 instanceof Dog){//p1对象是否是子类对象Dog的实例
			Dog dog2=(Dog)p1;
			dog2.sleep();
		}else if(p1 instanceof Penguin){
			Penguin pe=(Penguin)p1;
			pe.swimming();
		}
		
	}

}