多态（polymorphic）

多态基本介绍

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

多态的具体体现

1、方法的多态（重写和重载体现多态）

// 例子
public class Poly {
   
   
    public static void main(String[] args) {
   
   
        // 方法重载体现多态
        A a = new A();
        // 传入不同的参数，会调用不同sum 方法，就体现多态
        System.out.println(a.sum(10, 20));
        System.out.println(a.sum(10, 20, 30));

        // 方法重写体现多态
        B b = new B();
        a.say();
        b.say();
    }
}

// 父类
class B{
   
   
    public void say(){
   
   
        System.out.println("B say() 方法被调用...");
    }
}

// 子类
class A extends B{
   
   
    public int sum(int n1, int n2){
   
    // 和下面sum 构成重载
        return n1 + n2;
    }

    public int sum(int n1, int n2, int n3){
   
   
        return n1 + n2 + n3;
    }

    public void say(){
   
   
        System.out.println("A say() 方法被调用...");
    }
}

2、对象的多态（核心、重点、难点）

 
  1）一个对象的编译类型和运行类型可以不一致；

// 父类的一个引用指向子类的一个对象
Animal animal = new Dog(); // animal 编译类型是 Animal，运行类型是 Dog

  2）编译类型在定义对象时，就确定了，不能改变；

  3）运行类型时可以变化的，可以通过 getClass() 来查看运行类型；

animal = new Cat(); // animal 的运行类型变成了Cat，编译类型仍然是 Animal

  4）编译类型看定义时 " = " 的左边，运行类型时看 " = " 的右边；

// Animal
public class Animal {
   
   
    public void cry(){
   
   
        System.out.println("Animal cry() 动物在叫...");
    }
}

// Dog
public class Dog extends Animal{
   
   

    public void cry() {
   
   
        System.out.println("Dog cry() 小狗汪汪叫...");
    }
}

// Cat
public class Cat extends Animal{
   
   

    public void cry() {
   
   
        System.out.println("Cat cry() 小猫喵喵叫...");
    }
}

public class PolyObject {
   
   
    public static void main(String[] args) {
   
   
        // 体验对象多态特点

        // animal 编译类型就是 Animal，运行类型 Dog
        Animal animal = new Dog();
        // 运行时，执行到该行时，animal 运行类型是 Dog,所以 cry 就是 Dog 的 cry
        animal.cry();   // 小狗汪汪叫...

        // animal 编译类型就是 Animal，运行类型 Cat
        animal = new Cat();
        animal.cry();   // 小猫喵喵叫...
    }
}

多态的转型、注意事项和细节

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

多态的向上转型:

  1）本质：父类的引用指向了子类的对象；

  2）语法：父类类型 引用名 = new 子类类型()；

  3）特点：① 编译类型看左边，运行类型看右边；
        ② 可以调用父类中的所有成员（需遵守访问权限）；
        ③ 不能调用子类中特有成员；
        ④ 最终运行效果看子类的具体实现！

// 父类
public class Animal {
   
   
    String name = "动物";
    int age = 10;
    public void sleep(){
   
   
        System.out.println("睡");
    }
    public void run(){