时间戳

首页 > 解决方案 > 为不同类型的员工实施不同的谓词

java - 为不同类型的员工实施不同的谓词

问题描述

我是使用谓词的新手，不确定我是否正确理解它。我有一个抽象employee类，其中小时和薪水员工是分别创建的。我的问题取决于我的EmployeePredicate.java班级，我不确定如何检查它是否是小时工并返回真假。

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

所有员工，仅限小时工、仅限薪水和仅限全职员工。

到目前为止，我只是想让“仅每小时”谓词首先正常工作，然后我想我可以弄清楚其余的。我不确定在“p”后面放什么来检查它是哪种类型的员工。我目前拥有的是：

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

我也有这个声明double avgSalary = calculateAveragePay(employees, null);，我不确定用什么替换null，因为它应该是一个基于我calculateAveragePay上面 main 函数的谓词。

主.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 =====");

}

}

雇员.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();

}

HourlyEmployee.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;
    }

}

SalaryEmployee.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;
    }

}

EmployeePredicate.java

package homework04;

import java.util.function.Predicate;

public class EmployeePredicate {

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

}

标签： java

解决方案

您正在寻找：

 return p -> p instanceof HourlyEmployee;

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

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

不过，如果您想继续使用 Predicate 方法的工厂类，因为您觉得它提供了更好的可读性，那么您可以这样做：

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);
}

推荐阅读