代写data程序、代做Java语言编程

日期：2024-10-09 09:42

1.1  Introduction

Volunteer work is admirable, but many people enjoy being paid

for the work they do for an employer. Depending on the type of

employee, said employee may be paid by the hour, a fifixed rate

(salaried), or be on some bonus/commission payment scale.

For this assignment, I provide an interface called IEmployee. Do

not modify, extend, or in any way alter this interface - other than

to embellish the JavaDoc if required to pass the checkStyle tests.

You will create two concrete classes that implement this

interface: HourlyEmployee and SalariedEmployee. You will

also provide a test class that will test your code. This class must

be named IEmployeeTest.

1.2  What to do

EMPLOYEES

All of your assets for this assignment must be placed in a

package named student.

We're dealing with money for this example (US dollars). Consider

investigating the BigDecimal and DecimalFormat classes to

help you deal with fractional items. The rounding mode you

should use for this assignment is RoundingMode.HALF_UP (in

other 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.

Note: This assignment is a bit difffferent from the previous homework, and asks you to

practice with JUnit 5. Ensure you read the instructions carefully and submit what is

required. */

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. When

created, these employees specify the "normal" number of hours

they typically work each week. The weekly hours cannot be  less

than zero (0) and cannot be more than 80.0. If this constraint is

not met, your HourlyEmployee should throw

an IllegalArgumentException.

An HourlyEmployee also gets paid "time and one-half" (1.5x)

for any hours worked over 40.0

hours. HourlyEmployees override their "normal" hours by

calling the setSpecialHours() method. By calling this

method, an HourlyEmployee temporarily sets their "hours for

the week" to the value passed to this method (same constraints

as described above - the value must be between 0 and 80.0

hours).

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 that

follows 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 allowable

salary (based on the type of employee), throw

an 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 should

be increased by the percentage specifified by the parameter

passed in. Allowable values for the raise percentage is any

number between 0 and 10.0. Any value outside of this range

should 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 of

the semester, I'm asking you to place ALL of your assets in the

same package (the one called student).

You need to have the six methods prefifixed by "testGet" methods

above. The automated grader we're using for this assignment is

difffferent than the one used on homework 1 & 2, so your test

methods 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 "starter

tests" I've given you.

Notes:

For this assignment, we'll be running your JUnit tests against

your code, our exemplar code (what we think is correct) and a

sample 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 JUnit

tests will be evaluated on how well it exercises our code (and

detects the errors we have in the "buggy" solution). We'll also be

running a test code coverage analyzer to see how much of your

solution code you test with your JUnit. Part of your grade will be

calculated based on code coverage (of your own code, not of

ours).

You should provide a suitable .toString() method for

Employees:

Name: Clark Kent

ID: SUPS-111

Base Salary: $416.50

As part of your submission, remember:

• Create a UML class diagram that describes your solution

and include it with your submission