某公司的雇员分为以下若干类： (1) employee：这是所有员工总的父类。 ① 属性：员工的姓名,员工的生日月份 ② 方法：getsalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会 额外奖励100 元。 (2) salariedemployee：employee 的子类，拿固定工资的员工。 ① 属性：月薪。 (3)hourlyemployee：employee 的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5 倍工资发放。 ① 属性：每小时的工资、每月工作的小时数。 (4) salesemployee：employee 的子类，销售，工资由月销售额和提成率决定。 ① 属性：月销售额、提成率。 (5) baseplussalesemployee：salesemployee 的子类，有固定底薪的销售人员，工资由底薪加 上销售提成部分。 ① 属性：底薪。 要求： 创建一个employee 数组，分别创建若干不同的employee对象，并打 印某个月的工资。 注意：要求把每个类都做成完全封装，不允许非私有化属性。

### 回答1：
这是一个面向对象的编程问题，要求创建一个employee数组，包含不同类型的员工对象，并计算某个月的工资。其中，employee是所有员工的父类，包含姓名和生日月份属性，以及根据月份计算工资的方法。其子类包括salariedemployee、hourlyemployee、salesemployee和baseplussalesemployee，分别对应拿固定工资、按小时拿工资、按销售额拿工资和有固定底薪的销售人员。每个子类都有自己的属性和计算工资的方法。

要求把每个类都做成完全封装，不允许非私有化属性。这意味着属性只能通过方法访问，而不能直接访问。这样可以保证数据的安全性和可维护性。

具体实现可以参考以下代码：

public class Employee {
    private String name;
    private int birthMonth;

    public Employee(String name, int birthMonth) {
        this.name = name;
        this.birthMonth = birthMonth;
    }

    public String getName() {
        return name;
    }

    public int getBirthMonth() {
        return birthMonth;
    }

    public double getSalary(int month) {
        double salary = 0;
        // calculate salary based on month and other factors
        // ...
        if (month == birthMonth) {
            salary += 100; // bonus for birthday
        }
        return salary;
    }
}

public class SalariedEmployee extends Employee {
    private double monthlySalary;

    public SalariedEmployee(String name, int birthMonth, double monthlySalary) {
        super(name, birthMonth);
        this.monthlySalary = monthlySalary;
    }

    public double getMonthlySalary() {
        return monthlySalary;
    }

    public double getSalary(int month) {
        return monthlySalary + super.getSalary(month);
    }
}

public class HourlyEmployee extends Employee {
    private double hourlyWage;
    private int monthlyHours;

    public HourlyEmployee(String name, int birthMonth, double hourlyWage, int monthlyHours) {
        super(name, birthMonth);
        this.hourlyWage = hourlyWage;
        this.monthlyHours = monthlyHours;
    }

    public double getHourlyWage() {
        return hourlyWage;
    }

    public int getMonthlyHours() {
        return monthlyHours;
    }

    public double getSalary(int month) {
        double salary = hourlyWage * monthlyHours;
        if (monthlyHours > 160) {
            salary += hourlyWage * 1.5 * (monthlyHours - 160);
        }
        return salary + super.getSalary(month);
    }
}

public class SalesEmployee extends Employee {
    private double monthlySales;
    private double commissionRate;

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

    public double getMonthlySales() {
        return monthlySales;
    }

    public double getCommissionRate() {
        return commissionRate;
    }

    public double getSalary(int month) {
        return monthlySales * commissionRate + super.getSalary(month);
    }
}

public class BasePlusSalesEmployee extends SalesEmployee {
    private double baseSalary;

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

    public double getBaseSalary() {
        return baseSalary;
    }

    public double getSalary(int month) {
        return baseSalary + super.getSalary(month);
    }
}

public class Main {
    public static void main(String[] args) {
        Employee[] employees = new Employee[5];
        employees[0] = new SalariedEmployee("Alice", 3, 5000);
        employees[1] = new HourlyEmployee("Bob", 5, 20, 180);
        employees[2] = new SalesEmployee("Charlie", 7, 10000, 0.1);
        employees[3] = new BasePlusSalesEmployee("David", 9, 8000, 0.2, 3000);
        employees[4] = new Employee("Eve", 11);

        int month = 7;
        for (Employee employee : employees) {
            System.out.println(employee.getName() + "'s salary in month " + month + " is " + employee.getSalary(month));
        }
    }
}

这段代码创建了一个包含5个不同类型的员工对象的数组，然后计算了7月份每个员工的工资，并打印出来。其中，SalariedEmployee、HourlyEmployee、SalesEmployee和BasePlusSalesEmployee都是Employee的子类，分别对应拿固定工资、按小时拿工资、按销售额拿工资和有固定底薪的销售人员。每个子类都重写了Employee的getSalary方法，以实现自己的计算工资逻辑。最后，通过循环遍历数组，依次计算每个员工的工资并打印出来。

### 回答2：
首先，根据题目要求，我们需要创建五个类：employee、salariedemployee、hourlyemployee、salesemployee和baseplussalesemployee。其中，employee为父类，其余四个类为其子类。

我们首先在employee类中定义属性和方法，属性包括员工姓名和生日月份，方法包括getsalary(int month)来确定工资。如果员工在该月过生日，则公司会额外奖励100元。代码如下：

public class Employee {
    private String name;
    private int birthMonth;
    
    public Employee(String name, int birthMonth) {
        this.name = name;
        this.birthMonth = birthMonth;
    }
    
    public int getSalary(int month) {
        int salary = 0;
        // 计算员工工资
        // ...
        // 如果员工在该月过生日，则额外奖励100元
        if (month == birthMonth) {
            salary += 100;
        }
        return salary;
    }
}

接下来，我们创建salariedemployee、hourlyemployee、salesemployee和baseplussalesemployee类。

对于salariedemployee类，我们可以定义一个属性为月薪（salary），代码如下：

public class SalariedEmployee extends Employee {
    private int salary;
    
    public SalariedEmployee(String name, int birthMonth, int salary) {
        super(name, birthMonth);
        this.salary = salary;
    }
    
    @Override
    public int getSalary(int month) {
        int salary = super.getSalary(month);
        // 计算月薪
        salary += this.salary;
        return salary;
    }
}

对于hourlyemployee类，我们可以定义两个属性为每小时的工资（hourlyWage）和每月工作的小时数（workedHour），超出部分按照1.5倍工资发放，代码如下：

public class HourlyEmployee extends Employee {
    private int hourlyWage;
    private int workedHour;
    
    public HourlyEmployee(String name, int birthMonth, int hourlyWage, int workedHour) {
        super(name, birthMonth);
        this.hourlyWage = hourlyWage;
        this.workedHour = workedHour;
    }
    
    @Override
    public int getSalary(int month) {
        int salary = super.getSalary(month);
        // 计算工作时长
        int extraHours = Math.max(workedHour - 160, 0);
        // 计算工资
        salary += workedHour * hourlyWage + extraHours * hourlyWage * 1.5;
        return salary;
    }
}

对于salesemployee类，我们可以定义两个属性为月销售额（sales）和提成率（commission），工资由月销售额和提成率决定，代码如下：

public class SalesEmployee extends Employee {
    private double sales;
    private double commission;
    
    public SalesEmployee(String name, int birthMonth, double sales, double commission) {
        super(name, birthMonth);
        this.sales = sales;
        this.commission = commission;
    }
    
    @Override
    public int getSalary(int month) {
        int salary = super.getSalary(month);
        // 计算销售提成
        salary += sales * commission;
        return salary;
    }
}

对于baseplussalesemployee类，我们可以继承自salesemployee类，再定义一个属性为底薪（baseSalary），工资由底薪加上销售提成部分。代码如下：

public class BasePlusSalesEmployee extends SalesEmployee {
    private int baseSalary;
    
    public BasePlusSalesEmployee(String name, int birthMonth, double sales, double commission, int baseSalary) {
        super(name, birthMonth, sales, commission);
        this.baseSalary = baseSalary;
    }
    
    @Override
    public int getSalary(int month) {
        int salary = super.getSalary(month);
        // 加上底薪
        salary += baseSalary;
        return salary;
    }
}

接着，我们创建一个employee数组，并创建不同的employee对象，最后打印某个月的工资。代码如下：

public class Test {
    public static void main(String[] args) {
        Employee[] employees = new Employee[4];
        employees[0] = new SalariedEmployee("张三", 6, 5000);
        employees[1] = new HourlyEmployee("李四", 7, 50, 180);
        employees[2] = new SalesEmployee("王五", 8, 10000, 0.2);
        employees[3] = new BasePlusSalesEmployee("赵六", 9, 15000, 0.1, 5000);
        
        int month = 8;
        for (Employee employee : employees) {
            System.out.println("员工姓名：" + employee.getName() + "，工资：" + employee.getSalary(month));
        }
    }
}

至此，我们完成了题目要求的所有内容。注意，我们在以上代码中并没有给出所有的属性和方法，只是提供了部分示例代码，具体实现还需要根据题目要求自行完成。

### 回答3：
首先需要创建一个Employee类，作为其他几个子类的父类，它包含两个属性：员工姓名和生日月份，以及一个获取工资的方法getSalary(int month)。该方法会根据月份参数来计算工资，并返回工资的金额，如果该月是员工的生日月份，那么公司会额外奖励100元。

接下来需要创建SalariedEmployee类，继承自Employee类，拥有一个月薪属性，该属性会被用来计算工资。

然后需要创建HourlyEmployee类，同样继承自Employee类，拥有每小时的工资和每月工作小时数两个属性，以及根据工作时长算出工资的方法。

Salesemployee类也是继承自Employee类，不过它拥有月销售额和提成率两个属性，利用这些属性计算得到工资金额。

最后是BasePlusSalesEmployee类，它继承Salesemployee类，拥有一个额外的底薪属性，它的工资则由底薪和销售提成部分加总得到。

为了方便操作，可以创建一个Employee数组，用来存储所有雇员的信息。接着分别创建各种类型的Employee对象，并将它们存放到数组中。最后，通过循环遍历数组，打印出每个雇员在指定月份的工资金额即可。

无论是Employee类还是其子类，都要进行完全封装，将属性都设为私有的，避免外部直接访问和修改属性。提供公开的方法来获取和设置属性的值，以确保数据的安全性。

总而言之，这道题目主要考察了面向对象编程的基本原理和封装的技巧，需要掌握继承、多态等知识点，并学会运用到具体的问题中。