7.19 java-多态，抽象类

为了减少工作量，例如写get、set方法
推荐插件：小辣椒

例：
在父类中写一个方法
在子类中重写这个方法
修改Master的同名方法

master.cure(dog);// 传递的Pet的子类对象dog
传递的是子类的对象那么就会调用子类的重写方法

如果传递的是penguin类的对象，同理会调用penguin的重写方法

**多态：**同一个方法，传递不同的实例，执行不同的操作。增加代码的灵活性。

转型（了解）：
向上转型：子类实例向上转型为父类
好处：可以调用父类通用的方法。多态的需要
缺点：向上转型后就不能调用自己独有的方法。
Dog dog = new Dog()
Pet pet = dog;
想要调用自己独有的方法，需要向下转型

向下转型：转换成父类的实例再转换成子类

Dog dog2=(Dog)Pet
dog2.catchDisk();

抽象类

意义：

如果一个方法不需要方法体，那么可以把此方法变为抽象的

怎么变?

1. 去掉方法体的花括号
2. 在方法前加上 abstract
3. 把方法所在的类也加上 abstract

语法规定：抽象方法所在的类必须是抽象类

抽象类：一个普通的类 有abstract 修饰，就是抽象类

抽象类中可以有抽象方法，也可以有普通方法。

判断：
抽象类中都是抽象方法，语法不报错 对
抽象类中都是普通方法，语法不报错 对
抽象类中既有普通方法，又有抽象方法，语法不报错 对

概念：
继承一个抽象类，那么子类必须实现父类的抽象方法，或者子类必须也是抽象类

示例：包含了方法重写，转型，多态，抽象类知识

父类 定义成了抽象类，里面包含了普通方法和抽象方法

//父类 定义成了抽象类，里面包含了普通方法和抽象方法
public abstract class Pet {
	private String name;  	//名字
	private int health;		//健康值 0-10
	private int love;		//亲密度
	
	
	public Pet() {
		super();
		System.out.println("父类的无参构造函数");
	}
	public Pet(String name, int health, int love) {
		super();
		this.name = name;
		this.health = health;
		this.love = love;
	}


	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 int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}
	
	public void print() {
		System.out.println("这是一只宠物");
	}
	
	public abstract void tohospital();

}

子类，重写了父类方法，抽象类方法实现

public class Dog extends Pet {

//	private int health;		//健康值 0-10
	private String strain;
	
//	在无参的构造函数中，super()写不写都会调用父类的无参构造函数
	public Dog() {
		super();//访问父类的无参构造函数 必须在方法的第一行
		// TODO Auto-generated constructor stub
//		super不可以访问父类私有的属性和方法
		System.out.println("dog子类的无参构造函数");
	}
//	访问父类的有参构造函数
	public Dog(String name, int heath, int love,String strain) {
//		为什么必须在第一行
//		实例化的时候，把必须先实例化父类，才可以实例化子类
//		先有父，再有子
		super(name, heath, love);
		// TODO Auto-generated constructor stub
		this.strain = strain;
	}
	
	

	//	重写父类的方法，在调用的时候 优先调用自己的方法
	@Override
	public void print() {
		System.out.println("这是一只宠物狗");
	}
	@Override
	public void tohospital() {
		if (super.getHealth()< 5) {
			System.out.println("打针、吃药");
			super.setHealth(10);
		}
	}
//	接飞盘
	public void catchDisk() {
		System.out.println("接飞盘");
	}

}

子类，重写了父类方法，抽象类方法实现

public class Penguni extends Pet {
	
	private String sex;
	
	public Penguni() {
		super();
		// TODO Auto-generated constructor stub
	}
	

	public Penguni(String name, int health, int love,String sex) {
		super(name, health, love);
		// TODO Auto-generated constructor stub
		this.sex =sex;
	}


	@Override
	public void print() {
		System.out.println("这是一只宠物企鹅");
	}
	
	
	@Override
	public void tohospital() {
		if (super.getHealth()< 6) {
			System.out.println("疗养、吃药");
			super.setHealth(9);
		}
	}
	
//	自己独有的方法
	public void catchFish() {
		System.out.println("会捉鱼！");
		
	}
}

主人类：

//主人类
public class Master {

//	给宠物看病 有两种宠物，应该有两种方法
	
//	看病
	public void cure(Pet pet ) {
		pet.tohospital();
	}
	
	给企鹅看病
//	public void cure(Penguni penguni) {
//		if (penguni.getHealth() < 6) {
//			System.out.println("疗养、吃药");
//			penguni.setHealth(10);
//		}
//	}
}

测试类1：
测试多态性

public class Test {
	
	public static void main(String[] args) {
		
		//实例化dog
		Dog dog = new Dog("小黄", 3, 8, "秋田");
//		实例化主人
		Master master =new Master();
		System.out.println("看病前狗的健康值："+dog.getHealth());
//		看病
		master.cure(dog);// 传递的Pet的子类对象dog
		System.out.println("看病后狗的健康值："+dog.getHealth());
		
		Penguni penguni = new Penguni("琪琪", 4, 9, "ci");
		System.out.println("看病前企鹅的健康值："+penguni.getHealth());
//		看病
		master.cure(penguni);// 传递的Pet的子类对象dog
		System.out.println("看病后企鹅的健康值："+penguni.getHealth());
		
	}

}

测试类2：
测试向上和向下转型

public class Test2 {

	public static void main(String[] args) {
		//实例化一个对象
		Dog dog = new Dog();
		System.out.println(dog);
		
		Pet pet = dog;
		System.out.println(pet);
		pet.tohospital();
		pet.print();
		
		Dog dog2=(Dog)pet;  //向下转型
		dog2.catchDisk();	//调用子类独有的方法
		
		
	}

}

测试类3：
向下转型存在的坑

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//向下转型的坑
//		Dog----Pet----Penguin
		Dog dog = new Dog();
		Pet pet = dog;   //向上转型
//		Dog dog2 = (Dog)pet;
//		dog2.catchDisk();
		if (pet instanceof Penguni) {	//判断对象能不能向下转型成对应的类型
			Penguni penguni =(Penguni)pet;	//向下转型
			penguni.catchFish();
		}else {
			System.out.println("转换失败...");
		}

	}

}