Course Project - DeVry University College Of Engineer 859011

Course Project DeVry Universitycollege Of Engineering And Informatio

This course project involves developing an object-oriented Payroll System with a graphical user interface (GUI) for a small business. The system must be capable of managing employee information, including benefits, and support multiple employee types through inheritance. Key features include creating and updating employee records, storing data persistently, and calculating and printing paychecks, with an emphasis on object-oriented design principles such as composition and inheritance.

Paper For Above instruction

Introduction

The development of a comprehensive payroll system is a critical component for small businesses aiming to efficiently manage employee records and automate compensation processing. Employing object-oriented programming (OOP) techniques such as inheritance and composition enhances system flexibility, maintainability, and scalability. This paper details the design and implementation of such a system, illustrating how composition and inheritance facilitate effective data management and operational functionality within a GUI environment.

Design Principles and System Architecture

The payroll system is structured around core OOP principles. The primary class, Employee, serves as the parent class containing essential attributes such as FirstName, LastName, SSN, HireDate, and methods like CalculatePay() and ToString(). To extend its functionality, two subclasses inherit from Employee: Salary and Hourly, each adding specific attributes such as annualSalary for Salary and hourlyRate, hoursWorked for Hourly. This inheritance structure allows differentiated pay calculations and simplifies maintenance by centralizing shared attributes in the parent class.

To manage additional employee benefits, a Benefits class is created, encapsulating details like health insurance, life insurance, and vacation days. The Employee class incorporates composition by containing a Benefits object, illustrating the "has-a" relationship and enabling detailed benefit tracking for each employee. This design offers the flexibility to modify benefit details independently without altering core employee data.

Implementation of Composition and Inheritance

Incorporating composition, the Employee class includes a Benefits object, which encapsulates all benefits-related information. Operations such as adding a new employee involve creating a Benefits object with specific data and associating it with an Employee instance. Data persistence utilizes file handling to write and read employee data, including benefits, in CSV format, with updates to support reading benefits details and distinguishing employee types.

Inheritance adopts a hierarchical approach, where Salary and Hourly classes extend Employee, overriding methods like CalculatePay() to implement specific pay logic. Using method overriding and polymorphism, the system can process different employee types seamlessly, especially when displaying employee info or printing paychecks.

Graphical User Interface Design

The GUI facilitates user interaction for managing employee records. Input forms are adapted to include benefits and employee type selection through radio buttons. Users can add, update, or remove employees via button controls. Listboxes display employee summaries, and double-click events enable record editing—populating the form with selected employee details for modifications. The interface also includes a print paycheck button that shows employee details and calculated pay in MessageBoxes, offering an intuitive user experience.

Data Storage and Serialization

Persistent storage involves serializing employee objects to a binary file using the BinaryFormatter class, addressing the need for saving complex object graphs. When saving, the list of employees—each containing benefits and subclass-specific attributes—is serialized into a binary file. Loading reconstructs the objects by deserializing the file, restoring the full object hierarchy with benefits included. This approach ensures data integrity and simplifies file management.

Sample Code Snippets

Sample code for the Employee class with embedded Benefits object:

public class Employee


{


public string FirstName { get; set; }


public string LastName { get; set; }


public string SSN { get; set; }


public DateTime HireDate { get; set; }


public Benefits BenefitsPackage { get; set; }


public Employee(string fName, string lName, string ssn, DateTime hireDate, Benefits benefits)


{


FirstName = fName;


LastName = lName;


SSN = ssn;


HireDate = hireDate;


BenefitsPackage = benefits;


}


public virtual double CalculatePay()


{


// Placeholder for pay calculation


return 0;


}


public override string ToString()


{


return $"{FirstName} {LastName}";


}


}

Benefits class definition:

public class Benefits


{


public string HealthInsurance { get; set; }


public double LifeInsurance { get; set; }


public int Vacation { get; set; }


public Benefits(string healthIns, double lifeIns, int vacation)


{


HealthInsurance = healthIns;


LifeInsurance = lifeIns;


Vacation = vacation;


}


public override string ToString()


{


return $"Health: {HealthInsurance}, Life: {LifeInsurance}, Vacation: {Vacation} days";


}


}

Conclusion

Applying object-oriented principles like inheritance and composition in developing a payroll system significantly enhances its agility and ease of maintenance. By structuring employee data to include benefits as a composed object and creating subclasses for employee types, the system becomes flexible enough to accommodate future requirements such as additional employee categories or benefits. The GUI, combined with robust data storage strategies, offers an accessible and reliable platform for payroll management, aligning technical design with business needs.

References

  • Heuser, C. (2012). Object-oriented Analysis and Design with Applications. Pearson Education.
  • Larman, C. (2004). Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design. Pearson Education.
  • Masoud, M. (2014). Object-Oriented Programming with C#. McGraw-Hill Education.
  • Sommers, N. (2010). Fundamentals of Object-Oriented Design in Java. Addison-Wesley.
  • Grasser, C. (2013). Professional C# and .NET. John Wiley & Sons.
  • Zhang, R., & Felder, R. (2007). A cognitive and affective model of engineering students’ motivation and their achievement in project-based learning. Journal of Engineering Education, 336-347.
  • McConnell, S. (2004). Code Complete: A Practical Handbook of Software Construction. Microsoft Press.
  • Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
  • Schmidt, D. (1998). The use of design patterns for component-based software development. IEEE Software, 27-36.
  • Stroustrup, B. (2013). The C++ Programming Language. Addison-Wesley.

Related Assignments