&Java面向对象特征——多态性 & 多态是编译时行为还是运行时行为？&向下转型（instanceof）

• 多态性（向上转型） 

理解多态性：可以理解为一个事物的多种形态。

何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。

多态性的使用前提：  ① 类的继承关系  ② 方法的重写

说明：对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

public class PolymorphismTest{
    public static void main(String[] args) {
        Person p = new Student();//对象的多态性：父类的引用指向子类的对象
        p.setName("张三");
        p.walk();
        p.eat();//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
//        p.study; //不能调用子类特有的属性和方法
    }
}

class Person {
    private String name;

    public Person(){};
    public Person(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
     public void eat(){
        System.out.println(name +"吃饭");
    }
    public void walk(){
        System.out.println("人走路");
    }
}
class Student extends Person{
    String major;

    public Student() {
        super();
    }
    public Student( String major){
        super();
        this.major = major;
    }
    public Student(String name, String major) {
        super(name);
        this.major = major;
    }

    public void eat(){
        System.out.println(getName() +"吃学校的饭");
    }
    public void study(){
        System.out.println("学生学习的专业：" + major);
    }
}

//运行结果：
//人走路
//张三吃学校的饭

思考：多态是编译时行为还是运行时行为？

答案是：运行是行为 ，下面引用一段代码来证明此答案

import java.util.Random;

public class InterviewTest {
    public static void main(String[] args) {
        int key = new Random().nextInt(3);//随机生成0、1、2的随机数
        Animal animal = getInstance(key);
        animal.eat();
    }

    public static Animal getInstance(int key){
        switch (key){
            case 0:
                return new Dog();
            case 1:
                return new Cat();
            default:
                return new Sheep();
        }
    }
}

class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

class Sheep extends Animal{
    public void eat(){
        System.out.println("羊吃草");
    }
}

 代码说的是：随机生成一个随机数，调用getInstance方法根据随机数，new不同的子类对象，赋值给Animal。因为我们根据代码无法看出结果，只有真正运行时才知道new的是谁！

虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法。
父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

• 向下转型（instanceof） 

引语

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。 那该如何才能调用子类特有的属性和方法？ 这时候我们就需要用到向下转型：使用强制类型转换符。

对比基本数据类型

instanceof关键词使用：instanceof关键词的使用看这篇文章

public class PolymorphismTest{
    public static void main(String[] args) {
        
        Person p1 = new Student();
        if (p1 instanceof Student) { //true
            Student s = (Student) p1;
            s.setName("李四");
            s.major = "数学"; //向下转型后，就可以调用子类特有的属性
            s.study(); //向下转型后，就可以调用子类特有的方法
            s.eat();//执行子类重写的方法
            s.walk();//可以调用父类未重写的方法
        }else{
            System.out.println("ClassCastException的异常");
        }
    }
}

class Person {
    private String name;

    public Person(){};
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

     public void eat(){
        System.out.println(name +"吃饭");
    }
    public void walk(){
        System.out.println("人走路");
    }
}
class Student extends Person{
    String major;

    public Student() {
        super();
    }
    public Student( String major){
        super();
        this.major = major;
    }
    public Student(String name, String major) {
        super(name);
        this.major = major;
    }

    public void eat(){
        System.out.println(getName() +"吃学校的饭");
    }
    public void study(){
        System.out.println("学生学习的专业：" + major);
    }
}

//执行结果：
//学生学习的专业：数学
//李四吃学校的饭
//人走路

经典例题

public class InterviewTest {
    public static void main(String[] args) {
        A a = new B();
        a.add(1,2,3); 

        B b = (B) a;
        b.add(1,2,3);
    }
}

class A {
    public void add(int x , int ... arr ){
        System.out.println("结果1");
    }
}

class B extends A{
    public void add(int x, int[] arr){
        System.out.println("结果2");
    }

    public void add(int x, int y, int z){
        System.out.println("结果3");
    }
}

//执行结果：
//结果2
//结果3