城管希课堂之多态

多态就是一种事物的多种状态

多态的前提：

1.类和类之间，必须要有关系（继承关系）

2.必须要有方法的重写（没有方法重写的多态没有意义）

3.（核心）父类的引用（指针）指向子类的对象（空间）

多态的好处：

    提高了代码的扩展性，后期出现的功能，可以被之前的程序所执行。

多态的弊端：

    当使用多态的方式创建对象时，无法直接调用子类中特有的方法。

public class Demo01 {
	public static void main(String[] args) {
		// 本类的引用(本类的指针) 指向 本类的对象(空间)
		Cat cat = new Cat();
		cat.eat();
		
		//多态的对象创建方式
		//父类指针指向子类空间
		Animal aCat = new Cat();
		aCat.eat();
		Animal aDog = new Dog();
		aDog.eat();
		
	}
}
/*
 * 需求: 创建 动物类 猫类 狗类 都有一个吃的方法 
 * 动物类 动物吃饭 
 * 猫 猫吃鱼 
 * 狗 狗吃骨头
 */

class Animal {
	public void eat() {
		System.out.println("动物吃饭");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

public class Demo03 {
	public static void main(String[] args) {
		// 多态创建对象
		// 提升了骗子的逼格
		// 提升了子类对象的类型---向上转型
		Person p = new PianZi();
		p.speak();
		// 如何调用子类的特有方法
		// 把装成人的骗子 打回原型
		// 向下转型 使用强制类型转换
		PianZi pZ = (PianZi)p;
		//调用子类的特有方法
		pZ.hit();
		
	}
}

class Person{
	public void speak(){
		System.out.println("聊天");
	}
	
}
class PianZi extends Person{
	@Override
	public void speak() {
		System.out.println("洗你的脑");
	}
	//特有方法
	public void hit(){
		System.out.println("打人 威胁人");
	}
}

打僵尸例子

package com.lanou3g;

public class zuoye {
	public static void main(String[] args) {
		Tt tt = new Tt();
		tt.setBlood(200);
		da(tt);
		Mk mk = new Mk();
		mk.setBlood(300);
		da(mk);
	}
	public static void da(Js js){
		js.hit();
	}

}

class Js{
	private int blood;
	public Js() {
		// TODO Auto-generated constructor stub
	}
	public Js(int blood) {
		// TODO Auto-generated constructor stub
		this.blood=blood;
	}
	public int getBlood() {
		return blood;
	}
	public void setBlood(int blood) {
		this.blood = blood;
	}
	public void hit(){
		System.out.println("僵尸被打");
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
}

class Mk extends Js{
	@Override
	public void hit() {
		while (true) {
			if(this.getBlood()<=0){
				System.out.println("门框僵尸死了");
				break;
			}
			this.setBlood(this.getBlood()-5);
			System.out.println("剩余血量"+this.getBlood());	
		}
	}
}

class Tt extends Js{
	@Override
	public void hit() {
		if (this.getBlood()<=0) {
			System.out.println("铁桶僵尸死了");
			return;
		}
		this.setBlood(this.getBlood()-2);
		System.out.println("剩余血量"+this.getBlood());
		this.hit();
	}
}

多态如何使用成员变量和成员方法

 * 多态 如何使用成员变量?
 * 父类引用 只能访问子类空间中属于父类的那块空间
 * 编译:
 * 		编译时 要查看 父类中是否有这个属性 没有就编译错误
 * 运行:
 * 		运行时 访问是父类中 这个成员变量
 * 结论:当使用多态形式创建对象的时候
 * 访问成员变量时 编译和运行 都是看父类中的属性	
 * 
 * 
 * 多态 调用成员方法 
 * 编译:编译时 需要看父类中 是否有该方法 没有就报错
 * 有 就编译通过
 * 运行:运行时 调用是 子类重写父类的方法
 * 结论:编译看父类 运行看子类

多态调用子类的特有方法时，要注意：

必须要先有向上转型，才能进行向下转型。

lic class Demo03 {
	public static void main(String[] args) {
		// 多态创建对象
		// 提升了骗子的逼格
		// 提升了子类对象的类型---向上转型
		Person p = new PianZi();
		p.speak();
		// 如何调用子类的特有方法
		// 把装成人的骗子 打回原型
		// 向下转型 使用强制类型转换
		PianZi pZ = (PianZi)p;
		//调用子类的特有方法
		pZ.hit();
		
	}