**Course Title:** Software Design Principles: Foundations and Best Practices **Section Title:** Structural Patterns **Topic:** Design and implement a system using one or more structural patterns.(Lab topic) **Introduction** In the previous topics, we explored various structural patterns that enable you to compose classes and objects into larger structures. Now, it's time to put these concepts into practice by designing and implementing a system using one or more structural patterns. **System Requirements** For this lab, let's consider a simple e-commerce system that allows customers to place orders for books, CDs, and DVDs. The system should be able to calculate the total cost of each order, including taxes and shipping fees. Additionally, the system should be able to provide a summary of each order, including the list of items, quantities, and prices. **Structural Patterns Used** To implement this system, we will use the following structural patterns: 1. **Composite Pattern**: To model the order item hierarchy, where each order can contain multiple items, and each item can be a book, CD, or DVD. 2. **Adapter Pattern**: To convert the tax and shipping fee calculators into a uniform interface that can be used by the order system. 3. **Facade Pattern**: To provide a simplified interface for the order system, hiding the complexity of the calculation and summary generation. **System Implementation** Here's a high-level implementation of the system using the above structural patterns: ```java // OrderItem.java (Composite Pattern) public abstract class OrderItem { private String name; private double price; public OrderItem(String name, double price) { this.name = name; this.price = price; } public String getName() { return name; } public double getPrice() { return price; } } public class Book extends OrderItem { public Book(String name, double price) { super(name, price); } } public class CD extends OrderItem { public CD(String name, double price) { super(name, price); } } public class DVD extends OrderItem { public DVD(String name, double price) { super(name, price); } } // TaxCalculator.java (Adapter Pattern) public interface TaxCalculator { double calculateTax(Order order); } public class USATaxCalculator implements TaxCalculator { @Override public double calculateTax(Order order) { // implement tax calculation logic for USA return 0.08 * order.getTotalCost(); // 8% tax } } // ShippingFeeCalculator.java (Adapter Pattern) public interface ShippingFeeCalculator { double calculateShippingFee(Order order); } public class FlatRateShippingFeeCalculator implements ShippingFeeCalculator { @Override public double calculateShippingFee(Order order) { // implement shipping fee calculation logic return 5.99; // flat rate shipping fee } } // Order.java (Facade Pattern) public class Order { private List<OrderItem> items; public Order() { this.items = new ArrayList<>(); } public void addItem(OrderItem item) { items.add(item); } public double getTotalCost() { double total = 0; for (OrderItem item : items) { total += item.getPrice(); } return total; } public double calculateTax(TaxCalculator taxCalculator) { return taxCalculator.calculateTax(this); } public double calculateShippingFee(ShippingFeeCalculator shippingFeeCalculator) { return shippingFeeCalculator.calculateShippingFee(this); } public String generateSummary() { // generate summary of order items, tax, and shipping fee return "Order Summary: " + getTotalCost() + ", Tax: " + calculateTax(new USATaxCalculator()) + ", Shipping Fee: " + calculateShippingFee(new FlatRateShippingFeeCalculator()); } } ``` **Example Usage** ```java public class Main { public static void main(String[] args) { Order order = new Order(); order.addItem(new Book("Book 1", 19.99)); order.addItem(new CD("CD 1", 14.99)); order.addItem(new DVD("DVD 1", 9.99)); System.out.println(order.generateSummary()); } } ``` **Key Takeaways** 1. **Composite Pattern** helps you create hierarchical structures, where objects can contain other objects. 2. **Adapter Pattern** enables you to convert incompatible interfaces into compatible ones, making it easier to work with different systems. 3. **Facade Pattern** provides a simplified interface to complex systems, hiding the underlying complexity. **Practical Exercise** Design and implement a system using one or more structural patterns to solve a real-world problem. Some ideas include: * A bank account system that uses the composite pattern to model account hierarchies * A payment gateway system that uses the adapter pattern to integrate with different payment processors * A hotel reservation system that uses the facade pattern to provide a simplified interface to room booking and billing **Additional Resources** * [Composite Pattern tutorial by Oracle](https://docs.oracle.com/javase/tutorial/essential/inheritance/composition.html) * [Adapter Pattern tutorial by GeeksforGeeks](https://www.geeksforgeeks.org/adapter-pattern/) * [Facade Pattern tutorial by Tutorialspoint](https://www.tutorialspoint.com/design_pattern/facade_pattern.htm) **Leave a Comment or Ask for Help** If you have any questions or need help with implementing the system, please leave a comment below. We'll be happy to assist you.