Objectives: Use Inheritance To Create Base And Child Classes ✓ Solved

Objectivesuse Inheritance To Create Base And Child Classesutilize Mul

Use inheritance to create base and child classes. Utilize multiple classes in the same program. Perform standard input validation. Implement a solution that uses polymorphism.

Sample Paper For Above instruction

Introduction

This paper presents a comprehensive design and implementation for an inventory management system tailored for a small electronics company. The system emphasizes object-oriented programming principles such as inheritance, encapsulation, and polymorphism to create a flexible, secure, and maintainable application. Key features include role-based access control (RBAC), dynamic menu loading, user and inventory management, and robust input validation.

System Overview and Objectives

The primary goal of the system is to facilitate secure and efficient management of product inventory while accommodating different user roles—managers and employees. Managers have full access to all system functionalities, whereas employees have limited permissions. The system dynamically loads menus from external files, enabling easy updates and reordering without modifying core code. In addition, the system ensures data integrity through input validation and secure authentication procedures.

Design Principles and Object-Oriented Concepts

Inheritance and Class Hierarchies

The system employs inheritance to create a structured class hierarchy. A base class User encapsulates common attributes such as first name, last name, username, and password. Derived classes Manager and Employee inherit from User and extend functionality, especially regarding access permissions.

Similarly, a generic MenuItem class serves as a parent for various command classes like AddUserCommand, DeleteUserCommand, and others. These command classes implement specific actions, facilitating polymorphism when executing menu commands.

Polymorphism

Polymorphism allows the system to treat different command objects uniformly through a common interface. When a menu item is selected, the application invokes the execute method on the corresponding command object, regardless of its concrete class. This design simplifies adding new commands and reordering existing ones, as the main menu handling code interacts solely with the base command interface.

User Management and Authentication

User Data Storage

User information resides in a text file Users.dat with comma-separated values capturing user details and role flags. The data includes first name, last name, username, hashed password, and a boolean indicating managerial status. A hardcoded admin account (username: 'admin', password: 'admin') exists for initial setup.

Authentication Process

Upon login, the system prompts the user for credentials and verifies them against stored data. Passwords are stored as hashes for security. The authentication method utilizes input validation to prevent injection or invalid data entries. Depending on the user’s role, different menu options are presented.

Adding and Changing Users

Features include adding new users, ensuring no duplicate usernames, and changing passwords only after correct verification. These operations update the Users.dat file accordingly, maintaining data consistency and security.

Menu System and Dynamic Loading

Menu Data File

The menu content is read from MenuList.dat, which contains descriptions, restrictions, and command identifiers for menu items. The system dynamically constructs the menu based on the file, allowing reordering and updates without code changes. The 'Exit' option is always available as the last menu item.

Menu Item Commands

Each menu item maps to a class with a method to execute its associated command. Restricted items are visible only to managers, based on the boolean flag in the data file. This design employs polymorphism, where each command class implements a shared interface.

Inventory Management

Product Class and Catalog

Products are represented by a Product class containing attributes such as ID, name, cost, quantity, and margin percentage. The retail price is computed as cost plus margin, formatted appropriately for display.

The ProductCatalog manages a collection of products, providing methods to add, remove, find, update, and display products. Persistent storage is maintained via the Inventory.dat file, supporting dynamic loading and saving.

Operations and Functions

  • AddUpdateProduct: Adds a new product or updates existing product information.
  • RemoveProduct: Deletes a product by ID.
  • FindProduct: Retrieves a product based on ID.
  • PrintProductInformation: Displays detailed information for a specific product.
  • PrintInventoryList: Shows all inventory items.

Program Flow

Upon startup, the application prompts for user credentials, authenticates, and loads user roles. It then loads inventory data and constructs the dynamic menu. Users interact via menu selections, executing commands encapsulated in polymorphic classes. The application continues until the user selects the exit option.

Input Validation and Security

The program employs rigorous input validation to guard against malformed or malicious input. Passwords are hashed to prevent plain-text exposure. Menu options and product data are checked for correctness before processing. Password change and user addition features include verification steps to prevent unauthorized modifications.

Unit Testing

Methods such as AuthenticateUser, AddNewUser, RemoveUser, ChangePassword, cover various system functionalities. The unit tests verify correctness for individual methods, promoting robustness and facilitating maintenance.

Conclusion

This design leverages object-oriented programming best practices, ensuring a modular, flexible, and secure inventory management system. The application’s architecture supports future enhancements, maintains data integrity, and incorporates role-based permissions seamlessly.

References

  • Bloch, J. (2018). Effective Java (3rd Edition). Addison-Wesley.
  • Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
  • Estrada, D. (2010). Java Inheritance and Polymorphism. O'Reilly Media.
  • Oracle. (2022). Java Documentation. https://docs.oracle.com/javase/tutorial/
  • Fowler, M. (2004). Refactoring: Improving the Design of Existing Code. Addison-Wesley.
  • Schmidt, D. (2000). Pattern-Oriented Software Architecture. Wiley.
  • Heineman, G. T., & Councill, W. T. (2001). Component-Based Software Engineering. Addison-Wesley.
  • Sun Microsystems. (2005). Java Security Guide. https://java.sun.com/security/security-guide.html
  • Marinescu, R. (2013). Design of Secure Software Systems. Elsevier.
  • Object Management Group. (2017). UML Specification. https://www.omg.org/spec/UML/

Related Assignments