抽象工厂模式：Java实现薪资计算系统

根据您的需求，我建议选择抽象工厂模式来创建这三种职务的员工。

抽象工厂模式是一种创建型设计模式，它提供了一种将对象的创建委托给实现了共同接口的工厂类的方式。在您的情况下，每种职务需要创建不同的员工对象，而每个员工对象都有不同的工资和奖金，因此抽象工厂模式是一个合适的选择。

以下是使用Java代码实现的简单示例：

首先，我们定义一个抽象的Employee接口，定义了员工的共同行为和方法：

public interface Employee {
    String getName();
    String getPosition();
    float calculateSalary();
}

接下来，我们定义一个抽象的EmployeeFactory接口，用于创建不同职务的员工对象：

public interface EmployeeFactory {
    Employee createEmployee(String name, String position, float salary, float bonus);
}

然后，我们实现具体的职务类，其中包括Manager、Sales和Programmer，它们实现了Employee接口：

public class Manager implements Employee {
    private String name;
    private String position;
    private float salary;
    private float bonus;

    public Manager(String name, String position, float salary, float bonus) {
        this.name = name;
        this.position = position;
        this.salary = salary;
        this.bonus = bonus;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getPosition() {
        return position;
    }

    @Override
    public float calculateSalary() {
        return salary + bonus;
    }
}

public class Sales implements Employee {
    private String name;
    private String position;
    private float salary;
    private float bonus;

    public Sales(String name, String position, float salary, float bonus) {
        this.name = name;
        this.position = position;
        this.salary = salary;
        this.bonus = bonus;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getPosition() {
        return position;
    }

    @Override
    public float calculateSalary() {
        return salary + bonus;
    }
}

public class Programmer implements Employee {
    private String name;
    private String position;
    private float salary;
    private float bonus;

    public Programmer(String name, String position, float salary, float bonus) {
        this.name = name;
        this.position = position;
        this.salary = salary;
        this.bonus = bonus;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getPosition() {
        return position;
    }

    @Override
    public float calculateSalary() {
        return salary + bonus;
    }
}

最后，我们创建具体的EmployeeFactory实现类，用于根据职务创建相应的员工对象：

public class ConcreteEmployeeFactory implements EmployeeFactory {
    @Override
    public Employee createEmployee(String name, String position, float salary, float bonus) {
        if (position.equals('Manager')) {
            return new Manager(name, position, salary, bonus);
        } else if (position.equals('Sales')) {
            return new Sales(name, position, salary, bonus);
        } else if (position.equals('Programmer')) {
            return new Programmer(name, position, salary, bonus);
        }
        throw new IllegalArgumentException('Invalid position: ' + position);
    }
}

现在，您可以使用ConcreteEmployeeFactory类来创建不同职务的员工对象，如下所示：

public class Main {
    public static void main(String[] args) {
        EmployeeFactory employeeFactory = new ConcreteEmployeeFactory();

        Employee manager = employeeFactory.createEmployee('John', 'Manager', 5000, 1000);
        Employee sales = employeeFactory.createEmployee('Alice', 'Sales', 3000, 500);
        Employee programmer = employeeFactory.createEmployee('Bob', 'Programmer', 4000, 800);

        System.out.println(manager.getName() + ': ' + manager.calculateSalary());
        System.out.println(sales.getName() + ': ' + sales.calculateSalary());
        System.out.println(programmer.getName() + ': ' + programmer.calculateSalary());
    }
}

这样，您就可以通过具体的EmployeeFactory实现类创建不同职务的员工对象，并使用它们的calculateSalary()方法来计算薪资。