多态的好处

多态
1、多态：同一个对象，在不同时刻体现出来的不同状态。
2、多态的前提：
  1）要有继承关系或实现关系（接口）；
  2）要有方法重写；
  3）要有父类或者父接口引用指向子类`Fu f= new Zi()；
    注意：形参实参形式的（形参父类实参子类）。
3、多态的分类：
  1）具体类多态

class Fu{}
class Zi extends Fu{}

Fu f= new Zi()//父类引用指向子类

2）抽象类多态（常用）

abstract class Fu{}
class Zi extends Fu{}

Fu f= new Zi();//抽象父类引用指向子类

3）接口多态（常用）

interface Fu{}
class Zi implements Fu{}

Fu f= new Zi();//父接口引用指向子类

多态中成员访问特点
如:

Fu f= new Zi();//左父类右子类

重点：成员方法，运行时，结果为子类重写的成员方法的结果。

成员变量：编译看左边，运行看左边。
构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
成员方法：编译看左边，运行看右边。（方法重写的意义）
静态方法：编译看左边，运行看左边。静态和类相关，算不上重写，所以访问还是左边的。

提醒：理解这些的时候要记得继承啊方法重写它们存在的意义所在。就好理解啦。
意义：
子类拥有父类的所有属性和方法(关键字private修饰的属性和方法除外)
实现代码复用

多态的好处
提高了代码的维护性（继承保证）；提高了代码的扩展性。
原代码，不易扩展：
（借用本代码，也进一步理解一下工具类）

//父类：动物类
class Animal{
	public void eat(){
		System.out.println("eat");
	}
	public void sleep(){
		System.out.println("sleep");
	}
}
//猫类
class Cat extends Animal{
	//方法重写
	public void eat(){
		System.out.println("狗吃肉");
	}
	//方法重写
	public void sleep(){
		System.out.println("狗坐着睡");
	}
}
//狗类
class Dog extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void sleep(){
		System.out.println("猫趴着睡");
	}
}

//添加猪类
class Pig extends Animal{ //----------note:老忘记写extends!!!!!!!!!!
		public void eat(){
		System.out.println("猪吃白菜");
	}
	public void sleep(){
		System.out.println("猪躺着睡");
	}
}

//针对动物操作的工具类
class AnimalTool{
	
	private AnimalTool(){}//最好把工具类的构造方法私有，防止别人创建该类的对象。该类是工具类。
	
	//调用猫的功能
	public static void feedCat(Cat c){  //工具类，方法就写成static的，然后直接在测试类：工具类名.方法 使用。
		c.eat();
		c.sleep();
	}
	//调用狗的功能
	public static void feedDog(Dog d){
		d.eat();
		d.sleep();
	}
	
	//添加猪的，调用猪的功能
	public static void feedDog(Dog d){
		d.eat();
		d.sleep();
	}
	
}


/*测试类
  测试类里面不放其他东西（如，定义其他方法）！只能是建对象，调方法。
  所以新定义了个操作动物的工具类去放feedCat(),feedDog()方法。
*/
class DuotaiTest{
	public static void main(String[] args){
		//我喜欢猫，我养3只猫
		Cat c= new Cat();
		Cat c2= new Cat();
		Cat c3= new Cat();
		AnimalTool.feedCat(c);
		AnimalTool.feedCat(c2);
		AnimalTool.feedCat(c3);
		
		//我喜欢狗，我养3只狗
		Dog d= new Dog();
		Dog d2= new Dog();
		Dog d3= new Dog();
		AnimalTool.feedDog(d);
		AnimalTool.feedDog(d2);
		AnimalTool.feesDog(d3);
		
		//我喜欢宠物猪
		//需要定义一个猪类，它继承自动物类，提供两个方法。且在工具类里添加方法。
		
		//我喜欢宠物兔、老虎、狼.....
		//若按上述添加猪的办法做，定义类，继承类，提供方法都是必须要的。
		//但是在工具类里面改过来改过去，不好。能否做到不改？
		//能。
		//见DuotaiTest2.java 中工具类的写法
		
		
	}
}

改进后：
采用多态后，易于扩展。
重点在：**用Fu f做形参接收参数，用Zi z的z做实参。有了父类引用指向子类。**即动物类引用指向各具体的动物类。同时又有方法重写，运行的时候肯定是个各子类重写的方法在起作用。从而利用多态实现好的扩展性。

/*
	多态的扩展性
*/
/*
程序输出结果：
	狗吃肉
	狗坐着睡
	狗吃肉
	狗坐着睡
	狗吃肉
	狗坐着睡
	---------------
	猫吃鱼
	猫趴着睡
	猫吃鱼
	猫趴着睡
	猫吃鱼
	猫趴着睡
	---------------
	猪吃白菜
	猪躺着睡

*/
//父类：动物类
class Animal{
	public void eat(){
		System.out.println("eat");
	}
	public void sleep(){
		System.out.println("sleep");
	}
}
//猫类
class Cat extends Animal{
	public void eat(){
		System.out.println("狗吃肉");
	}
	public void sleep(){
		System.out.println("狗坐着睡");
	}
}
//狗类
class Dog extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void sleep(){
		System.out.println("猫趴着睡");
	}
}

//添加猪类
class Pig extends Animal{ //----------note:老忘记写extends!!!!!!!!!!
	public void eat(){
		System.out.println("猪吃白菜");
	}
	public void sleep(){
		System.out.println("猪躺着睡");
	}
}

//针对动物操作的工具类
class AnimalTool{
	
	private AnimalTool(){}//最好把工具类的构造方法私有，防止别人创建该类的对象。该类是工具类。
	
	/*-------------改动-----------------------*/
	//注意：形参是Animal a，用动物接收。 到时候左边是 Fu f, 右边是Zi z， Fu f= Zi z 
	public static void feedAnimal(Animal a){  //工具类，方法就写成static的，然后直接在测试类：工具类名.方法 使用。
		a.eat();   //成员方法：运行看右边：各子类的。（ 不然干嘛方法重写）
		a.sleep();
	}
	
	
}

/*测试类
  测试类里面不放其他东西（如，定义其他方法）！只能是建对象，调方法。
  所以新定义了个操作动物的工具类去放feedCat(),feedDog()方法。
*/
class DuotaiTest2{
	public static void main(String[] args){
		//我喜欢猫，我养3只猫
		Cat c= new Cat();
		Cat c2= new Cat();
		Cat c3= new Cat();
		AnimalTool.feedAnimal(c);
		AnimalTool.feedAnimal(c2);
		AnimalTool.feedAnimal(c3);
		System.out.println("---------------");
		
		//我喜欢狗，我养3只狗
		Dog d= new Dog();
		Dog d2= new Dog();
		Dog d3= new Dog();
		AnimalTool.feedAnimal(d);
		AnimalTool.feedAnimal(d2);
		AnimalTool.feedAnimal(d3);
		System.out.println("---------------");
		
		//我喜欢宠物猪
		//需要定义一个猪类，它继承自动物类，提供两个方法。且在工具类里添加方法。
		
		//我喜欢宠物兔、老虎、狼.....
		//若按上述添加猪的办法做，定义类，继承类，提供方法都是必须要的。
		//但是在工具类里面改过来改过去，不好。能否做到不改？
		//能。
		//猫、狗、猪...都是动物，feedAnimal(Animal a)参数接收动物
		
		Pig p= new Pig();
		AnimalTool.feedAnimal(p);
		
	}
}