一、多态概述

面向对象三大特征：封装性、继承性、多态性
extends继承或implements实现，是多态的前提
一个对象拥有多种形态，这就是：对象的多态性

二、多态的格式和使用

代码中体现多态性，其实就是一句话：父类引用指向子类对象。
格式：
父类对象对象名 = new 子类名称（）；
或者：
接口名称对象名 = new 实现类名称（）；
示例：

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

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

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

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

        obj.method();
        //子类没有就向上寻找
        obj.mehtodFu();
    }
}

三、多态中成员变量访问的使用特点

变量是不存在覆盖重写的
访问成员变量的两种方式：
1.直接通过对象名称访问成员变量：等号左边是谁，优先使用谁，没有则向上找
2.间接通过成员方法访问成员变量：看该方法属于谁，优先使用谁，没有则向上找。

public class Fu {
    int num = 10;

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

public class Zi extends Fu {

    int num = 20;

    int age = 15;

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

public class MultiField {
    public static void main(String[] args) {
        //使用多态写法，父类引用指向子类对象
        Fu obj=new Zi();
        System.out.println(obj.num);
        //System.out.println(obj.age); //错误写法！程序不存在向下寻找！！！
        System.out.println("===============");
        //子类没有覆盖重写，就是父：10
        //子类如果覆盖重写，就是子：20
        obj.showNum();
    }
}

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

在多态的代码当中，成员方法的访问规则是：看new的是谁，就优先用谁，没有则向上找。
口诀：编译看左边，运行看右边。

成员变量VS成员方法
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

public class Fu {
    int num = 10;

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

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

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

public class Zi extends Fu {

    int num = 20;

    int age = 15;

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

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

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

public class Demo02MultiField {
    public static void main(String[] args) {
        Fu obj = new Zi(); //多态
        obj.method();   //父子类都有，优先使用子类
        obj.methodFu(); //子类没有，父类有，向上找父类

        //编译看左边，左边是Fu，Fu当中没有methodZi()方法，所以编译出错。
        //obj.methodZi(); //错误写法！
    }
}

五、使用多态的好处

不使用多态VS使用多态
以员工类（抽象类）为例
如果不用多态，只用子类，那么写法是：

Teacher one = new Teacher();
one.work(); //讲课
Assistant two = new Assistant();
two.work(); //辅导

使用多态：

Employee one = new Teacher();
one.work(); //讲课
Employee two = new Assistant ();
two.work();  //辅导

好处：无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。

六、对象的向上转型

多态的向上转型，其实就是多态的写法：
格式：父类对象对象名 = new 子类名称();
含义：右侧创建一个子类对象，把它当做父类来看待使用。
注意事项：向上转型一定是安全的。从小范围转向大范围。

public abstract class Animal {

    public abstract void eat();
}

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

public class Demo01Main {
    public static void main(String[] args) {
        //对象向上转型，就是：父类引用指向子类对象
        Animal animal =new Cat();
        animal.eat();
    }
}

七、对象的向下转型

向上转型一定是安全的，但是也有弊端——对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
解决方案：用对象的向下转型还原。

对象的向下转型，其实是一个还原动作。
格式：子类名称对象名 =（子类名称）父类对象；
含义：将父类对象，还原成本来的子类对象

Animal animal = new Cat(); //本身是猫，向上转型成为动物
Cat cat = (Cat)anima；//本来是猫，已经被当作动物了，还原回来成为本来的猫
注意事项：
a.必须保证对象本来创建的时候就是猫，才能向下转型成为猫。
b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

public class Demo01Main {
    public static void main(String[] args) {
        //对象向上转型，就是：父类引用指向子类对象
        Animal animal =new Cat();
        animal.eat();

        //animal.eatMouse(); //错误写法！！

        //向下转型，进行还原动作
        Cat cat =(Cat)animal;
        cat.eatMouse();

        //下面是错误的向下转型
        //本来new的时候是一只猫，现在非要做狗
        //错误写法！编译不会报错，单数运行会出现异常：
        //java.lang.ClassCastException，类转换异常

        Dog dog =(Dog)animal;
    }
}

八、instanceof关键词的用法

如何才能知道一个父类引用对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例。

public class Demo02Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();  //猫吃鱼

        //如果希望调用子类特有方法，需要向下转型
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchMouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.eatMouse();
        }

    }

Java基础——多态