024、面向对象的三大基本特征-多态

一、多态概述
多态：同一个对象(事物)，在不同时刻体现出来的不同状态。
	举例：
		猫是猫，猫是动物。
		水(液体，固体，气态)。
		
	多态的前提：
		A:要有继承关系。
		B:要有方法重写。
			其实没有也是可以的，但是如果没有这个就没有意义。
				动物 d = new 猫();
				d.show();
				动物 d = new 狗();
				d.show();
		C:要有父类引用指向子类对象。
			父 f =  new 子();

二、多态中的成员访问特点：
		A:成员变量
			编译看左边，运行看左边。
		B:构造方法
			创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
		C:成员方法
			编译看左边，运行看右边。
		D:静态方法
			编译看左边，运行看左边。
			(静态和类相关，算不上重写，所以，访问还是左边的)
			
		由于成员方法存在方法重写，所以它运行看右边。

三、案例
class Fu {
	public int num = 100;

	public void show() {
		System.out.println("show Fu");
	}
	
	public static void function() {
		System.out.println("function Fu");
	}
}

class Zi extends Fu {
	public int num = 1000;
	public int num2 = 200;

	public void show() {
		System.out.println("show Zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}
	
	public static void function() {
		System.out.println("function Zi");
	}
}

class DuoTaiDemo {
	public static void main(String[] args) {
		//要有父类引用指向子类对象。
		//父 f =  new 子();
		Fu f = new Zi();
		System.out.println(f.num);
		//找不到符号
		//System.out.println(f.num2);
		
		f.show();
		//找不到符号
		//f.method();
		f.function();
	}
}

四、多态的好处：
		A:提高了代码的维护性(继承保证)
		B:提高了代码的扩展性(由多态保证)

五、案例
class Animal {
	public void eat(){
		System.out.println("eat");
	}
}

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

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

//针对动物操作的工具类
class AnimalTool {
	private AnimalTool(){}

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

class DuoTaiDemo2 {
	public static void main(String[] args) {
		//我喜欢猫，就养了一只
		Cat c = new Cat();
		c.eat();
		
		//我很喜欢猫，所以，又养了一只
		Cat c2 = new Cat();
		c2.eat();
		
		//我特别喜欢猫，又养了一只
		Cat c3 = new Cat();
		c3.eat();
		//...
		System.out.println("--------------");
		//问题来了,我养了很多只猫，每次创建对象是可以接受的
		//但是呢?调用方法，你不觉得很相似吗?仅仅是对象名不一样。
		//我们准备用方法改进
		//调用方式改进版本
		AnimalTool.useAnimal(c);
		AnimalTool.useAnimal(c2);
		AnimalTool.useAnimal(c3);
		System.out.println("--------------");
		
		//我喜欢狗
		Dog d = new Dog();
		Dog d2 = new Dog();
		Dog d3 = new Dog();
	
		AnimalTool.useAnimal(d);
		AnimalTool.useAnimal(d2);
		AnimalTool.useAnimal(d3);
		System.out.println("--------------");
	}
}

五、多态的弊端：
		不能使用子类的特有功能。

我就想使用子类的特有功能?行不行?
		行。
		
		怎么用呢?
			A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
			B:把父类的引用强制转换为子类的引用。(向下转型)
		
		对象间的转型问题：
			向上转型：
				Fu f = new Zi();
			向下转型：
				Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。	

六、案例
class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		f.show();
		//f.method();
		
		//创建子类对象
		//Zi z = new Zi();
		//z.show();
		//z.method();
		
		//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
		//如果可以，但是如下
		Zi z = (Zi)f;
		z.show();
		z.method();
	}
}