OOP⑺

1.多态和instanceof

都是去买东西，但是根据我们给别人金额的不同，得到不同的结果！！！！ 生活中的多态！

操作是否一致？   一致！  都是买东西！
什么不一样？？
     01.消费金额不一样
     02.因为消费金额不一样   所以  得到的东西不一样

程序中的多态：
    01.静态的多态     方法重载

    String     buySomething();
    String     buySomething(double money);
    String     buySomething(double money,String something);

    02.动态的多态

     Animal  是抽象类
     Animal x=new X(); 

     同一个引用类型，使用不同的对象实例，而执行不同的操作，从而得到一个不同的结果！

  如果X是Dog，等会执行eat（）就是吃骨头；
  如果X是Cat，等会执行eat（）就是吃鱼；

  01.Dog和Cat都是动物！！ ===》同一个引用类型
  02.一个Dog 一个Cat     ===》不同的对象实例
  03. 吃骨头     吃鱼            ===》不同的操作结果

多态存在的必要条件：
01.要有继承关系！                                    Dog和Cat   is a  动物        都是 extends  Animal
02.子类要重写父类方法 ！                              eat（）是重写了父类的方法
03.父类的引用指向了子类的对象！                        Animal x=new X();   X()子类的对象

多态的实际应用场景：
01.使用父类作为方法的参数！         

      我要买小动物！    buy(Animal)   buy(Dog)  对！

02.使用父类作为方法的返回值！

    我要买小动物！
     public   Animal   buy(Animal  animal){
		         这个方法让我们返回一个Animal（动物）
		        我们返回一个Cat 小猫咪  行吗？   行！！！
          return  new Cat();
     }

 **instanceof  判断某个对象 是否属于某个类型
   所有的对象  instanceof  Object  返回值都是true
2.代码

需求：
 01.创建Dog  Cat  Animal  三个类
 02.Dog  Cat 分别继承   Animal
 03.创建一个Master 主人类
 04.在Master中新增一个 给宠物喂食的方法，方法的参数是？？？Animal
 05.模拟主人给小动物 喂食的方法

 /**
  * 动物的抽象类
  */
 public abstract class Animal {

     /**
      * 所有动物的吃饭方法
      */
     public abstract void eat();

 }

多态

 public class Cat extends Animal {

     @Override
     public void eat() {
         System.out.println("СèßäÔÚ³ÔÓã");
     }

 }

多态

 public class Dog extends Animal {

     @Override
     public void eat() {
         System.out.println("小狗狗在啃骨头");
     }

     /**
      * 小狗狗特有的游泳的方法
      */
     public void swimming() {
         System.out.println("小狗狗在游泳");
     }

 }

多态

 /**
  * 宠物的主人类
  */
 public class Master {

     /**
      * 给所有宠物喂食的方法
      * 有那么多小宠物？  喂谁？？？
      * 关键点：
      *  我们怎么知道  传递来的是 小猫咪还是小狗狗！！！
      *
      *  instanceof  判断某个对象 是否属于某个类型
      *  所有的对象  instanceof  Object  返回值都是true
      */
     public void feed(Animal animal) {
         // animal.eat(); 那么子类中特有的方法我们无法访问
         if (animal instanceof Dog) {
             Dog dog = (Dog) animal;// 向下转型
             dog.eat();
             dog.swimming(); // 调用子类特有的方法
         } else if (animal instanceof Cat) {
             Cat cat = (Cat) animal;// 向下转型
             cat.eat();
         }

     }
 }

多态

 import java.util.Scanner;

 public class AnimalTest {

     public static void main(String[] args) {
         // 实例化主人类
         Master master = new Master();
         System.out.println("请您选择需要喂食的宠物： 01.小猫咪   02.小狗狗");
         Scanner input = new Scanner(System.in);
         int choose = input.nextInt();
         // 创建一个动物 抽象类 不能被实例化 具体是哪个动物我们不知道
         Animal animal;
         switch (choose) {
         case 1: // 给小猫咪喂食
             animal = new Cat(); // 父类的引用指向了子类的对象
             master.feed(animal);
             break;
         case 2: // 给小狗狗喂食
             animal = new Dog();
             master.feed(animal);
             break;
         }

     }
 }

多态

3.面试题

 public class A {
     /**
      * ÏÂÃæÁ½¸ö·½·¨ÊÇÖØÔØ
      */
     public String show(D d) {
         return " A   AND  D";
     }

     public String show(A a) {
         return " A   AND  A";
     }

 }

exam

 public class B extends A {

     /**
      * 下面两个方法是重载
      */
     public String show(B b) {
         return " B   AND  B";
     }

     /**
      *重写A类的方法
      */
     public String show(A a) {
         return " B   AND  A";
     }

 }

exam

 public class C extends B {

 }

exam

 public class D extends B {

 }

exam

 public class TestExam {

     public static void main(String[] args) {
         A a1 = new A();
         A a2 = new B(); // 父类的引用指向了子类的对象
         B b = new B();
         C c = new C();
         D d = new D();

         System.out.println(a1.show(b)); // A AND A
         /**
          * a1是A类的对象！
          * 我们传递了一个C对象
          * C类继承B类 ，B类继承A类
          * 所以会执行 A类中的  show(A a)
          */
         System.out.println(a1.show(c)); // A AND A
         System.out.println(a1.show(d)); // A AND D
         /**
          * a2是父类的引用指向了子类的对象
          * a2.show（b）应该去A类中查询 show()并且参数是B类型的！
          * A类中没有参数为B的！
          * 但是有参数是B类父类的方法的！show(A a)!
          * 又因为子类B重写了A类的show(A a) 所以执行 B类的show(A a)
          */
         System.out.println(a2.show(b)); // B AND A
         System.out.println(a2.show(c)); // B AND A
         System.out.println(a2.show(d)); // A AND D
         System.out.println(b.show(b)); // B AND B
         System.out.println(b.show(c)); // B AND B
         /**
          * b确实是B类的对象！
          * 但是b.show(d)在B类中没有发现！
          * 这时候 会去父类中查询 有没有对应的show(d) 因为B类继承了A类
          * 所以说 A类中的 show(D d)  B类中也有！只不过在A类中！
          * A类中有就执行！否则就执行B类中的show(B b)  因为D类继承了B类
          */
         System.out.println(b.show(d)); // A AND D

     }

 }

exam