关于Java中的继承

继承

我们将通用的方法放在超类也就是父类中，子类通过继承使用超类的方法和域。
子类不能直接使用超类中的域，例如：

//超类
import java.time.LocalDate;

public class Employee {
    private String name;
    private double salary;
    private LocalDate hireday;

    public Employee(String name, double salary, LocalDate hireday) {
        this.name = name;
        this.salary = salary;
        this.hireday = hireday;
    }

    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;
    }

    public LocalDate getHireday() {
        return hireday;
    }

    public void setHireday(LocalDate hireday) {
        this.hireday = hireday;
    }
    
    public void raiseSalary(double percent){
        double raise = salary*percent/100;
        salary += raise;
    }
}
//这是一个标准的超类，有三个私有域，和一个公有方法、
//如果一个子类继承超类
public class Manager extends Employee {
    private double bonus;

    public Manager(String name, double salary, LocalDate hireday, double bonus) {
        super(name, salary, hireday);
        this.bonus = bonus;
    }

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

子类新增了一个域和设置这个域的方法
如果我们新增一个Manager类的对象，对象是可以直接使用超类和自己的方法的

LocalDate today = LocalDate.now(); //获取当前日期 年月日
Manager manager = new Manager("jack", 1000, today, 100);
manager.setName("lus");
manager.setBonus(100);

但是，manager不可以直接使用超类中的私有域，类似于以下操作是错误的
manager.name = "jax";
必须通过超类的方法进行设置
如果想覆盖超类的中的方法，可以直接重写方法

public double getSalary(){
      return getSalary() + bouns;
}

但这样会导致新的错误，因为getSalary()方法会无限调用自己，所以需要加上super前缀

public double getSalary(){
      return super.getSalary() + bouns;
}

super 和 this不是类似的概念，super不是一个对象的引用，不能将super赋给另一个对象变量，它只是一个特殊关键字

关于构造器

在上面的子类中已经给出了一个构造器，里面的关键字super有不同的含义

public Manager(String name, double salary, LocalDate hireday, double bonus) {
        super(name, salary, hireday);
        this.bonus = bonus;
    }

其中super的意思是调用超类中含有name, salary, hireday参数的构造器的简写形式
使用super调用构造器的语句必须是子类构造器的第一条语句
如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认（没有参数 )的构造器。
如果超类没有不带参数的构造器，并且在子类的构造器中又没有显式地调用超类的其他构造器，则 Java 编译器将报告错误。
一个对象变量可以指示多种实际类型的现象被称为多态（polymorphism)。
在运行时能够自动地选择调用哪个方法的现象称为动态绑定（ dynamic binding)。

多态

程序中出现超类对象的任何地方都可以用子类对象置换，例如可以将一个子类对象赋给超类对象：

Employee e;
e = new Employee(...);
e = new Manager(...);

在 Java 程序设计语言中，对象变量是多态的。一个 Employee 变量既可以引用一个
Employee 类对象，也可以引用一个 Employee 类的任何一个子类的对象。
不能将一个超类的引用赋给子类变量

Employee[] staff = new Employee[3];
Manager boss = new Manager(...);
staff[0] = boss;
//子类引用赋给超类是可以的
Manager m = staff[i];
//超类引用赋给子类是错误的

下面定义一个三个雇员的数组

Employee[] staff = new Employee[3];

将Employee对象和Manager对象都放到数组中

staff[0] = boss;
staff[1] = new Employee(...);
staff[2]= new Employee(...);

输出每个人的salary

for (Employee e : staff){
    System.out.println(e.getName + " " + e.getSalary());
}

这里的对象e既可以指示Employee对象，也可以指Manager对象，分别调用对应的salary方法，这种现象就是多态。

阻止继承

不允许被扩展的类称为final类，表现形式为在类定义时，class前加入final修饰符。
类中特定的方法也可以加final修饰符，表示不允许子类覆盖这个类，final类中的所有方法自动的成为final方法。