CIS 247A Week 4 iLab Composition and Class Interfaces

Just Click on Below Link To Download This Course:

http://bit.ly/2YYmhmO

CIS 247A Week 4 iLab Composition and Class Interfaces

Scenario and Summary
The objective of the lab is to modify the Employee class to demonstrate composition where a containing class (Employee) contains another class (Benefit). An employee typically has benefits, so we will make the following changes:

1. Create a Benefit class.
2. Integrate the Benefit class into the Employee class.
3. Separate the files in the project into Presentation and Logic tier folders Deliverables
   Before you post your lab in the dropbox, copy your entire program into a Notepad file and post that. I do not need you to zip the project or give me screen shots of the output.

iLAB STEPS
STEP 1: Understand the UML Diagram

1. Analyze and understand the object UML diagram, which models the structure of the program. • There are no design changes to the Presentation Tier from the previous project and InputUtilities and ApplicationsUtilities classes are used without modification (except for changing the Application Information).
2. A new class called Benefits that holds the health insurance company, life insurance amount, and vacation days. There are constant attributes defined for each of the default values and the minimum and maximum values. This composition relationhip is specified in the UML class diagram as a solid diamond connecting to the Emploee class.
3. The Benefits class shall contain properties that contain get and set methods for each of the attributes in the Benefits class, and each attribute value shall be properly validated in the properties.
4. The Employee class contains a new attribute called benefit that is of type Benefits. There will be a property in the Employee class that can set and get the benefit attribute.
5. Each constructor of Employee class will need to instansiate the benefit attribute.

STEP 2: Create the Project
You will want to use the Week 3 project as the starting point for the lab. To do this, you will want to create a new project by following these steps:

1. Create a new project named “CIS247_WK4_Lab_LASTNAME”. An empty project will then be created.
2. Delete the default Program.cs file that is created.
3. Now that we are beginning to add more classes to our projects the Solution Explorer can become difficult to organize so you will create folders to hold the Presentation Tier and Logic Tier Files in order to organize the project. One thing to remember, even though we only have a few files in our project, a professional program will have 100′s if not 1000′s of files in a project, so you will want to get practice in organizing your project files in a logical folder heirarchy and we will use the Tiered Architecture structure shown in the UML Class diagram for the folder structure.

You will find that creating folders within MS Visual Studio is very similiar to creating folders in Windows Explorer. Follow these directions to create the folders:

1. Select the project and then right click
2. Select Add
3. Select New Folder
4. Enter the name of the folder
5. Add the following three folders to your project (1) Presentation Tier, (2) Logic Tier, and (3) Utilities.
6. You are going to add the files from the previous week lab to the project just as you did before, but now you add the existing files to the corresponding folder
7. Select the Logic Tier folder, right click and select Add then Existing Item, navigate to your previous week‟s project and select the InputUtitilies.cs and Program.cs files and click add. These two files will then be added to the Presentation. [Hint: you can also drag and drop the files directly from Windows Explorer directly into the corresponding folder in your project!]
8. Add the previous week‟s Employee.cs file to the Logic Tier folder.
9. Add the ApplicationUtilities.cs file to the Utilities folder.
10. Your solution explorer should look similiar to the following (note: you can rename any folder by selecting the folder, right click, and then Rename just like you do in Windows).
11. The namespaces for the classes should all be “Employee”, but you should verify that the namespaces for all the classes are the same.
12. Update the program information in the ApplicationUtilities.DisplayApplicationInformation method to reflect your name, current lab, and program description.
13. Build and execute the project.

STEP 3: Create the Benefits Class
Using the Benefit class diagram as a guide, build the Benefit class.

1. Create a property for each of the listed private attributes and validate the provided value using the following rules:
1. If the insurance company provided is empty or null then set the healthInsuranceCompany to DEFAULT_HEALTH_INSURANCE
2. If the provided life insurance value is between the MIN_LIFE_INSURANCE and MAX_LIFE_INSURANCE (inclusive) then set lifeInsuranceAmount to the provided value; if the provided value is less than MIN_LIFE_INSURANCE set the lifeInsuranceAmount to MIN_LIFE_INSURANCE; else if provided value is greater than MAX_LIFE_INSURANCE; set thelifeInsuranceAmount to MAX_LIFE_INSURANCE.
3. If the provided vacation days value is between the MIN_VACATION and MAX_VACATION (inclusive) the set the vacationDays to the provided value; if the provided value is less than MIN_VACATION set the vacationDays to MIN_VACATION; else if provided value is greater than MAX_VACATION set the vacationDays value to MAX_VACATION.
2. In the parameterized constructor, set the attributes so that the properties are used, which ensures that attributes are validated prior to be set.
3. Create an overridden ToString method that collects and formats the attribute information for
   the benefit object. Ensure to display life insurance amount in currency format.

STEP 4: Modify the Employee Class
Using the Employee class diagram as a guide, modify the Employee class

1. Add a private attribute called “benefit” to the employee class of type Benefits
2. Create a public Benefit property that returns the benefit attribute. In the set method of the property, if the provided value is null then re-instantiate the benefit variable; otherwise, set the provided value to the benefit variable. [Hint: to check if a object is null use the syntax “if (object != null)”]
3. In the default constructor, instantiate the benefit variable using the Benefits default constructor
4. In the parameterized constructor, add a benefit argument of type Benefits, and then set the value of this parameter to the Benefit property (using the property will ensure that any null benefit object is correctly instansiated.)
5. Modify the ToString method to the Employee class, by adding a call to the Benefits ToString methods at the end of the Employee ToString method.

STEP 5: Modify the Main Method
In the previous labs you learned how to access an object/class methods and properties using the DOT notation. For example, to access the calculatePay method of an employee object you used a statement similiar to:

1 2 3 4 5 6 7 8

employee1.CalculateWeeklyPay(modifiedSalary) Notice that the Employee class now has a public Benefit object inside it. This means that you can access the set methods of the Benefit object using the transitive notation: containingObject.containedObject.methodName() or containingObject.containedObject.PropertyName That is to access the members of contained object, you start at the containing object, then “transit” to the contained object, then to the contained objects members. As an example, to set the life insurance amount of an employee object, the statement would look something like: employee1.Benefit.LifeInsuranceAmount = 100000; Notice, the containing object is “employee1′′, the contained object is “Benefit”, and the property of Benefit we are accessing is LifeInsuranceAmount.

The code in the previous week‟s project performed the following operations

1. Display the program information.
2. Create an Employee object using the default constructor.
3. Prompt for and then set the first name, last name, gender, dependents, and annual salary. Remember to use the appropriate methods in the InputUtilties class to prompt for and retreive the values.
4. Display the employee information.
5. After the first employee information is provided, display the number of employees created.
6. Prompt the user to provide an updated annual salary for employee1, retrieve the value and invoke the overloaded CalculateWeeklyPay, and then display only the updated weekly pay.
7. Create a second Employee object using the multi-argument constructor using data of your choosing that is of the correct type for each input.
8. Display the Employee information for the second employee object.
9. Create a third Employee object using the parameterized constructor setting each of the attributes with the following values: “Sue”, “Smith”, „F‟, 15, 500000.0
10. Display the employee information for the third Employee object and verify that the dependents and annual salary values have been set to the maximum values by the properties. If not, make sure you change the parameterized constructor to use the properties to set the attributes.
11. Display the number of employees created.
12. Terminate the application

Once your code is working and implements the previous week‟s operations, modify the code to implement the following new requirements (updated code should implement all previous requirements except as noted below).

1. After you collect the information for the first employee object, prompt for and collect the Health Insurance Company, the LifeInsuranceAmount, and the number of vacation days.
2. Display the updated employee 1 information
3. Display the number of employees created.
4. Create a new, standalone benefits object using the multi-argument constructor using data of your choosing that is of the correct type for each input.
5. Modify the second employee object instantiation and add the newly created benefit object to the constructor call.
6. Display the updated employee 2 information
7. Display the number of employees created.
8. Create a new, standalone benefits object using the multi-argument constructor using the following invalid data “” (empty string), 10000000, -10
9. Modify the third employee object instantiation and add the newly created benefit object to the constructor call.
10. Display the updated employee 3 information and verify that the default values for the benefit object have been correctly set.
11. Display the number of employees created.

STEP 6: Compile and Test
When done, compile and execute your code. Debug errors until your code is error-free. Check your output to ensure that you have the desired output, modify your code as necessary, and rebuild. The following shows some sample output, but your output may look different.

 

Download Now