Java多态

1.多态

1.1多态的概述（记忆）

• 什么是多态

  不同类的对象在调用同一个方法时表现出来的多种不同行为

• 多态的前提

  • 要有继承或实现关系

  • 要有方法的重写

  • 要有父类引用指向子类对象

• 代码演示

  class Animal {
      public void eat(){
          System.out.println("动物吃肉");
      }
  }
  ​
  class Cat extends Animal {
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }
  class Dog extends Animal {
      @Override
      public void eat() {
          System.out.println("狗吃骨头");
      }
  }
  ​
  public class Test1Polymorphic {
      /*
          多态的前提:
  ​
              1. 要有(继承 \ 实现)关系
              2. 要有方法重写
              3. 要有父类引用, 指向子类对象
       */
      public static void main(String[] args) {
          // 当前事物, 是一只猫
          Cat c = new Cat();
          // 当前事物，是一只狗
          Dog d = new Dog();
          // 当前事物, 是一只动物（a:猫对象）
          Animal a = new Cat();
          // 当前事物, 是一只动物(b:狗对象)
          Animal b = new Dog();
          a.eat();
          b.eat();
  ​
      }
  }

  运行结果：

• 

1.2多态中的成员访问特点（记忆）

• 成员访问特点

  • 成员变量

    编译看父类，运行看父类

  • 成员方法

    编译看父类，运行看子类

• 代码演示

  class Fu {
      int num = 10;
  ​
      public void method(){
          System.out.println("Fu.. method");
      }
  }
  ​
  class Zi extends Fu {
      int num = 20;
  ​
      public void method(){
          System.out.println("Zi.. method");
      }
  }
  ​
  public class Test2Polymorpic {
      /*
           多态的成员访问特点:
  ​
                  成员变量: 编译看左边 (父类), 运行看左边 (父类)
  ​
                  成员方法: 编译看左边 (父类), 运行看右边 (子类)
       */
      public static void main(String[] args) {
          Fu f = new Zi();
          System.out.println(f.num);
          f.method();
      }
  }

1.3多态的好处和弊端（记忆）

• 好处

  提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

• 弊端

  不能使用子类的特有成员

1.4多态中的转型（应用）

• 向上转型

  父类引用指向子类对象就是向上转型

• 向下转型

  格式：子类型 对象名 = (子类型)父类引用;

• 代码演示

  class Fu {
      public void show(){
          System.out.println("Fu..show...");
      }
  }
  ​
  class Zi extends Fu {
      @Override
      public void show() {
          System.out.println("Zi..show...");
      }
  ​
      public void method(){
          System.out.println("我是子类特有的方法, method");
      }
  }
  ​
  public class Test3Polymorpic {
      public static void main(String[] args) {
          // 1. 向上转型 : 父类引用指向子类对象
          Fu f = new Zi();
          f.show();
          // 多态的弊端: 不能调用子类特有的成员
          // f.method();
  ​
          // A: 直接创建子类对象
          // B: 向下转型
  ​
          // 2. 向下转型 : 从父类类型, 转换回子类类型
          Zi z = (Zi) f;
          z.method();
      }
  }

1.5多态中转型存在的风险和解决方案 (应用)

• 风险

  如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

• 解决方案

  • 关键字

    instanceof

  • 使用格式

    变量名 instanceof 类型

    通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

• 代码演示

  abstract class Animal {
      public abstract void eat();
  }
  ​
  class Dog extends Animal {
      public void eat() {
          System.out.println("狗吃肉");
      }
  ​
      public void watchHome(){
          System.out.println("看家");
      }
  }
  ​
  class Cat extends Animal {
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }
  ​
  public class Test4Polymorpic {
      public static void main(String[] args) {
          useAnimal(new Dog());
          useAnimal(new Cat());
      }
  ​
      public static void useAnimal(Animal a){  // Animal a = new Dog();
                                               // Animal a = new Cat();
          a.eat();
          //a.watchHome();
  ​
  //        Dog dog = (Dog) a;
  //        dog.watchHome();  // ClassCastException  类型转换异常
        
          // 判断a变量记录的类型, 是否是Dog
          if(a instanceof Dog){
              Dog dog = (Dog) a;
              dog.watchHome();
          }
      }
  ​
  }