Java继承与多态-优快云博客

本文链接：https://blog.youkuaiyun.com/xzx4959/article/details/78936237

Java新创建的类可以使用关键字extends继承一个已经存在的类，已经存在的类我们称之为超类，基类或父类；新创建的类我们称为子类、派生类或孩子类。看下面的基类Coder：

public class Coder {
    private Integer id;
    private String name;
    private double salary;

    public Coder(Integer id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Coder中包含工号id，姓名name和工资salary三个属性，Leader中除了包含Coder的属性以外，还包含奖金bonus，相应的薪水应该是奖金bonus 加上工资salary，Leader的代码如下：

public class Leader extends Coder {
    private double bonus;

    public Leader(Integer id, String name, double salary, double bonus) {
        super(id, name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public double getSalary() {
        return bonus + super.getSalary();
    }
}

此时需要注意，Leader的getSalary()方法需要调用父类Coder中的getSalary方法，需要使用特定的关键字super。super不是一个对象的引用，不能将super赋给另外一个对象变量，它是一个指示编译器调用超类方法的特殊关键字。Leader 的构造器中也使用了super关键字 super(id, name, salary); 这个是指调用父类Coder中含有id，name和salary参数的构造器。使用super关键字调用构造器的语句必须是子类构造器的第一条语句，如果子类的构造器没有显式的调用超类的构造器，则会默认的调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中又没有显式地调用超类的其他构造器，则Java编译器将报告错误。和this关键字对比来看，我们可以得到以下结论：

this：引用隐式参数，调用该类其他的方法包括构造器。
super：调用超类的方法包括超类的构造器。

多态和动态绑定

一个对象变量可以指示多种实际类型的现象称为多态，例如一个Coder变量既可以引用一个Coder类对象，也可以引用一个Coder类的子类对象（例如，Leader）。在运行时能够自动地选择调用哪个方法的线程称为动态绑定，动态绑定的调用过程如下：

编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数x声明为C类的对象。需要注意的是：有可能存在多个名字为f，但参数类型不一样的方法。例如，可能存在f(int)和方法f(String)。编译器将会一一列举所有C类中名为f的方法和其超类中访问属性为public且名为f的方法。至此，编译器已获得所有可能被调用的候选方法。
接下来，编译器将查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，就选择这个方法。这个过程被称为重载解析。例如，对于调用x.f("Hello")来说，编译器将会挑选f(String)，而不是f(int)。由于允许类型转换（int可以转换成double），所以这个过程可能会很复杂。如果编译器没有找到与参数类型匹配的方法，或者发现经过类型转换后有多个方法与之匹配，就会报告一个错误。
如果是private方法，static方法，final方法或者构造器，那么编译器就可以准确地知道应该调用哪个方法，我们将这种调用方式称为静态绑定。
当程序运行，并且采用动态绑定调用方法时，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。假设x的实际类型是D，它是C类的子类。如果D类定义了方法f(String)，就直接调用它；否则将在D类的超类中寻找f(String)，以此类推。每次调用方法都要进行搜索，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表，其中列出了所有方法的签名和实际调用的方法。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。

我们以Coder的getSalay()为例，看一下动态绑定的具体过程，如下实例代码：

 Coder coder = new Leader(1,"martin",10023.21,3425.23);
 System.out.println(coder.getSalary());

首先，虚拟机提取coder的实际类型方法表，既可以是Coder，也可以是Leader的方法表，还包括Coder类的其他子类的方法表。
虚拟机搜索getSalary()签名的类，此时，虚拟机已经知道了调用哪个类的方法。
最后虚拟机调用该方法，即Leader的getSalary()方法。

需要注意的是：在覆盖一个方法的时候，子类方法不能低于父类方法的可见性。特别是，如果父类的方法是public，那么子类的方法也应该定义为public的。Java的访问修饰符如下：

仅对本类可见——private
对所有类可见——public
对本包和所有子类可见——protected
对本包可见——默认，不需要修饰符

不允许继承：final类和方法

不允许继承的类称为final类，如果在定义类的时候使用了final修饰符就表明这个类是final类。类中的方法也可以被声明为final的，子类不能覆盖被声明为final的父类中的方法。对于final域来说，构造对象之后就不允许改变它们的值了，final类中的所有方法会自动的成为final方法，但是不包括域。

将方法或者类声明为final的主要目的是：确保它们不会在子类中改变语义。例如String类就是一个final类，这意味着不允许任何类继承String类。