一、概述

多态性是继封装、继承之后，面向对象的第三大特性。

1、定义

多态：是指同一行为，具有多个不同表现形式。

2、前提

继承或者实现【二选一】
方法的重写【意义：不重写，无意义】
父类引用指向子类对象【格式体现】

二、多态的体现

1、格式

父类变量 变量名 = new 子类对象;
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型

Super s = new SubClass();
s.method();

当使用多态方法调用父类方法时，首先检查父类是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

public class SuperClass {
    public void method(){
        System.out.println("父类方法");
    }

    public void methodSuper(){
        System.out.println("父类特有方法");
    }
}

public class SubClass extends SuperClass{
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}


public class Demo01Multi {
    public static void main(String[] args) {
        // 使用多态写法
        // 左侧父类的引用指向了右侧子类的对象
        SuperClass obj = new SubClass();
        obj.method();
        obj.methodSuper();
    }
}


输出结果：
子类方法
父类特有方法

2、多态中的成员变量使用特点

(1)、对象名.成员变量（看对象名是谁，就优先用谁，没有则想上找）

public class SuperClass {
    int num = 10;
}

public class SubClass extends SuperClass{
    int num = 20;
    int age = 19;
}

 public class Demo02Multi {
    public static void main(String[] args) {
        // 使用多态写法
        // 左侧父类的引用指向了右侧子类的对象
        SuperClass obj = new SubClass();
        System.out.println(obj.num);
        
//        System.out.println(obj.age); // 错误写法
        System.out.println("======");
    }
 }

(2)、通过方法来调用成员变量（看该方法属于谁，就优先用谁，没有则想上找）

public class SuperClass {
    int num = 10;

    public void methodNum(){
        System.out.println(num);
    }
}

public class SubClass extends SuperClass{
    int num = 20;
    int age = 19;

//    @Override
//    public void methodNum(){
//        System.out.println(num);
//    }
}

public class Demo03Multi {
    public static void main(String[] args) {
        // 使用多态写法
        // 左侧父类的引用指向了右侧子类的对象
        SuperClass obj = new SubClass();

        // 子类没有覆盖重写，就是使用父类方法，输出为10
        // 子类有覆盖重写，就是使用子类方法，输出为20
        obj.methodNum();
    }
}

3、多态中的成员方法使用特点

public class SuperClass {
    public void method(){
        System.out.println("父类方法");
    }

    public void methodSuper(){
        System.out.println("父类特有方法");
    }
}

public class SubClass extends SuperClass{
    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodSub(){
        System.out.println("子类特有方法");
    }
}

public class Demo04Multi {
    public static void main(String[] args) {
        // 使用多态写法
        // 左侧父类的引用指向了右侧子类的对象
        SuperClass obj = new SubClass();
        obj.method();
        obj.methodSuper();
        
        obj.methodSub(); // 错误，
    }
}

三、多态的好处

1_Java_Multi

四、转型

1、对象的向上转型

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Demo05Main {
    public static void main(String[] args) {
        // 对象的向上转型
        Animal animal = new Cat();
        animal.eat();
    }
}

2_Java_Up

向上转型是安全的，没有问题，但是有个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容

2、对象的向下转型

public abstract class Animal {
    public abstract void eat();
}

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

    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        // 对象的向上转型
        Animal animal = new Cat();
        animal.eat();

        // 对象的向下转型
        Cat cat = (Cat) animal;
        cat.catchMouse();
    }
}