Reference no: EM13382114

Algorithm Design and Development - The graduate designs and develops algorithms for problem solving and implements those algorithms using appropriate program code. Competency Use of Data Structures - The graduate develops working programs that use appropriate data structures for problem solving. Competency

Modeling Systems Using Unified Modeling Language (UML) - The graduate develops and interprets Unified Modeling Language (UML) diagrams which model object-oriented designs. Competency Object-Oriented Concepts - The graduate applies object-oriented concepts, develops object-oriented designs, and uses object-oriented programming techniques. Competency

Software Testing and Troubleshooting - The graduate applies software testing and troubleshooting strategies to determine programming errors and recommend appropriate solutions.

Introduction: As a competent programmer, your ability to design and develop algorithms, your proficient use of data structures, and your ability to use the Unified Modeling Language (UML 2.0) to communicate and develop object-oriented designs will help you design and develop applications to meet customer requirements.

A solid understanding of object-oriented concepts will help you develop applications that are maintainable and extensible. Strong competence in software testing and troubleshooting will allow you to validate and verify your applications to ensure you are delivering a quality product that meets all requirements. You will need to develop a Java application to meet the requirements of this assignment. It is recommended that you use NetBeans as your integrated development environment. Note: You will submit all .java and .class files in one zipped folder.

If you developed this application using NetBeans, it is recommended that you zip and submit the entire NetBeans project folder. All documents such as the SDS and Test Plan will be submitted in MS Word 2003 or 2007 format. Your client has hired you to design a client/server application with a MySQL backend database.

The database will hold employee records. Each record will contain the employee's first name, last name, social security number, and department, along with other information specific to an employee type. There are four types of employees: director, manager, salaried, and hourly.

Since your client has planned on adopting this application long term, the application must be easy to maintain and easy to extend. For these reasons, your application must be developed using an object-oriented design. Your application should provide functionality to update, add, and delete employees from the database.

The application should also query the database to print out a selected employee's information or all employees' information. The functional and design requirements of the system are outlined in part A of the task. Task: Note: For this task, you will submit a working employee record managing system application, a Software Requirement Specification (SRS) document, a Software Design Specification (SDS) document, and a test plan with test cases.

A. Build an employee record management system application by doing the following: 1. Create an Employee inheritance hierarchy. This should include the following requirements: . Create the Employee class. Employee will be the super class and will be an abstract class. At least one method on Employee will be abstract. .

Employee class holds attributes first name, last name, social security, and department. All attributes will be inherited by the subclasses.

. Create appropriate overloaded constructors for super class, Employee.

. Employee has an abstract method, calculateWeeklyPay(), which will be implemented in the subclasses Director, Manager, Salaried, and Hourly, making use of the polymorphism principle.

. Create the subclasses Director, Manager, Salaried, and Hourly, which inherit from the Employee class.

Each subclass will encapsulate a specialization of Employee.

. Create an abstract method, update(). When this method is called, the database entry for the employee is updated.

. Create an abstract method, add() method. When this method is called, the database entry for the employee is created.

. Create an abstract method, delete(). When this method is called, the database entry for the employee is deleted.

. Create an abstract method, query(). When this method is called, a query is made to the database to retrieve the information and then it is printed to the screen. 2. Create subclasses. This should include the following requirements:

. Create the subclass Salaried, which inherits from Employee. Salaried has additional attributes "salary" and "overtimeHours", which is the number of hours above 40 worked for a given week.

. Create subclass Hourly, which inherits from Employee. Hourly has additional attributes, "hourlyWage" and "numberHours". . Create the subclass Manager, which inherits from Employee. Manager Employees have attributes "salary" and "department", which is the name of department they manage.

. Create the subclass Director, which inherits from Employee. Director Employees have attributes "salary", "organization", and "bonus." . Incorporate the technique of information hiding by making appropriate attributes private and creating getters and setters to access and modify each private attribute.

. Create overloaded constructors for each Employee type. The super class's constructor should be used by the subclass's constructors to set those attributes found in the super class.

Create enough constructors for each class to initialize the instance variables (attributes) of an object, either by initial values passed into the constructor or default values used if none passed in. All values passed in should be verified for validity. 3. Implement methods. This should include the following requirements:

. Using polymorphism, implement calcuate WeeklyPay() method as follows: - Salaried: Weekly pay = annualPay /52 + overtimeHours × (annualPay/52)/40; - Hourly: Weekly pay = numberHours × hourlyWages; - Manager: Weekly pay = annualPay/52; - Director: Weekly pay = (annualPay/52) + bonus;

. Employee objects should know how to display the information. Override the toString() method on each subclass. Use inheritance to display attributes provided by super class by calling super.toString() method.

. For each subclass, implement method query(). When this method is called, a query is made to the database to retrieve the information and then the information is printed to the screen.

If appropriate, use toString() within the print() method.

. For each subclass, implement method update(). When this method is called, the database entry for the employee is updated.

. For each subclass, implement method add() method. When this method is called, the database entry for the employee is created.

. For each subclass, implement method delete().

When this method is called, the database entry for the employee is deleted. 4. Create Department class. This should include the following requirements:

. Each employee has a department. Each department has several employees.

. Departments have a name and manager.

. Create appropriate constructor(s) for Department class.

. Override toString() method to print out a department's information (name and manager, along with all employees assigned).

. Create method listEmployees(), which lists employees for the department.

. Create method addEmployee(), which inserts an employee into the list of employees for the department. Associated employee should be updated when added to a department's list.

. Department information is not stored in the database at this time. This will be developed for the customer at a later date. 5. Create an application driver. This should include the following requirements:

. Create an application that allows the user to add, update, delete, and query any employee type.

. Application should allow user to create a department and add employees.

. Application should allow user to list all employees assigned for a given department.

. Application should allow user to assign a manager to a department.

B. Create a Software Requirement Specification (SRS) document that captures all functional requirements for this application.

Use the task description in part A to elicit the requirements.

The document should include the following sections:

. Title Page

. Introduction: Overall and brief description of the application

. Data Requirements: Brief overview of data requirements from the user's point of view. Describe where the data will be stored. An overview (suggested length of 1-2 paragraphs) is fine but should be included because this will have a database backend.

. Interfaces: Overview of interfaces required. This will likely include a brief description of the interface required between the application and the database.

. Functional Requirements:

1. Document the functional requirements and provide use case diagrams for each. For each functional requirement, provide the following information:

. Requirement number and title

. Description of the functionality

. Input

. Results of processing or output

. Error handling or recovering requirements outlined

. UML 2.0 use case diagrams (It is very important that your UML use case diagrams are complete and that proper UML 2.0 Modeling notation is used.)

Note: For an example, see the attached "Software Requirements Specification Example."

Note: It will be helpful to complete the test plan while completing the SRS since the test plan will be used to test all functional requirements.

C. Create a Software Design Specification (SDS) document that includes UML class and sequence diagrams. (It is very important that your UML diagrams are complete and that proper UML 2.0 Modeling notation is used.Your design must be an object-oriented design.) Your SDS needs to include at least the following sections: . Title Page . Table of Contents or Outline . Overview or Introduction: Discuss an overview of the system under design, assumptions, dependencies, and constraints. .

Design: UML Diagrams and description of the system architecture. Provide an overview of the subsystems and components.