1.1 Introduction
Note: This assignment is a bit different from the previous homework, and asks you topractice with JUnit 5. Ensure you read the instructions carefully and submit what isrequired.Volunteer work is admirable, but many people enjoy being paidfor the work they do for an employer. Depending on the type ofemployee, said employee may be paid by the hour, a fixed rate(salaried), or be on some bonus/commission payment scale.For this assignment, I provide an interface called IEmployee. Donot modify, extend, or in any way alter this interface - other thanto embellish the JavaDoc if required to pass the checkStyle tests.You will create two concrete classes that implement thisinterface: HourlyEmployee and SalariedEmployee. You willalso provide a test class that will test your code. This class mustbe named IEmployeeTest.
1.2 What to do
EMPLOYEES
All of your assets for this assignment must be placed in apackage named student.We're dealing with money for this example (US dollars). Considerinvestigating the BigDecimal and DecimalFormat classes tohelp you deal with fractional items. The rounding mode youshould use for this assignment is RoundingMode.HALF_UP (inother words, round up the fractional parts beyond the second
decimal place)You must implement the provided IEmployee interface.
package student;
/**
* An interface representing the concept of Employees. */
public interface IEmployee {
// NOTES (you may remove these notes after you understand the assignment if they
cause checkStyle issues):
// The max HOURLY base salary is $50.00 (per hour).
// The max Salaried base salary is $1 million per year.
// HourlyEmployees earn 1.5x base salary for any time worked > 40 hours in a
period.
// SalariedEmployees are paid monthly. For one pay period their salary should be
baseSalary/12
/**
* @return the employee's pay for the given period.
* Hourly employees are paid weekly based on the number of hours worked.
* Salaried employees are paid monthly, with a given paycheck of 1/12 their yearly
salary
*
*/
double getPayForThisPeriod();
/**
* @return the employee's base salary.
* Hourly employees answer their hourly rate.
* Salaried employees answer their yearly salary
*/
double getBaseSalary();
/**
* @param raisePercent raises the employee's base salary from 0% (minimum) to 10%
maximum.
* The parameter is a value between 0.0 and 10.0. This method converts that value
to a decimal value
* 0 - 0.10 when required for calculations.
*/
void giveRaiseByPercent(double raisePercent);
/**
* @return Returns employee ID.
*/
String getID();
/**
* @return Returns employee name.
*/
String getName();
}
Create two concrete classes (remember, both of these classes
should be created in the student package as
well): HourlyEmployee and SalariedEmployee.Your HourlyEmployee class must include a constructor that
follows this signature:
public HourlyEmployee(String name, String id, double hourlySalary, double normalHours)
HourlyEmployees also have an additional method NOT listed
in the shared interface:
/**
* This method allows HourlyEmployees to supersede the number of hours worked for the
week.
*/
public void setSpecialHours(double hours)
HourlyEmployees have a name, ID, and an hourly salary. Whencreated, these employees specify the "normal" number of hoursthey typically work each week. The weekly hours cannot be lessthan zero (0) and cannot be more than 80.0. If this constraint isnot met, your HourlyEmployee should throw
an IllegalArgumentException.An HourlyEmployee also gets paid "time and one-half" (1.5x)for any hours worked over 40.0hours. HourlyEmployees override their "normal" hours bycalling the setSpecialHours() method. By calling thismethod, an HourlyEmployee temporarily sets their "hours forthe week" to the value passed to this method (same constraintsas described above - 代 写SalariedEmployee the value must be between 0 and 80.0hours).This "override" does not persist, so after the method getPayForThisPeriod() is called, the employee's "normal hours" are re-activated for any subsequent payments.Your SalariedEmployee class must include a constructor thatfollows this signature:public SalariedEmployee(String name, String id, double yearlySalary)For both types of employees, if their constructors are given a
salary less than zero (0) or greater than the maximum allowablesalary (based on the type of employee), throwan IllegalArgumentException.For both types of employees, if their constructors are given null
or an empty String ("") for either the name or ID, throw
an IllegalArgumentException.When the giveRaiseByPercent() method is called for either
type of employee, the base salary for the employee object shouldbe increased by the percentage specified by the parameterpassed in. Allowable values for the raisepercentage is anynumber between 0 and 10.0. Any value outside of this rangeshould raise an IllegalArgumentException.
Note: The maximum salary constraint must be maintained during
this operation. Therefore, if a "raise" request would take the employee's salary above the maximum, this request should be
ignored. Do NOT throw an exception. Instead, leave the employee's salary unchanged. void giveRaiseByPercent(double raisePercent);
IEmployeeTest
Design your IEmployeeTest class to be a JUnit5 test class.
Here is some starter code - you may opt to use this if you wish:
// This is a placeholder for student code.
package student;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
public class IEmployeeTest {
HourlyEmployee snoopyHours = new HourlyEmployee("Snoopy", "111-CHLY-BRWN", 17.50,
20);
SalariedEmployee lucy = new SalariedEmployee("Lucy", "222-22-2222", 70000.00);
IEmployee woodStock = new SalariedEmployee("Woodstock", "33-CHIRP", 180000.50);;
// sample test provided to students
@Test
public void testGetErrorWhenCreatingEmployee() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { IEmployee e = new HourlyEmployee(null, null, 15.51, 30);
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
IEmployee e = new HourlyEmployee("Part-timer", "PT-TIME", -1, 30);
});
}
@Test
public void testGetHappyDayEmployee() {
}
@Test
public void testGetPayForThisPeriod() {
}
@Test
public void testGetBaseSalary() {
}
@Test
public void testGetID() {
}
@Test
public void testGetName() {
}
}
Note: Unlike our the assignments we'll be doing for the rest ofthe semester, I'm asking you to place ALL of your assets in thesame package (the one called student).You need to have the six methods prefixed by "testGet" methodsabove. The automated grader we're using for this assignment isdifferent than the one used on homework 1 & 2, so your testmethods need to follow this form. Spelling and case-sensitivity is
important here so I suggest you copy the template given above.You should write more tests than what I've given you here.
However, at the very least, be sure you develop the six "startertests" I've given you.Notes:
For this assignment, we'll be running your JUnit tests againstyour code, our exemplar code (what we think is correct) and asample of code in which we have purposely injected some bugs/defects. Of course, your tests should validate your code (and
your solution should pass your tests). Additionally, your JUnittests will be evaluated on how well it exercises our code (anddetects the errors we have in the "buggy" solution). We'll also berunning a test code coverage analyzer to see how much of yoursolution code you test with your JUnit. Part of your grade will becalculated based on code coverage (of your own code, not ofours).You should provide a suitable .toString() method for
As part of your submission, rememberCreate a UML class diagram that describes your solutionand include it with your submission
标签：salary,code,HourlyEmployee,public,SalariedEmployee,employee,设计模式,your From： https://www.cnblogs.com/comp9313/p/18450893