继承，组合，和多态的介绍

面向对象编程指的是在编程中使用对象的语言。面向对象编程旨在在编程中实现现实世界的实体，如继承、隐藏、多态性等。面对对象编程的主要目的是将数据和对其进行操作的函数绑定在一起，以便代码的其他部分除了该函数之外不能访问该数据。

继承

假设在一个公司里面有很多员工，分为Manager和Employee, 有相同的特征，也有不同的地方，比如普通雇员在完成本职任务之后仅领取薪水，而经理在完成了预期的业绩之后还能得到奖金。这种情形就需要使用继承。这是因为需要为经理定义一个新类 Manager, 以便增加一些新功能。但可以重用 Employee 类中已经编写的部分代码，并将其中的所有域保留下来。

由继承 Employee 类来定义 Manager 类的格式，关键字 extends 表示继承。

public 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;
        is hireDay = LocalDate.of(year, month, day);
        }
        
        is public String getName{
        return name;
       }
        
    public double getSalary{
        
        return salary;
        }

    public LocalDate getHireDay{
        
        return hireDay;
        }

    public void raiseSalary(double byPercent) {
    double raise = salary * byPercent / 100;
    salary += raise;
}

    public class Manager extends Employee{
        private double bonus;
    public Manager(String name,double salary,int year, int month,int day){
        super(name,salary,year,month,day);
        bonus=0;
}
    public double getSalary(){
         double baseSalary+super.getSalary();
         return baseSalary+bonus;
}

然而，超类中的有些方法对子类 Manager 并不一定适用。具体来说， Manager 类中的
getSalary方法应该返回薪水和奖金的总和。为此，需要提供一个新的方法来覆盖（override)
超类中的这个方法：

super.getSalary()

 public class Manager extends Employee{
        private double bonus;
    public Manager(String name,double salary,int year, int month,int day){
        super(name,salary,year,month,day);
        bonus=0;
}

super（）只能在类的非静态方法中使用，用来访问非静态成员方法和字段；在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

继承层次

从某个特定的类到其祖先的路径被称为该类的继承链，一个祖先类可以拥有多个子孙
继承链。例如，可以由 Employee 类派生出子类 Programmer 或 Secretary，它们与
Manager 类没有任何关系。

继承方式

在Java中，可以实现单继承（A->B），多层继承（A->B->C）,不同类继承同一个类（A->B&&A->C）.

子类继承父类各部分执行顺序为：父静态代码块--子静态代码块--父非静态代码--父无参构造函数--子静态代码块--子构造函数--方法。

注意：创建子类对象调用子类的构造方法的时候会先调用父类的构造方法。

继承与组合

组合跟继承类似，也可以实现代码重用的效果。区别：采用继承的对象间是is-a的关系（苹果和香蕉都是水果），采用组合的对象间是has-a的关系（前桥，方向盘，和发动机等都是汽车所具备的）。。一般建议：能用组合尽量用组合。

// 前桥类
class FrontAxle{
// ...
} 
//发动机类
class Engine{
// ...
} 
//方向盘类
class SteeringWheel{
// ...
}
class Car{
private FrontAxle frontaxle; // 可以复用前桥中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private SteeringWheel steeringwheel; // 可以复用方向盘中的属性和方法
// ...
} 
//奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：前桥、发动机、方向盘全部继承下来
}

多态

多态指的是在完成某种行为中，采用不同的对象去完成会出现多种不同的状态。在运行时能够自动地选择调用哪个方法的现象称为动态绑定。

多态的实现条件

必须在继承体系下
子类必须要对父类中方法进行重写
通过父类的引用调用重写的方法
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法

public class Boss extends Employee {
    public Boss(String name, int hireDay) {
        super(name, hireDay);
    }

    public void getSalary() {
        System.out.println(name + " get Revenue");
    }
}
public class Manager extends Employee {
    public Manager(String name, int hireDay) {
        super(name, hireDay);
    }

    public void getSalary() {
        System.out.println(name + " get bonus");
    }
}

public class TestEmployee{
    public static void getSalary(Employee a){
        a.getSalary();
    }


    public static void main(String[] args) {
        Boss boss = new Boss("Bris", 200);
        Manager manager = new Manager("Cal", 100);

        getSalary(boss);
        getSalary(manager);
    }
}

编译器在编译代码时，并不知道要调用Manager还是Boss中getSalary的方法,
等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法。

继承，组合，和多态的介绍

猜你喜欢