**Course Title:** Software Design Principles: Foundations and Best Practices **Section Title:** Refactoring Techniques **Topic:** Refactor a codebase using various refactoring techniques.(Lab topic) **Introduction:** In the previous topic, we discussed the importance of refactoring, common refactoring techniques, and tools for refactoring. Now, it's time to put these concepts into practice by refactoring a real-world codebase using various refactoring techniques. In this lab, we'll work with a sample codebase that exhibits some common design issues and apply different refactoring techniques to improve its maintainability, readability, and scalability. **Objective:** By the end of this lab, you should be able to: 1. Identify areas in a codebase that require refactoring. 2. Apply various refactoring techniques to improve code quality. 3. Use refactoring tools to automate the refactoring process. **Preparation:** Before starting the lab, make sure you have: * A code editor or IDE of your choice (e.g., Visual Studio Code, IntelliJ IDEA, Eclipse) * A version control system (e.g., Git) * Familiarity with the programming language used in the sample codebase (e.g., Java, C++, Python) **Sample Codebase:** For this lab, we'll use a simple e-commerce system written in Java. The codebase consists of a `Product` class, an `Order` class, and a `PaymentProcessor` class. ```java // Product.java public class Product { private String id; private String name; private double price; public Product(String id, String name, double price) { this.id = id; this.name = name; this.price = price; } public String getId() { return id; } public String getName() { return name; } public double getPrice() { return price; } } // Order.java public class Order { private List<Product> products; private PaymentProcessor paymentProcessor; public Order(List<Product> products, PaymentProcessor paymentProcessor) { this.products = products; this.paymentProcessor = paymentProcessor; } public void placeOrder() { // Calculate total price double totalPrice = 0; for (Product product : products) { totalPrice += product.getPrice(); } // Process payment paymentProcessor.processPayment(totalPrice); } } // PaymentProcessor.java public class PaymentProcessor { public void processPayment(double amount) { // Simulate payment processing System.out.println("Processing payment of " + amount); } } ``` **Refactoring Steps:** 1. Extract Method: The `placeOrder()` method in the `Order` class is doing two things: calculating the total price and processing the payment. We can extract the calculation logic into a separate method called `calculateTotalPrice()`. ```java // Order.java public class Order { ... public void placeOrder() { double totalPrice = calculateTotalPrice(); paymentProcessor.processPayment(totalPrice); } private double calculateTotalPrice() { double totalPrice = 0; for (Product product : products) { totalPrice += product.getPrice(); } return totalPrice; } } ``` 2. Introduce Interface: The `PaymentProcessor` class has a specific implementation, but what if we want to use a different payment processor? We can introduce an interface called `PaymentGateway` that defines the `processPayment()` method. ```java // PaymentGateway.java public interface PaymentGateway { void processPayment(double amount); } // PaymentProcessor.java public class PaymentProcessor implements PaymentGateway { @Override public void processPayment(double amount) { System.out.println("Processing payment of " + amount); } } ``` 3. Remove Duplicate Code: In the `Product` class, we have a constructor that takes three parameters: `id`, `name`, and `price`. We can remove the duplicate code by creating a private constructor and using a builder pattern to create `Product` objects. ```java // Product.java public class Product { private String id; private String name; private double price; private Product(String id, String name, double price) { this.id = id; this.name = name; this.price = price; } public static class Builder { private String id; private String name; private double price; public Builder withId(String id) { this.id = id; return this; } public Builder withName(String name) { this.name = name; return this; } public Builder withPrice(double price) { this.price = price; return this; } public Product build() { return new Product(id, name, price); } } } ``` **Conclusion:** In this lab, we applied various refactoring techniques to improve the maintainability, readability, and scalability of a sample e-commerce system. We extracted methods, introduced interfaces, and removed duplicate code to make the codebase more modular and easier to understand. **What's Next:** In the next topic, we'll discuss the importance of testing in software design. We'll cover different types of tests, testing frameworks, and best practices for writing effective tests. **External Resources:** * [Refactoring Techniques](https://sourcemaking.com/refactoring/techniques) by Sourcemaking * [Design Patterns](https://www.patterns.dev/) by FreeCodeCamp * [Testing](https://martinfowler.com/testing/) by Martin Fowler