Java（3）封装、继承、多态-优快云博客

本文链接：https://blog.youkuaiyun.com/Tttian622/article/details/145003566

1.封装

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

public class Person {
    // 私有属性，外部代码不能直接访问
    private String name;
    // 公共构造器，用于创建对象时初始化属性
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

2.继承

完全独立的两个类，通过继承的方式可以共用一些属性或方法：

通过继承，子类可以自动获得父类的所有公共和受保护的成员（属性和方法），

而不需要重新编写相同的代码。

2.1 继承的关键字：

extends：类的继承。

implements：接口的继承。

this:指向自己的引用，引用当前对象。

super:引用当前的父类，可对其访问。

2.2 继承的特点：

一个父类可以有多个子类，而一个子类只能有一个父类
子类可以调用父类成员，父类不能调用子类成员，只能调用本类成员
子类构造器调用父类构造器，需要使用super()
子类方法中调用父类成员需要使用super.

2.3 案例

2.3.1 创建员工类

public class Emp {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

2.3.2 创建部门经理类

public class Manager extends Emp{
    private String dept;
    public String getDept() {
        return dept;
    }
    public void setDept(String dept) {
        this.dept = dept;
    }
    public String getMessage(){
        return super.getName();
    }
}

2.3.3 创建部门经理实例对象

public class Test {
    public static void main(String[] args) {
        //父类只能调用本类成员，而子类可以调用本类及父类成员
        Emp emp = new Emp();
        Manager m = new Manager();
        m.setName("Adela");

        System.out.println(m.getName());
        //或
        String message = m.getMessage();
        System.out.println(message);
        //或
        System.out.println(m);
    }
}

2.4 构造器

构造器的主要作用是在创建对象时为对象的属性设置初始值，或者执行一些必要的初始化操作。

构造器的名称必须与类名相同，并且没有返回类型（连 void 也没有）。

子类不继承父类的构造器（包括构造方法和构造函数），他只是调用。

下方案例通过构造器对部门经理进行属性值初始化，要求父类数据：

2.4.1 员工类

public class Emp {
    private String name;
//  构造器👇
    public Emp() {}
    public Emp(String name) {
        this.name = name;
    }👆
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override👇
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                '}';
    }👆
}

2.4.2 经理类

public class Manager extends Emp{
    private String dept;
//  构造器👇
    public Manager() {}
    public Manager(String name) {
        super(name);
        this.dept = dept;

    }👆
    public String getDept() {
        return dept;
    }
    public void setDept(String dept) {
        this.dept = dept;
    }
    @Override👇
    public String toString() {
        return "Manager{" +
                "dept='" + dept + '\'' +
                "} " + super.toString();
    }👆
}

2.4.3 实例对象

public class Test {
    public static void main(String[] args) {
        //父类只能调用本类成员，而子类可以调用本类及父类成员
        Emp emp = new Emp();
        Manager m = new Manager();
        m.setName("Adela");
        👇
        Manager m1 = new Manager("Hela");
        System.out.println(m1);
    }   👆
}

3.多态

一种事物的多种存在形式或一种行为的多种实现方式。

多态允许不同类的对象对同一消息做出响应的能力。

多态性使得同一个接口可以被不同的对象以不同的方式实现，从而提供了更大的灵活性和扩展性。

3.1 多态存在的必要条件

继承
重写
父类声明、子类创建对象

3.2 案例

模拟员工工资计算方式：

1.普通员工，按月领取工资

2.小时工，按小时领取工资，超过160小时为加班，超过部分按1.5计算

3.销售人员，按照销售数量算提成

4.过生日的员工，加100块

3.2.1 获得工资父类

public abstract class Employee {
    String name;
    int birthMonth;
    //获得工资
    public abstract double getSalary(int month);
}

3.2.2 普通员工薪资规则

public class SalariedEmployee extends Employee{
    double monthly;//基本月工资
    @Override
    public double getSalary(int month) {
        if (month == birthMonth) {
            return monthly+100;
        }else{
            return monthly;
        }
    }
}

3.2.3 小时工薪资规则

public class HourlyEmployee extends Employee{
    double hourly;//每个小时的加班费用
    double hour;//加班时间
    @Override
    public double getSalary(int month) {
        double salary=0;
        if (hour>160){
            salary = 160*hourly+(hour-160)*hourly*1.5;
        }else{
            salary = hour*hourly;
        }
        if (month==birthMonth){
            salary += 100;
        }
        return salary;
    }
}

3.2.4 销售人员薪资规则

public class SalesEmployee extends Employee{
    double sales;//销售数量
    double rate;//提成
    @Override
    public double getSalary(int month) {
        if (month == birthMonth){
            return sales*rate+100;
        }else{
            return sales*rate;
        }
    }
}

3.2.5 实例对象

public class Test {
    public static void payWage(Employee e,int month) {
        double wage = e.getSalary(month);
        System.out.println(wage);
    }
    public static void main(String[] args) {
        Employee[] e=new Employee[3];
        SalariedEmployee salariedEmployee=new SalariedEmployee();
        salariedEmployee.name="Adela";
        salariedEmployee.birthMonth=5;
        salariedEmployee.monthly =3000;

        HourlyEmployee hourlyEmployee=new HourlyEmployee();
        hourlyEmployee.name="Hela";
        hourlyEmployee.birthMonth=4;
        hourlyEmployee.hourly=20;
        hourlyEmployee.hour=180;

        SalesEmployee salesEmployee=new SalesEmployee();
        salesEmployee.name="Hecate";
        salesEmployee.birthMonth=3;
        salesEmployee.sales=100000;
        salesEmployee.rate=0.05;

        e[0]=salariedEmployee;
        e[1]=hourlyEmployee;
        e[2]=salesEmployee;

        for(int i=0;i<e.length;i++){
            Test.payWage(e[i],5);
        }
    }
}