java三大特性之多态的认识，以及多态的实际应用（二）

      package test;
      /**
       * 3、定义一个动物类(Animal)，里面有一个吃方法。该类有两个子  类Dog和Cat，
       * 覆盖父类中的吃方法，Dog类为打印狗 喜欢  吃骨头，Cat类为猫喜欢吃鱼。
       * 定一个饲养员类，该类中有一  个给动物喂食的方法，形参定义为Animal类型的引用。
       * 定义 Test类，创建饲养员,调用喂食方法，
       * 传入Dog对象打 印狗喜欢吃骨头，传入Cat对象打印猫喜欢吃鱼。
       */
      public class lt3{
        public static void main(String[] args) {
          //定义  Test类，创建饲养员,调用喂食方法，
          Feeder f = new Feeder();
          //创建dog对象
          Dog d = new Dog();
          //创建cat对象
          Cat c = new Cat();
          // 传入Dog对象打 印狗喜欢吃骨头，传入Cat对象打印猫喜欢吃鱼。
          f.feed(d);// 传入Dog对象打 印狗喜欢吃骨头
          f.feed(c);//传入Cat对象打印猫喜欢吃鱼。
        }
      }
      //定一个饲养员类，该类中有一个给动物喂食的方法，形参定义为Animal类型的引用。
      class Feeder{
        public void feed(Animal animal){
          animal.eat();
        }
      }
      //定义一个动物类(Animal)，里面有一个吃方法。该类有两个子 类Dog和Cat，
      class Animal{
        public void eat(){
          System.out.println("Animal eat ");
        }
      }
      //覆盖父类中的吃方法，Dog类为打印狗 喜欢 吃骨头，Cat类为猫喜欢吃鱼。
      class Dog extends Animal{
        public void eat(){
          System.out.println("狗 喜欢  吃骨头");
        }
      }
      class Cat extends Animal{
        public void eat(){
          System.out.println("Cat类为猫喜欢吃鱼。");
        }
      } 

      package testUse;
        public class useDuoT2{
          public static void main(String[] args) {
          Dog d = new Dog();
          //d作实参，调用m1；
          m1(d);
            //实参传子类对象
            m2(d);
          //再创建一个cat，用猫做对象，猫也想调用这个m1.
          Cat c = new Cat();
          //这句话就不对了，因为函数类型是Dog，这里传一个cat类型进去肯定不对了
          //想用这个可以再重载一个函数；
          m1(c);
            Animal a = m33();
            Animal a1 = m33(5);//返回Cat
            Animal a2 = m33(6);//返回Dog
        }
        //函数，dog类型
        static void m1(Dog d){
          d.sleep();
        }
        static void m1(Cat c){
          c.sleep();
        }
        //如果动物类里面有一万个子类，这种方法就不行了，难道去重载一万次？
        //不用重载，把函数参数类型改为Animal
        //然后传的时候，就可以传任何一种动物了
        //这就是多态的第一种用法：
        //1，多态用在方法参数上，  形参可以是父类引用，实参可以传子类对象；
        //M(A a) :   可以用A的任何子类对象作为参数
        static void m2(Animal a){//Animal a,形参，传父类引用，
          //如果传入的是dog类型，就输出Dog  sleep，子类会重写父类方法
          //如果传入的是cat类型，就输出Cat  sleep，
          a.sleep();
        }
        //以一个dog对象作为返回值，返回类型可以写Dog，static Dog m3(){}
        //但是实现可能会修改,如果返回值是Cat，那么返回值类型也得跟着改，
        //类型一改所有调用这个方法的代码都得跟着修改
        static Dog m3(){
          return new Dog();
        }
          //所以这个返回值类型可以写成Animal，所以只要是动物就都可以返回
          //所以调用的时候就需要一个Animal类型的引用去接这个返回值；Animal a = m33();
          //
          static Animal m33(){
            return new Dog();
          }
          //这个代码还可以再改一下；
          //这个代码可以返回dog也可以返回猫。所以只能用多态。
          //多态的第2中用法：
          //这是把多态用在方法的返回值上，
          //A   m() :  m方法完全可以返回A的某个子类对象
          static Animal m33(int n){
            if (n % 2 == 0) {
              System.out.println("return new Dog()");
              return new Dog();
            }else
              System.out.println("return new Cat()");
              return new Cat();
          }
      }
      class Animal{
        public void sleep(){
          System.out.println("Animal  sleep");
        }
      }
      class Dog extends Animal{
        public void sleep(){
          System.out.println("Dog  sleep");
        }
      }
      class Cat extends Animal{
        public void sleep(){
          System.out.println("Cat  sleep");
        }
      }