java学习笔记（3）——多态

所谓多态，就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用的到底是哪个类中实现的方法，必须在由程序运行期间才能决定。即不修改程序代码就可以让程序有多个运行状态可以选择，这就是多态性。同一个事件发生在不同的对象上会产生不同的结果，可见，多态实现了很好的扩展性。

多态的三个必要条件

• 继承 :在多态中必须存在有继承关系的子类和父类。
• 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
• 向上转型：父类引用指向子类对象：Farther f = new Son()

向下转型：
子类引用指向父类引用的子类对象：
语法：Son s = （Son）f

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

实例的演示：
Test.java 文件代码：

public class Test {
    public static void main(String[] args) {
        show(new Cat()); // 以 Cat 对象调用 show 方法
        show(new Dog()); // 以 Dog 对象调用 show 方法

        Animal a = new Cat(); // 向上转型，父类引用指向子类对象

        //向上转型时，子类单独定义的方法会丢失，a.work()会报错
        a.eat(); // 调用的是 Cat 的 eat
       
        Cat c = (Cat) a; // 向下转型，向下转型前得先向上转型
        c.work(); // 调用的是 Cat 的 work
    }

    public static void show(Animal a) {
        a.eat();
        // 类型判断
        if (a instanceof Cat) { // 猫做的事情
            Cat c = (Cat) a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog) a;
            c.work();
        }
    }

}

abstract class Animal {    //创建抽象类，该类不能实例化
    //即：Animal dog=new Animal   会报错
    abstract void eat();   //抽象方法，只有方法声明，没有方法实现
} 

class Cat extends Animal {   //普通类继承抽象类
    public void eat() {
        System.out.println("吃鱼");   //重写父类中的抽象方法
    }

    public void work() {
        System.out.println("抓老鼠");  //新增方法
    }
}

class Dog extends Animal {   //普通类继承抽象类
    public void eat() {
        System.out.println("吃骨头");   //重写父类中的抽象方法
    }

    public void work() {
        System.out.println("看家");   //新增方法
    }
}

附：
instanceof 的作用：
因为在多态发生时，子类只能调用父类中的方法（编译时类型的方法），而子类自己独有的方法（运行时类型的方法）无法调用，如果强制调用的话就需要向下转型，语法和基本类型的强制类型转换一样；但是向下转型具有一定的风险，很有可能无法成功转化，为了判断能否成功转化，就需要 instanceof 先进行一个判断，然后再进行转换操作

instanceof 是一个运算符，语法为：

引用类型变量(object) instanceof 类(class)

功能：
判断前面的对象是否属于后面的类，或者属于其子类；
如果是，返回 true，不是返回 false；

重写

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字 super。
Employee.java 文件代码

public class Employee {
    private String name;
    private String address;
    private int number;

    public Employee(String name, String address, int number) {
        System.out.println("Employee 构造函数");
        this.name = name;
        this.address = address;
        this.number = number;
    }

    public void mailCheck() {
        System.out.println("Employee 类的 mailCheck 方法 ");
        System.out.println("邮寄支票给： " + this.name + " " + this.address);
    }

    //该方法的作用：获取到这个类指向的对象的数据，且按期待的形式输出
    //例：Employee p = new Employee();
    //System.out.println(p); 隐式调用toString(0)方法
    //System.out.println(p.toString()); // 显式调用toString(0)方法
    public String toString() {
        return name + " " + address + " " + number;
    }

    public String getName() {
        return name;
    }
}

Salary.java 文件代码：

public class Salary extends Employee {
    private double salary; // 全年工资

    public Salary(String name, String address, int number, double salary) {
        super(name, address, number);
        // 关键字super，调用父类中被重写的方法，即调用了父类中的构造方法
        setSalary(salary);
    }

    public void mailCheck() {
        System.out.println("Salary 类的 mailCheck 方法 ");
        System.out.println("邮寄支票给：" + getName()
                + " ，工资为：" + salary);
    }

    public void setSalary(double newSalary) {
        if (newSalary >= 0.0) {
            salary = newSalary;
        }
    }
}

VirtualDemo.java 文件代码输出结果：

public class VirtualDemo {
    public static void main(String[] args) {
        // 子类引用子类对象
        Salary s = new Salary("员工 A", "北京", 3, 3600);
        // 父类引用子类对象
        Employee e = new Salary("员工 B", "上海", 2, 2400.00);
        // Employee e = new Employee("员工 B", "上海", 2);
        System.out.println(e);
        System.out.println("使用 Salary 的引用调用 mailCheck -- ");
        s.mailCheck();
        System.out.println("\n使用 Employee 的引用调用 mailCheck--");
        e.mailCheck();
    }
}