多态

面向对象 多态

多态性：多态性是指允许不同 类的对象对同 一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同 名问题。
多态在程序设计中，为程序提供了 [可插拔性]
多态说白了就是，一种类型，多种形态，对象在创建时是父类形态，在使用时是子类形态。

package pm01;
/**
 * 宠物类
 *
 *
 */

public class Pet {
	private String name;
	private int age;
	private int health;
	private int love;
	
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}

	public int getAge(){
		return age;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	
	public int getHealth(){
		return health;
	}
	
	public void setHealth(int health){
		this.health = health;
	}
	
	
	public int getLove(){
		return love;
	}
	
	public void setLove(int love){
		this.love = love;
	}
	
	public Pet(){
		
	}
	public Pet(String name,int age,int health,int love){
		this.name = name;
		this.age = age;
		this.health = health;
		this.love = love;
	}
	
	public void eat(){
		
	}


}

package pm01;
/**
 * 企鹅类 继承宠物类
 *
 *
 */
public class Penguin extends Pet{
	private String sex;
	public String getSex(){
		return sex;
		
	}

	public void setSex(String sex){
		this.sex = sex;
		
	}
	
	public Penguin(){
		
	}
	public Penguin(String name, int age, int health,int love,String sex){
		super(name,age,health,love);
		this.sex = sex;
	}
	
	public String toString(){
		return  "宠物的名字是："+getName()+"\t年龄："+getAge()+"\t性别"+getSex()+"\t健康值："+getHealth()+"\t亲密度："+getLove();
	}
	public void eat(){
		System.out.println("企鹅吃鱼，哦哦哦");
		setHealth(getHealth()+1);
		System.out.println("企鹅的健康值是："+getHealth());
	}
	public void swmming(){
		System.out.println("企鹅游泳，哦哦哦");
		setHealth(getHealth()-2);
		setLove(getLove()+1);
		System.out.println("企鹅的健康值："+getHealth()+"\t和主人的亲密度；"+getLove());
	}

}

package pm01;
/**
 * 
 * Dog类 继承宠物类
 * 
 *
 */

public class Dog extends Pet{
private String cloro;
	
	public String getCloro(){
		return cloro;
	}
	public void setCloro(String cloro){
		this.cloro = cloro;
	}
	public Dog (){
		
	}
	public Dog(String name,int age,int health,int love,String cloro){
		super(name,age,health,love);
		this.cloro = cloro;
		}
	
	public String toString(){
		return  "宠物的名字是："+getName()+"\t年龄："+getAge()+"\t健康值："+getHealth()+"\t亲密度："+getLove()+"\t颜色是："+getCloro();
	}
	
	public void eat(){
		System.out.println("狗吃骨头，汪汪");
		setHealth(getHealth()+1);
		System.out.println("狗的健康值是:"+getHealth());
		
	}
	public void jie(){
		System.out.println("狗接飞盘，汪汪");
		setHealth(getHealth()-2);
		setLove(getLove()+1);
		System.out.println("狗的健康值是:"+getHealth()+"\t和主人的亲密度:"+getLove());
	}

}

package pm01;

public class Test {

	public static void main(String[] args) {
		Pet pet = new Penguin("qq",2,85,50,"雌");//子类赋值给父类。自动类型转换。向上转型。
		System.out.println(pet);
		pet.eat();
		pet = new Dog("大黄",5,90,95,"黄色");//子类赋值给父类。自动类型转换。向上转型。
		System.out.println(pet);
		pet.eat(); 多态的父类，拥有子类的多种形态，子类重写父类的方法。父类对象在调用方法时，运行子类的方法。
		
		
		if(pet instanceof Penguin){
			Penguin pen = (Penguin)pet;//父类强制转换成子类，需要加子类类型符号，向下转型。
			pen.swmming();
			
		}else if(pet instanceof Dog){
			Dog dog1 = (Dog)pet;//父类强制转换成子类，需要加子类类型符号，向下转型。
			dog1.jie();
		}

	}

}

子类赋值给父类。自动类型转换。向上转型。
父类强制转换成子类，需要加子类类型符号，向下转型。
多态：形成的必要因素：
1：必须有继承关系。
2：子类中需有方法的重写。
关键词：instanceof : 是否包含子类对象。