【Java面向对象】06 继承

继承

使用extends根据新类派生一个已存在的类。

继承满足条件

两同两小一大

方法名，参数同
返回值类型和异常小于父类
访问权限比父类大

public class ExtendsDemo {
    
    public static void main(String[] args) {
    
        Manager boss = new Manager("a", 1000, 1999, 1, 1);
        boss.setBonus(5000);

        Employee[] staff = new Employee[3];
        staff[0] = boss; // Manager@559
        staff[1] = new Employee("b", 2000, 1999, 1, 1); // Employee@573
        staff[2] = new Employee("c", 3000, 1999, 1, 1); //Employee@562

        // e既可以引用Employee类型，也可以引用Manager类型
        // 一个对象变量可以指示多种实际类型的现象称为多态，在运行期能够自动选择调用哪个方法的现象称为动态绑定
        // e引用的是那个类型的对象，调用的就是那个对象的方法
        for (Employee e : staff) {
    
            System.out.println(e.getSalary());
        }
    }
}

// 超类
class Employee {
    
    private String name;
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day) {
    
        this.name = name;
        this.salary = salary;
        this.hireDay = LocalDate.of(year, month, day);
    }

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

    @Override
    public String toString() {
    
        return "Employee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                ", hireDay=" + hireDay +
                '}';
    }
}

// 子类
class Manager extends Employee {
    

    public Manager(String name, double salary, int year, int month, int day) {
    
        // 1.使用super调用父类构造器，构造器必须在第一行
        // 2.默认调用无参构造函数，如果父类不写无参构造，则编译错误
        super(name, salary, year, month, day);
        bonus = 0;
    }

    private double bonus;

    // 重写父类方法
    @Override
    public double getSalary() {
    
        // 1.不能直接访问父类的私有属性
        // 2.调用父类方法通过super关键字
        return super.getSalary() + bonus;
    }

    public double getBonus() {
    
        return bonus;
    }

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

    @Override
    public String toString() {
    
        return "Manager{" +
                "bonus=" + bonus +
                "} " + super.toString();
    }
}

使用super调用父类构造器，构造器必须在第一行
默认调用无参构造函数，如果父类不写无参构造，则编译错误
子类不能访问父类的私有属性和方法
调用父类方法使用super关键字

方法调用过程

编译器查看对象的声明类型和方法名，可能存在多个相同的名字，但是参数类型不同的方法。编译器会一一列举所有本类和超类的public方法，作为候选方法。
编译器将查看调用方法时提供的参数类型。如果存在方法与提供的类型完全匹配，就选择这个方法。这个过程就称为重载解析。如果编译器没有找到与参数类型匹配的方法，或者有多个类型匹配，会报错。
如果是private，static，final，或者构造器，编译器可以准确的知道调用哪个方法，这种方式称为静态绑定。与此对应依赖参数的实际类型，称为动态绑定。
当程序运行时，采用动态绑定，虚拟机调用最合适的方法。如果x的实际类型是D，它是C的子类，D中定义了方法，就直接调用，否则在它的父类中寻找。