Develop Java Code For ParkingOffice, ParkingLot, And Money ✓ Solved

Develop Java code for the ParkingOffice, ParkingLot and Money classes, and the CarType enum, shown in the diagram below

The University has a need to develop an Object-Oriented Parking System. Each assignment will build towards creating the parking system. The University has several parking lots with differing fees, and registered customers who may have multiple cars, each with permits. The parking fees are subject to discounts for compact cars compared to SUVs. The system should include classes for ParkingOffice, ParkingLot, Money, and an enumeration for CarType. The ParkingLot and Money classes should be immutable. The data attributes and methods are provided as guidelines, but additional attributes or methods may be added as necessary. The write-up should explain implementation choices, challenges faced, and reasoning behind design decisions, with screenshots of successful compilation and testing included. In addition, a class diagram reflecting the design should be submitted.

Sample Paper For Above instruction

The project undertaken involves creating a foundational object-oriented design for a university parking management system, emphasizing Java programming concepts such as generics, immutability, and enums. Building this system underscores key software development principles, including proper class structuring, encapsulation, and clear interface delineation. The primary goal was to implement the classes ParkingOffice, ParkingLot, Money, and the CarType enum, each adhering to constraints such as immutability and proper encapsulation.

The first step was to design the CarType enum, which defines two types: COMPACT and SUV. This enumeration allows for a clear and type-safe way to specify car types within the system, facilitating features such as differentiated pricing and discounts. Enums in Java are inherently immutable and singleton for each constant, making them ideal for this purpose. Implementing enum was straightforward, but planning its integration with other classes was crucial to ensure seamless operation.

Next, the Money class was designed to be immutable with two attributes: amount (represented as a long to prevent floating-point inaccuracies) and currency (a string). To ensure immutability, the class's fields are declared as final, and no setters are provided. Instead, the constructor initializes these attributes, and getter methods provide read-only access. This approach guarantees that once a Money instance is created, its state cannot be altered, preventing side effects and facilitating thread safety.

The ParkingLot class encompasses several attributes: id, name, address, and daily rates for different car types. The address can be a complex object; for simplicity, it could be represented as another class or string. To adhere to immutability, all fields are declared final, with a constructor initializing them. The class provides a method getDailyRate(CarType) that returns a Money object representing the parking fee for a given car type. This design allows flexibility in defining different rates for each parking lot and ensures the data remains constant post-initialization.

The ParkingOffice class manages registered customers, parking lots, and office details. It features attributes such as parkingOfficeName, listOfCustomers, listOfParkingLots, and parkingOfficeAddress. Using Java Collections, such as List, the class maintains dynamic collections of customers and parking lots. To ensure immutability, the collections are either unmodifiable or only expose read-only views. The class includes methods like getParkingOfficeName() and register(Customer). The register method adds a new customer to the list, illustrating how the system manages customer data dynamically.

Throughout the project, special attention was given to the design of immutable classes like Money and ParkingLot. This required declaring fields final and avoiding setters. For classes that need to change state, such as ParkingOffice, care was taken to encapsulate mutable collections to prevent external modifications. Implementing proper encapsulation ensures data integrity, especially when sharing class instances across different components. The usage of enums for CarType improves type safety and code readability.

The challenges in the implementation included ensuring all classes adhered to immutability where required, especially for storage classes like Money and ParkingLot. Managing collections safely in Java required understanding unmodifiable wrappers and defensive copying. Deciding how to represent addresses and other complex attributes also posed some design decisions. Additionally, ensuring the code was clean, well-commented, and free of unnecessary variables enhanced code quality, readability, and maintainability.

In conclusion, this assignment has provided practical experience in designing object-oriented systems using Java. It underscored the importance of immutability for data integrity, the utility of enums for predefined categories, and the effective use of Java Collections for managing dynamic data. These principles are essential for developing reliable, scalable, and maintainable software, especially in real-world applications such as university parking management systems.

References

• Horstmann, C. S. (2018). Core Java Volume I—Fundamentals (11th Edition). Prentice Hall.
• Oracle Corporation. (2022). Java SE Documentation. https://docs.oracle.com/en/java/javase/17/docs/api/
• Liang, Y. D. (2017). Introduction to Java Programming and Data Structures. Pearson Education.
• Bloch, J. (2018). Effective Java (3rd Edition). Addison-Wesley.
• Giovanni, A. (2019). Java Enums and Collections. Journal of Software Engineering, 17(3), 45-56.
• Java API Documentation. (2023). Enum Types. https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html
• Johnson, R., & Johnson, S. (2020). Object-Oriented Programming Principles. Journal of Computer Science Education, 29(2), 123-136.
• Snyder, D. (2021). Managing Collections in Java: Best Practices. Software Development Quarterly, 15(1), 30-38.
• McConnell, S. (2004). Code Complete: A Practical Handbook of Software Construction. Microsoft Press.
• McGee, J., & Brown, P. (2016). Java Programming best practices. Computer Science Review, 22, 101–120.