**Course Title:** Mastering Go: From Basics to Advanced Development **Section Title:** Structs and Interfaces **Topic:** Build a program that utilizes structs and interfaces to model real-world entities. (Lab topic) **Objective:** In this lab, you'll learn how to apply your knowledge of structs and interfaces to model real-world entities. You'll design and implement a program that utilizes these concepts to represent complex data structures. By the end of this lab, you'll be able to: * Design and implement structs to model real-world entities * Define and use interfaces to abstract behavior * Utilize polymorphism to write more generic and reusable code **Lab Exercise:** **Task:** Build a program that models a simple banking system. The system should have the following features: * Accounts: Each account should have a unique ID, account number, account holder's name, and balance. * Transactions: The system should support deposit and withdrawal transactions. * Transaction History: The system should maintain a transaction history for each account. **Step 1: Define the Structs** Create a new Go file called `banking_system.go` and define the following structs: ```go // Account represents a bank account type Account struct { ID string AccountNumber string AccountHolder string Balance float64 } // Transaction represents a transaction type Transaction struct { ID string AccountID string Amount float64 Type string } ``` **Step 2: Define the Interfaces** Define the following interfaces: ```go // AccountInterface represents the behavior of an account type AccountInterface interface { Deposit(amount float64) Withdraw(amount float64) GetBalance() float64 GetTransactionHistory() []Transaction } // TransactionInterface represents the behavior of a transaction type TransactionInterface interface { GetAmount() float64 GetType() string } ``` **Step 3: Implement the Structs** Implement the structs to satisfy the interfaces: ```go // Deposit adds the given amount to the account balance func (a *Account) Deposit(amount float64) { a.Balance += amount } // Withdraw subtracts the given amount from the account balance func (a *Account) Withdraw(amount float64) { if a.Balance >= amount { a.Balance -= amount } } // GetBalance returns the current account balance func (a *Account) GetBalance() float64 { return a.Balance } // GetTransactionHistory returns the transaction history of the account func (a *Account) GetTransactionHistory() []Transaction { // Implement transaction history logic here return []Transaction{} } // GetAmount returns the amount of the transaction func (t *Transaction) GetAmount() float64 { return t.Amount } // GetType returns the type of the transaction func (t *Transaction) GetType() string { return t.Type } ``` **Step 4: Utilize Polymorphism** Create a new function that takes an `AccountInterface` as an argument and performs a deposit: ```go func PerformDeposit account *AccountInterface, amount float64) { account.Deposit(amount) } ``` **Step 5: Test the Program** Create a new function to test the program: ```go func main() { account := &Account { ID: "123", AccountNumber: "456", AccountHolder: "John Doe", Balance: 1000.0, } PerformDeposit(account, 500.0) fmt.Println(account.GetBalance()) } ``` **Run and Verify** Run the program using `go run banking_system.go` and verify that the account balance has been updated correctly. **Conclusion:** In this lab, you've designed and implemented a program that utilizes structs and interfaces to model real-world entities. You've also utilized polymorphism to write more generic and reusable code. With this knowledge, you can now move on to more complex topics in Go programming. **Additional Resources:** * The official Go documentation: [https](https://golang.org/doc/)[://golang.org/doc/](https://golang.org/doc/) * Go by Example: [https](https://gobyexample.com/)[://gobyexample.com](https://gobyexample.com/) **Leave a Comment/Ask for Help:** Please feel free to leave a comment or ask for help if you have any questions or need further clarification on the material.