为不同类型的员工实现不同的谓词

Question

我是使用谓词的新手，不确定我是否正确理解了它。我有一个抽象的员工类，其中每小时和薪水员工是分开创建的。我的问题依赖于我的员工redicate.java类，我不确定如何检查它是否是每小时员工并返回真或假。

我需要为以下所有条件创建不同的谓词：

所有员工，仅每小时一次，仅限工资和全职。

到目前为止，我只是想先让“仅每小时”谓词正常工作，然后再找出剩下的谓词。我不确定在“p”后面加什么来检查它是哪种类型的员工。我目前拥有的是：

public static Predicate<Employee> isHourlyEmployee() {
        return p -> p.
    }

我还有一条语句，即double avgSalary=calculateAveragePay（employees，null）和我不确定用什么来替换null，因为它应该是基于上面main中我的calculateAveragePay函数的谓词。

主要的Java语言

package homework04;

import java.util.function.Predicate;

public class Main {

public static double calculateAveragePay(Employee[] employees, Predicate<Employee> pred) {
    double sum = 0.0;
    int count = 0;
    for(Employee e : employees) {
        if(!pred.test(e)) {             
            continue;
        }
        sum += e.calculatePay();
        count++;
    }
    return sum / count;
}

public static void main(String[] args) {
    //The list of employees to calculate.
    Employee[] employees = {
        new HourlyEmployee("John Smith", 80, 18.00),
        new HourlyEmployee("Jane Doe", 77, 20.00),
        new SalaryEmployee("Bob Miller", 85, 40000.00),
        new HourlyEmployee("Alice Davis", 40, 12.50),
        new SalaryEmployee("Frank Frink", 70, 35000.00),
        new HourlyEmployee("Chris Williams", 95, 25.00)
    };

    //The average pay for both types of employee.
    double avgSalary = calculateAveragePay(employees, null);
    double avgHourly = calculateAveragePay(employees, null);

    //The bonus to be added to employee pay.
    //double bonus = Math.abs(avgSalary - avgHourly);

    //Print the average pay
    System.out.println("===== Average Pay =====");

}

}

Employee.java

package homework04;

import java.util.function.Predicate;

abstract class Employee {

    private String name;
    private int hoursWorked;

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

    public int getHoursWorked() {
        return hoursWorked;
    }

    public String getName() {
        return name;
    }

    public abstract double calculatePay();

}

小时mployee.java

package homework04;

public class HourlyEmployee extends Employee {

    private double hourlyPay;

    public HourlyEmployee(String name, int hoursWorked, double hourlyPay) {
        super(name, hoursWorked);
        this.hourlyPay = hourlyPay;
    }

    @Override
    public double calculatePay() {
        return getHoursWorked() * hourlyPay;
    }

}

工薪员工。Java语言

package homework04;

public class SalaryEmployee extends Employee {

    private static final int NUM_PAY_PERIODS = 26;

    private double salary;

    public SalaryEmployee(String name, int hoursWorked, double salary) {
        super(name, hoursWorked);
        this.salary = salary;
    }

    @Override
    public double calculatePay() {
        return salary / NUM_PAY_PERIODS;
    }

}

员工预测。Java语言

package homework04;

import java.util.function.Predicate;

public class EmployeePredicate {

    public static Predicate<Employee> isHourlyEmployee() {
        return p -> p.
    }

}

Answer 1

您正在寻找：

 return p -> p instanceof HourlyEmployee;

但我不建议在工厂类中为每个类型的员工创建谓词，而是在调用calculateAveragePay方法时传入行为，即。

double avgSalary = calculateAveragePay(employees, p -> p instanceof SalaryEmployee);
double avgHourly = calculateAveragePay(employees, p -> p instanceof HourlyEmployee);

然而，如果您想继续使用谓词方法的工厂类，因为您觉得它提供了更好的可读性，那么您可以执行以下操作：

public class EmployeePredicate {
    public static Predicate<Employee> isHourlyEmployee() {
        return p -> p instanceof HourlyEmployee;
    }
}

然后该方法调用calculateAveragePay成为：

double avgSalary = calculateAveragePay(employees, EmployeePredicate.isSalaryEmployee()); // create the isSalaryEmployee method
double avgHourly = calculateAveragePay(employees, EmployeePredicate.isHourlyEmployee());

另一方面，您可以使用流API执行calculateAveragePay，使其更具可读性。

public static double calculateAveragePay(Employee[] employees, Predicate<Employee> pred) {
    return Arrays.stream(employees)
                 .filter(pred)
                 .mapToDouble(e -> e.calculatePay()) 
                 .average().orElse(0);
}