**Course Title:** Software Design Principles: Foundations and Best Practices **Section Title:** Behavioral Patterns **Topic:** Create an application that utilizes behavioral design patterns. **Objective:** By the end of this lab, you will be able to create an application that effectively utilizes behavioral design patterns to manage complex interactions and behaviors between objects. You will understand how to apply the principles learned in the previous topics to design a real-world application. **Overview:** In this lab, we will create a simple banking system that utilizes behavioral design patterns to manage user accounts, transactions, and notifications. We will use a combination of the Observer, Strategy, and Command patterns to create a robust and scalable application. **Design Requirements:** * The system should allow users to create and manage their accounts. * The system should allow users to perform transactions (deposits and withdrawals). * The system should notify users when a transaction is successful or failed. * The system should provide different notification strategies (email, SMS, etc.). **Solution:** We will use the following behavioral design patterns to implement the banking system: * Observer Pattern: to notify users when a transaction is successful or failed. * Strategy Pattern: to provide different notification strategies (email, SMS, etc.). * Command Pattern: to manage user accounts and transactions. **Implementation:** * **Step 1: Create the Account class** ```java // Account class (Observable) public class Account { private List<AccountObserver> observers; private double balance; public Account(double balance) { this.balance = balance; this.observers = new ArrayList<>(); } public void addObserver(AccountObserver observer) { this.observers.add(observer); } public void removeObserver(AccountObserver observer) { this.observers.remove(observer); } public void notifyObservers(String message) { for (AccountObserver observer : observers) { observer.update(message); } } // Getters and setters } ``` * **Step 2: Create the AccountObserver interface** ```java // AccountObserver interface (Observer) public interface AccountObserver { void update(String message); } ``` * **Step 3: Create the NotificationStrategy interface** ```java // NotificationStrategy interface (Strategy) public interface NotificationStrategy { void sendNotification(String message); } ``` * **Step 4: Create the EmailNotificationStrategy class** ```java // EmailNotificationStrategy class (Strategy) public class EmailNotificationStrategy implements NotificationStrategy { @Override public void sendNotification(String message) { System.out.println("Sending email notification: " + message); } } ``` * **Step 5: Create the SMSNotificationStrategy class** ```java // SMSNotificationStrategy class (Strategy) public class SMSNotificationStrategy implements NotificationStrategy { @Override public void sendNotification(String message) { System.out.println("Sending SMS notification: " + message); } } ``` * **Step 6: Create the CommandPattern classes** ```java // TransactionCommand class (Command) public interface TransactionCommand { void execute(); } public class DepositCommand implements TransactionCommand { private Account account; private double amount; public DepositCommand(Account account, double amount) { this.account = account; this.amount = amount; } @Override public void execute() { account.deposit(amount); } } public class WithdrawalCommand implements TransactionCommand { private Account account; private double amount; public WithdrawalCommand(Account account, double amount) { this.account = account; this.amount = amount; } @Override public void execute() { account.withdraw(amount); } } ``` * **Step 7: Create the main application class** ```java // MainApplication class public class MainApplication { public static void main(String[] args) { // Create an account Account account = new Account(1000); // Create a notification strategy NotificationStrategy notificationStrategy = new EmailNotificationStrategy(); // Create an observer AccountObserver observer = new EmailObserver(notificationStrategy); // Add the observer to the account account.addObserver(observer); // Perform a transaction TransactionCommand transactionCommand = new DepositCommand(account, 500); transactionCommand.execute(); // Notify the observer account.notifyObservers("Transaction successful"); } } ``` **Conclusion:** In this lab, we created a simple banking system that utilizes behavioral design patterns to manage complex interactions and behaviors between objects. We applied the Observer, Strategy, and Command patterns to provide a robust and scalable application. **Practical Takeaways:** * Use the Observer pattern to notify objects when a specific event occurs. * Use the Strategy pattern to provide different algorithms or behaviors. * Use the Command pattern to encapsulate and manage complex behaviors. **References:** * Head First Design Patterns by Kathy Sierra and Bert Bates (https://www.amazon.com/Head-First-Design-Patterns-Kathy-Sierra) * Design Patterns: Examples and Best Practices by GeeksforGeeks (https://www.geeksforgeeks.org/design-patterns) **We'd like to hear from you!** Please leave a comment below with any questions or feedback about this lab.