Java多态的好处和弊端，代码实例

/*
   多态的好处
            A: 提高了代码的维护性（继承保证）
			B：提高了代码的扩展性（多态保证）
					
*/ 
/*猫狗的案例*/
class Animal{
	public void eat(){
		Systemout.println("eat");
	}
	public void sleep(){
		Systemout.println("sleep");
	}
}
class  Dog extends Animal{
	public void eat(){
		Systemout.println("狗吃肉");
	}
	public void sleep(){
		Systemout.println("狗站着睡觉");
	}
}
class Cat extends Animal{
	public void eat(){
		Systemout.println("猫吃鱼");
	}
	public void sleep(){
		Systemout.println("猫趴着睡觉");
	}
}
class Pig extends Animal{
	public void eat(){
		Systemout.println("猪吃白菜");
	}
	public void sleep(){
		Systemout.println("猪躺着睡觉");
	}
}
  //针对动物操作的工具类
class AnimalTool{
	private AnimalTool(){}
	/*
       //调用猫的功能
		public static void useCat(Cat c){
			c.eat();
			c.sleep();
		}
		//调用狗的功能
		public static void useDog(Dog d){
			d.eat();
			d.sleep();
		}
		}
		//调用猪的功能
		public static void usePig(Pig p){
			p.eat();
			p.sleep();
		}
		*/
		public static void useAnimal(Animal a){
			a.eat();
			a.sleep()
         }
}
class Dome{
	 public static void main(STring[] args){
		 //我养了一直猫
		 Cat c = new Cat();
		 c.eat();
		 c.sleep();
		 
		 //我再养了一直猫
		 Cat c2 = new Cat();
		 c2.eat();
		 c2.sleep();
		 
		 //我又养了一直猫
		 Cat c3 = new Cat();
		 c3.eat();
		 c3.sleep();
		 
		//问题来了，我养了很多只猫，每次创建对象时可以接受的
        //但是，调用方法，不觉的很相似吗？仅仅对象名不一样
        //所以我们用方法改进
        //建立了一个新的类，针对动物操作的工具类		
		
		AnimalTool.useAnimal(c);
		AnimalTool.useAnimal(c2);
		AnimalTool.useAnimal(c3);
		
		//我养了一狗
		  Dog d = new Dog();
		  d.eat();
		  d.sleep();
		  AnimalTool.useAnimal(d);
		  
		  //我喜欢宠物猪
		  //定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类的方法调用
		  Pig p = new Pig();
		  p .eat();
		  p .sleep();
		  AnimalTool.useAnimal(p );
		  
		  //我喜欢宠物狼，老虎
		  //定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类的方法调用
		  //前面个几个必须写
		  //但是，工具类每次都该，很麻烦
		  //所以我们在在工具类中写了一个方法
		 /* public static void useAnimal(Animal a){
			a.eat();
			a.sleep()
		  */
         //将来不管添加多少宠物，我接受的都是动物		  
	 }
}
/*
    多态的弊端
	          //不能访问子类特有的功能
*/
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 Dome{
	public static void main(Striing[] args){
		//测试
		Fu f = new Zi
		f.show();
		//编译不通过
		//不能访问子类特有的功能
		f.method();
	}
}

/*
    多态的弊端
	          //不能访问子类特有的功能
			  
		怎么使用子类特有的功能呢？
              A:创建子类对象调用方法(可以，但是很多时候不合理，而且太占内存)
			  B:把父类的引用强制转换为子类的引用。（向下转型）
			  
			  对象的转型问题：
			  向上转型：    //子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。
			     Fu f = new Zi();new出来的对象f在Zi但是引用却是指向Fu
			  向下转向：     如果不理解看9.11和9.12
			     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 Dome{
	public static void main(Striing[] 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();
	}
}