Employee record management system

IN PROGRESS
Project Budget (USD)
$120

Project Description:
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.

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.

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 calcuateWeeklyPay() 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.

Skills required:
Java
Additional Files: employee record management system.pdf
Project offered by:
Verified