Java——员工工资计算系统（Employee Wage Calculation System）

 要求如下：

这是一个关于员工工资计算的Java编程题目。要求使用面向对象的思想，定义员工的基本属性和计算工资的方法，并实现不同类型员工工资的计算。通过这个题目，可以深入理解Java中的继承、多态、重写等概念，以及protected关键字的用法。

具体要求如下：

1. 定义一个员工基类Employee，包含姓名、出生月份等基本属性，以及一个计算工资的方法calculateSalary。
2. 定义三个子类，分别是拿固定工资的员工SalariedEmployee、按小时拿工资的员工HourlyEmployee和销售人员SalesEmployee。每个子类继承自Employee类，并重写calculateSalary方法，根据不同的工资计算方式计算工资。
3. 在主类Main中，创建几个不同类型的员工对象，并打印他们的信息以及某个月的工资。

示例代码如下：

import java.time.Month;
//父类：Employee
class Employee{
    private String name;
    private Month birthmonth;
    protected Employee(String name, Month birthmonth){
        this.name = name;
        this.birthmonth = birthmonth;
    }

    public String getName() {
        return name;
    }

    public Month getMonth() {
        return birthmonth;
    }
    public int calculateSalary(int month){
        int bonus = birthmonth.getValue() == month ? 100:0;
        return bonus;
    }
}
//子类：拿固定工资的员工（SalariedEmployee）
class SalariedEmployee extends Employee{
    private int monthlySalary;
    public SalariedEmployee(String name, Month birthmonth, int monthlySalary) {
        super(name, birthmonth);
        this.monthlySalary = monthlySalary;
    }

    public int getMonthlySalary() {
        return monthlySalary;
    }

    @Override
    public int calculateSalary(int month) {
        return super.calculateSalary(month)+monthlySalary;
    }
}
//子类：按小时拿工资的员工（HourlyEmployee）
class HourlyEmployee extends Employee{
    private double hourlyRate;
    private int hoursWorked;
    public HourlyEmployee(String name, Month birthmonth, double hourlyRate, int hoursWorked) {
        super(name, birthmonth);
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    public double getHourlyRate() {
        return hourlyRate;
    }

    public int getHoursWorked() {
        return hoursWorked;
    }

    @Override
    public int calculateSalary(int month) {
        int baseSalary = (int)(hourlyRate*Math.min(hoursWorked,160));
        int overtimeSalary = (int)(hourlyRate*1.5*Math.max(0,hoursWorked - 160));
        return super.calculateSalary(month);
    }
}
// 子类：销售人员（SalesEmployee）
class SalesEmployee extends Employee {
    private double monthlySales;
    private double commissionRate;

    public SalesEmployee(String name, Month birthMonth, double monthlySales, double commissionRate) {
        super(name, birthMonth);
        this.monthlySales = monthlySales;
        this.commissionRate = commissionRate;
    }

    public double getMonthlySales() {
        return monthlySales;
    }

    public double getCommissionRate() {
        return commissionRate;
    }

    @Override
    public int calculateSalary(int month) {
        int commission = (int) (monthlySales * commissionRate);
        return super.calculateSalary(month) + commission;
    }
}
// 子类：有固定底薪的销售人员（BasePlusSalesEmployee）
class BasePlusSalesEmployee extends SalesEmployee {
    private int baseSalary;

    public BasePlusSalesEmployee(String name, Month birthMonth, double monthlySales, double commissionRate, int baseSalary) {
        super(name, birthMonth, monthlySales, commissionRate);
        this.baseSalary = baseSalary;
    }

    public int getBaseSalary() {
        return baseSalary;
    }

    @Override
    public int calculateSalary(int month) {
        return super.calculateSalary(month) + baseSalary;
    }

}
public class Main {
    public static void main(String[] args) {
        // 创建几个不同类型的员工对象
        Employee employee1 = new SalariedEmployee("Alice", Month.JANUARY, 3000);
        Employee employee2 = new HourlyEmployee("Bob", Month.FEBRUARY, 20, 200);
        Employee employee3 = new SalesEmployee("Charlie", Month.MARCH, 10000, 0.05);
        Employee employee4 = new BasePlusSalesEmployee("David", Month.APRIL, 15000, 0.04, 2500);

        // 打印某个员工的信息
        printEmployeeInfo(employee1);
        System.out.println();
        printEmployeeInfo(employee2);
        System.out.println();
        printEmployeeInfo(employee3);
        System.out.println();
        // 打印某个员工在某个月的工资
        System.out.println(employee1.getName() + ": " + employee1.calculateSalary(3));
        System.out.println(employee2.getName() + ": " + employee2.calculateSalary(4));
        System.out.println(employee3.getName() + ": " + employee3.calculateSalary(5));
        System.out.println(employee4.getName() + ": " + employee4.calculateSalary(6));

    }

    private static void printEmployeeInfo(Employee employee) {
        System.out.println("Name: " + employee.getName());
        System.out.println("Birth Month: " + employee.getMonth());
        System.out.println("Salary for current month (assuming current month is 7): " + employee.calculateSalary(7));
        System.out.println("--------------------");
    }
}

解释：

这段代码实现了一个员工工资计算的程序。首先定义了一个父类Employee，包含姓名、出生月份等基本信息，以及一个计算工资的方法calculateSalary。然后定义了三个子类，分别是拿固定工资的员工（SalariedEmployee）、按小时拿工资的员工（HourlyEmployee）和销售人员（SalesEmployee）。每个子类都继承了Employee类，并重写了calculateSalary方法，根据不同的工资计算方式计算工资。最后定义了一个主类Main，创建了几个不同类型的员工对象，并打印了他们的信息以及某个月的工资。

实现原理：
- 使用继承和多态，使得每个子类都可以使用Employee类的属性和方法，同时也可以有自己的特有属性和方法。
- 使用protected关键字，使得子类可以访问父类的属性和方法。
- 使用重写（override）方法，使得子类可以继承父类的方法，并对其进行扩展或修改。

用途：
- 用于计算不同类型员工的工资。

注意事项：
- 注意子类和父类的关系，以及protected关键字的用法。
- 注意重写（override）方法的规则，即子类的方法必须与父类的方法具有相同的签名。
- 注意代码的封装和可读性，使得代码更加易于理解和维护。