一：多态的基本介绍

方法或者属性具有多种形态，是面向对象的第三大特征，多态是寄哪里在封装和继承基础之上的。

二：多态的具体体现

1：方法的多态

重写和重载就体现多态

  1. package Data0801.Test0802;
  3. /**
  4.  * 作者：sakura
  5.  * 日期：2022年08月02日 00:05
  6.  */
  7. public class test02 {
  8.     public static void main(String[] args) {
  9.         A a = new A();
  10.         a.sum(3,4);
  11.         a.sum(3,4,6);
  12.         B b = new B();
  13.         b.sum(2,4);
  14.     }
  15. }
  16. class A{
  17.     //重载
  18.     public double sum(int a, int b){
  19.         return a+b;
  20.     }
  21.     public double sum(int a, int b,int c){
  22.         return a+b+c;
  23.     }
  24. }
  25. class B extends A{
  26.     @Override
  27.     public double sum(int a, int b) {
  28.         System.out.println("方法重写完毕");
  29.         return super.sum(a, b);
  30.     }
  31. }

2：对象的多态（重点，难点！！！）

:::danger

  1. 一个对象的编译类型和运行类型可以不一致
  2. 编译类型在定义对象是，就确定了，不能改变
  3. 运行类型是可以变化的

  4. 编译类型看定义是 = 好的左边，运行类型看 = 右边 :::

    1. Animal animal = new Dog(); //编译类型是Animal,运行类型是Dog
    2. animal = new cat();  //换了一个引用对象,运行类型变成了Cat

    三：代码案例

    1：多态基本体现

    1. public class test03 {
    2.  public static void main(String[] args) {
    3.      //编译类型和运行类型
    4.      Animal animal = new Dog();
    5.      animal.cry();
    6.      Animal animal1 = new Cat();
    7.      animal1.cry();
    8.  }
    9. }
    10. public class Animal {
    11.  public void cry(){
    12.      System.out.println("动物在叫");
    13.  }
    14. }
    15. public class Cat extends Animal{
    16.  @Override
    17.  public void cry() {
    18.      System.out.println("猫在叫");
    19.  }
    20. }
    21. public class Dog extends Animal{
    22.  @Override
    23.  public void cry() {
    24.      System.out.println("狗在叫");
    25.  }
    26. }

    2：解决主人给动物喂食的问题

    1. public class test04 {
    2.  public static void main(String[] args) {
    3.      Master sakura = new Master("sakura");
    4.      Animal animal = new Cat("L");
    5.      Food food = new fish("鱼");
    7.      sakura.feed(animal,food);
    9.  }
    10. }
    11. public class Master {
    12.  private String name;
    14.  public Master(String name) {
    15.      this.name = name;
    16.  }
    18.  public void setName(String name) {
    19.      this.name = name;
    20.  }
    22.  public String getName() {
    23.      return name;
    24.  }
    26.  public void feed(Animal animal , Food food){
    27.      System.out.println("主人:" + this.name + "给 " + animal.getName() + "喂食：" + food.getName());
    28.  }
    29. }
    30. public class Food {
    31.  private String name;
    33.  public Food(String name) {
    34.      this.name = name;
    35.  }
    37.  public String getName() {
    38.      return name;
    39.  }
    41.  public void setName(String name) {
    42.      this.name = name;
    43.  }
    44. }
    45. public class fish extends Food{
    47.  public fish(String name) {
    48.      super(name);
    49.  }
    50. }
    51. public class Animal {
    52.  private String name;
    54.  public Animal(String name) {
    55.      this.name = name;
    56.  }
    58.  public String getName() {
    59.      return name;
    60.  }
    62.  public void setName(String name) {
    63.      this.name = name;
    64.  }
    65. }
    66. public class Cat extends Animal{
    68.  public Cat(String name) {
    69.      super(name);
    70.  }
    71. }

    四：多态细节注意事项和细节讨论

  • 多态的前提是：__两个对象（类）之间存在继承关系

    1：多态的向上转型

  • 本质：父类的引用指向子类的对象

  • 语法：父类类型 引用名 = new 子类类型( );
  • 特点：编译类型看左边，运行类型看右边
    • 可以调用父类的所有成员
    • 不能调用子类的特有成员
    • 最终运行效果看子类的具体实现 ```java Animal animal = new cat(); Objectobj = new cat(); //Object 也是cat的父类

//向上转型调用方法的规则如下: //(1)可以调用父类中的所有成员(需遵守访问权限) //(2)但是不能调用子类的特有的成员 //(3)因为在编译阶段，能调用哪些成员,是由编译类型来决定的 //animal.catchMouse();错误 // //(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法 //，然后调用，规则我前面我们讲的方法调用规则一致。

animal.eat(); //如果想调用子类中的特有方法只能，向下转型

  2. <a name="QlIMJ"></a>
  3. #### 2：多态的向下转型
  5. - **_语法：子类类型  __引用名 =  (子类类型) 父类引用_**
  6. - **_只能强转父类的引用，不能强转父类的对象_**
  7. - **_要求父类的引用必须指向的时当前目标类型的对象_**
  8. - **_当向下转型后，可以调用子类类型中的所有的成员_**
  9. ```java
  10. Animal animal = new cat();
  11. Cat cat = (Cat)animal;

3：属性的值没有重写之说看编译类型

  1. public class PolyDetail02 { 
  2.     public static void main(String[] args) { 
  3.         //属性没有重写之说！属性的值看编译类型 
  4.         Base base = new Sub();//向上转型 
  5.         System.out.println(base.count);// ？ 看编译类型 10 
  6.         Sub sub = new Sub();
  7.         System.out.println(sub.count);//? 20
  8.     } 
  9. }
  10. class Base { 
  11.     //父类 
  12.     int count = 10;//属性
  13. }
  14. class Sub extends Base {
  15.     //子类 
  16.     int count = 20;//属性
  17. }

五：instanceOF比较操作符

:::danger 用于判断对象的运行类型是否为XX类型或XX类型的子类型 :::

  1. public class PolyDetail03 { 
  2.     public static void main(String[] args) { 
  3.         BB bb = new BB(); 
  4.         System.out.println(bb instanceof BB);// true 
  5.         System.out.println(bb instanceof AA);// true
  8.         //aa 编译类型 AA, 运行类型是 BB //BB 是AA子类 
  9.         AA aa = new BB(); 
  10.         System.out.println(aa instanceofAA); //true
  11.         System.out.println(aa instanceofBB); //true
  14.         Object obj = new Object(); 
  15.         System.out.println(obj instanceofAA);//false 
  16.         String str = "hello"; 
  17.         //System.out.println(str instanceof  AA); //fase
  18.         System.out.println(str instanceofObject);//true
  19.     }
  20. }

六：Java动态绑定机制

  1. 当调用方法时，该方法会和该对象的内存地址/运行类型绑定
  2. 当调用对象的属性时，没有动态绑定机制，哪里调用哪里使用

image.png

  2. public static void main(String[] args) {
  3.     A a = new B()
  4.     System.out.println(a.sum()); //40
  5.     System.out.println(a.sum(1); //30
  7. }
  8. class A {
  9.     public int i= 10;
  10.     public int sum() {
  11.         return getl()+ 10;
  12.     }
  13.     public int sum1(){
  14.         returni+ 10;
  15.     }
  16.     public int getl() {
  17.         return i;              
  18.     }
  19. }
  20. class B extends A { // 子类
  21.     public int i = 20;
  22.     /*public int sum(){
  23.         return i+ 20;
  24.     }*/
  25.     public int getl() {
  26.         return i;
  27.     }
  28.     public int sum10 {
  29.         returni+ 10;
  30.     }
  31. }