多态

多态：可以理解为事物存在的多种体现形态
例如：人：男人、女人  动物：猫、狗

猫 x = new 猫();
动物 x = new 猫();

1.多态的体现
父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象
2.多态的前提
必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提：存在覆盖
3.多态的好处
多态的出现提高了程序的扩展性
4.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员

5.多态的应用

6.多态的出现代码中的特点（多态使用的注意事项）

abstract class Animal{
	public abstract void eat();
}

class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

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

class DuoTaiDemo{
	public static void main(String[] args){
		//Cat c = new Cat();
		//c.eat();

		//Dog d = new Dog();
		//d.eat();

		function(new Cat());
		function(new Dog());
	}

	public static void function(Animal a){
		a.eat();
	}
}

//类型提升，向上转型
Animal a = new Cat();
a.eat();

//如果想要调用猫的特有方法时，如何操作？
强制将父类的引用，转成子类类型。向下转型。
Cat c = (Cat)a;
c.catchMouse();


Animal a = new Animal();
Cat c = (Cat)a;//这样是不行的，不能将父类对象转成子类类型，
//我们能转换的是父类引用指向了自己的子类对象时，该对象可以被提升，也可以被转换

//多态至始至终都是子类对象在做着变化

public static void function(Animal a){
	a.eat();
	if(a instanceof Cat){
		Cat c = (Cat)a;
		c.catchMouse();
	}else if(a instanceof Dog){
		Dog d = (Dog)a;
		d.kanJia();
	}
}

在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败
在运行时期：参阅对象所属的类中是否有调用的方法
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边

在多态中成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）

在多态中，静态成员函数、变量的特点：

无论编译和运行都参考左边

class Fu{
	int num = 5;
	void method1(){
		System.out.println("fu methhod_1");
	}

	void method2(){
		System.out.println("fu methhod_2");
	}

	static void method4(){
		System.out.println("fu methhod_4");
	}
}

class Zi extends Fu{
	int num = 8;
	void method1(){
		System.out.println("zi methhod_1");
	}

	void method3(){
		System.out.println("zi methhod_3");
	}

	static void method4(){
		System.out.println("zi methhod_4");
	}
}

class DuoTaiDemo{
	public static void main(String[] args){
		//Zi z = new Zi();
		//z.method1();
		//z.method2();
		//z.method3();  //打印结果 zi1 fu2 zi3

		//Fu f = new Zi();
		//f.method1();
		//f.method2();
		//f.method3();
		//编译失败 父类中没有method3

		//Fu f = new Zi();
		//f.method1();
		//f.method2(); //打印结果 zi1 fu2 

		//Fu f = new Zi();
		//f.num;   //5

		//Zi z = new Zi();
		//z.num;   //8

		Fu f = new Zi();
		f.method4（）; // 打印结果 fu4

		Zi z = new Zi();
		z.method4（）;  // 打印结果 zi4
	
	}
}