ANSWER

Section 5 – Class Design

Introduction: In Section 5 of this assignment, we will delve into the detailed class design for the ShoppingCart and ShoppingCartItem classes as part of the ITOT Case Study. This design process aligns with course objectives CO6 and CO9, focusing on the implementation of object-oriented models using UML concepts.

Section 5.1 – Class Diagram

For the detailed UML class design, we will establish a composition relationship between ShoppingCart and ShoppingCartItem, reflecting that when the ShoppingCart is empty, the ShoppingCartItem is also empty. The composition relationship implies that the lifetime of ShoppingCartItem is dependent on ShoppingCart. If ShoppingCart is destroyed, ShoppingCartItem instances within it are also destroyed.

Here’s a simplified representation of the class diagram:

ShoppingCart

• Attributes:
  • items: List<ShoppingCartItem>
  • totalCost: float
• Operations (Methods):
  • addItem(item: ShoppingCartItem): void
  • removeItem(item: ShoppingCartItem): void
  • calculateTotalCost(): float
  • getItems(): List<ShoppingCartItem>
  • getTotalCost(): float

ShoppingCartItem

• Attributes:
  • itemName: String
  • quantity: int
  • costPerItem: float
  • totalCost: float
• Operations (Methods):
  • updateItem(itemName: String, quantity: int, costPerItem: float): void
  • getItemName(): String
  • getQuantity(): int
  • getCostPerItem(): float
  • getTotalCost(): float

In the above class diagram:

• ShoppingCart has a composition relationship with ShoppingCartItem, denoted by the diamond-shaped symbol on the ShoppingCart end.
• ShoppingCart maintains a list of ShoppingCartItems and calculates the total cost.
• ShoppingCartItem represents an individual item in the cart, with attributes for its name, quantity, cost per item, and total cost.
• Operations are defined to add, remove, and calculate costs for items in the cart, and also to retrieve item details.

Section 5.2 – Discussion

The detailed class diagram provides a clear and concise representation of the ShoppingCart and ShoppingCartItem classes, their attributes, and operations. The composition relationship effectively models the containment of ShoppingCartItems within a ShoppingCart, ensuring that when a ShoppingCart is deleted, its associated items are also removed.

This design promotes modularity and encapsulation. The ShoppingCart encapsulates its item management logic, and the ShoppingCartItem encapsulates the attributes and operations related to individual items. This separation of concerns enhances maintainability and scalability.

The use of getter and setter methods enforces data encapsulation, allowing controlled access to class attributes. Additionally, the updateItem method in ShoppingCartItem provides a means to modify item details while maintaining consistency.

The composition relationship accurately reflects the real-world scenario where a shopping cart contains items, and the lifetime of items is tied to that of the cart. This design supports the use cases and sequence diagrams previously developed for the Manage Shopping Cart use case.

In conclusion, the detailed class design adheres to object-oriented principles, promoting a clean and robust architecture for the ITOT Case Study’s shopping cart system. This design is a crucial step towards implementing the software system and aligns with the course objectives related to software development processes and UML modeling.

QUESTION

Description