1.不使用多态时：

好处：可以调用子类的特有行为

弊端：扩展性极差

2.使用多态时：

好处：扩展性强，让代码更灵活，提高代码的复用性

弊端：不能调用子类对象的特有行为（方法）

在使用多态时，要调用子类对象特有方法是，我们可以向下转型，这时，为了避免强转出现问题，我们应该使用instanceof关键字来判断关键字左边的变量是否为右边的类型，返回boolean类型的结果即可。

package itheima_03;

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

}

}

package itheima_03;
/*
测试类
*/

public class AnimalDemo {
    public static void main(String[] args) {

    //创建动物操作类的对象，调用方法

AnimalOperator ao = new AnimalOperator();
Cat c = new Cat();
ao.useAnimal(c);

Dog d = new Dog();
ao.useAnimal(d);

pig p = new pig();
ao.useAnimal(p);

}

}

package itheima_03;
/*
动物操作类
*/

public class AnimalOperator {

/*

public void useAnimal(Cat c){//cat c = new Cat();
c.eat();
}

  public void usAnimal(Dog d){
        d.eat();

}

public void useAnimal(Dog d) {//Dog d = new Dog();
d.eat();

}
*/

 public void useAnimal(Animal a){
        //Animal a = new Cat();
        //Animal a = new Dog();

    a.eat();
  //  a.lookDoor();
}

}

package itheima_03;

public class Cat extends Animal {

@Override

   public void eat(){
        System.out.println("猫吃鱼");

}

}

package itheima_03;

public class Dog extends Animal{

@Override

  public void eat(){
        System.out.println("狗吃骨头");

}

  public void lookDoor(){
        System.out.println("狗看门");

}

}

package itheima_03;

public class pig extends Animal{

@Override

public void eat(){
    System.out.println("猪吃白菜");

}

}

多态的好处和弊端
多态的好处：提高了程序的扩张性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
多态的弊端：不能使用子类的特有功能

/*
   多态的好处
            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();
	}
}