public static void main(String[] args) { String csvFile = "C:/devel/EmployeeList.csv"; List<Employee> jobs = new ArrayList<Employee>(); ReadEmployeeList read = new ReadEmployeeList(); read.readCSV(csvFile, jobs); try { for (Employee job : jobs) { String fullName = job.getFirstName() + " " + job.getLastName(); String payperiod = read.calcPayPeriod(job.getMonth()); int grossIncome = read.calcGrossIncome(job.getAnnualSalary()); int netIncome = (int) (read.calcGrossIncome(job.getAnnualSalary()) - read.calcIncomeTax(job.getAnnualSalary())); int incomeTaxAmount = (int) read.calcIncomeTax(job.getAnnualSalary()); System.out.println("Payslip information for Employee is:"); System.out.println( fullName + "," + payperiod + "," + grossIncome + "," + incomeTaxAmount + "," + netIncome + "," + read.calcSuper(grossIncome, job.getSuperRate())); } } catch (Exception e) { e.printStackTrace(); } }
/** * This is a truly horrible way to make decisions. Very rigid and fragile! * * @param e - an employee object (not truly polymorphic!) employeeType - a String identifying the * employee type. A constant (see above) should be used for this, but can you guarantee it * will be? Are there other options? Hint: enum * @return the annual compensation for supported employee types */ public double getAnnualCompensationForEmployee(Employee e, String employeeType) { double annualCompensation = 0; // One example of using fragile if logic to determine employee type. // If only we could use polymorphism instead! if (employeeType.equals(HOURLY_TYPE)) { annualCompensation = e.getAnnualWages(); } else if (employeeType.equals(SALARIED_TYPE)) { annualCompensation = e.getAnnualSalary(); } else { JOptionPane.showMessageDialog(null, ERROR_MSG, ERROR_TITLE, JOptionPane.ERROR_MESSAGE); } return annualCompensation; }
SalarySlip generateFor(Employee employee) { AnnualAmount annualSalary = new AnnualAmount(employee.getAnnualSalary()); MonthlyAmount nationalInsuranceContribution = nationalInsuranceCalculation.execute(annualSalary); MonthlyAmount grossSalary = grossSalaryCalculation.execute(annualSalary); MonthlyAmount taxFreeAllowance = taxFreeAllowanceCalculation.execute(annualSalary); MonthlyAmount taxableIncome = taxableIncomeCalculation.execute(annualSalary); MonthlyAmount taxablePayable = taxablePayableCalculation.execute(annualSalary); return aSalarySlip() .withEmployeeID(employee.getEmployeeID()) .withName(employee.getName()) .withGrossMonthlySalary(grossSalary.asFormattedAmount()) .withNationalInsuranceMonthlyContribution(nationalInsuranceContribution.asFormattedAmount()) .withTaxFreeMonthlyAllowance(taxFreeAllowance.asFormattedAmount()) .withTaxableMonthlyIncome(taxableIncome.asFormattedAmount()) .withTaxablePayable(taxablePayable.asFormattedAmount()) .build(); }
/** * This is another truly horrible way to make decisions. Very rigid and fragile! * * @param e - an employee object (not truly polymorphic!) * @return the annual compensation for supported employee types */ public double getAnnualCompensationForEmployee(Employee e) { double annualCompensation = 0; // One example of using fragile if logic to determine employee type. // If only we could use polymorphism! // NOTE: you don't need both versions (the one above and this one). // Find a single, better way, using DIP principles. if (e instanceof HourlyEmployee) { annualCompensation = e.getAnnualWages(); } else if (e instanceof SalariedEmployee) { annualCompensation = e.getAnnualSalary(); } else { JOptionPane.showMessageDialog(null, ERROR_MSG, ERROR_TITLE, JOptionPane.ERROR_MESSAGE); } return annualCompensation; }