**Course Title:** Kotlin Programming: From Basics to Advanced Techniques **Section Title:** Object-Oriented Programming in Kotlin **Topic:** Build a class-based system in Kotlin to demonstrate OOP principles.(Lab topic) ### Introduction In this lab topic, we will create a class-based system in Kotlin to demonstrate the Object-Oriented Programming (OOP) principles we have learned so far. We will create a simple banking system that includes classes for `Bank`, `Account`, `Customer`, and `Transaction`. This example will help you understand how to apply OOP concepts such as inheritance, polymorphism, and encapsulation in a real-world scenario. ### Step 1: Define the Classes First, let's define the classes we need for our banking system. We will start by creating the `Customer` class, which will have properties for `name`, `address`, and `accountNumber`. ```kotlin // Customer class class Customer(val name: String, val address: String, val accountNumber: String) { override fun toString(): String { return "Customer(name='$name', address='$address', accountNumber='$accountNumber')" } } ``` Next, we will create the `Account` class, which will have properties for `accountNumber`, `balance`, and `customer`. This class will also have methods for depositing and withdrawing money. ```kotlin // Account class class Account(val accountNumber: String, var balance: Double, val customer: Customer) { fun deposit(amount: Double) { balance += amount println("Deposited $amount. New balance: $balance") } fun withdraw(amount: Double) { if (balance >= amount) { balance -= amount println("Withdrew $amount. New balance: $balance") } else { println("Insufficient funds") } } override fun toString(): String { return "Account(accountNumber='$accountNumber', balance=$balance, customer=$customer)" } } ``` Now, let's create the `Bank` class, which will have properties for `name` and `accounts`. This class will also have methods for creating new accounts and retrieving account information. ```kotlin // Bank class class Bank(val name: String) { private val accounts = mutableListOf<Account>() fun createAccount(customer: Customer, initialBalance: Double): Account { val account = Account(customer.accountNumber, initialBalance, customer) accounts.add(account) return account } fun getAccount(accountNumber: String): Account? { return accounts.find { it.accountNumber == accountNumber } } override fun toString(): String { return "Bank(name='$name', accounts=$accounts)" } } ``` Finally, we will create the `Transaction` class, which will have properties for `senderAccount`, `receiverAccount`, and `amount`. ```kotlin // Transaction class class Transaction(val senderAccount: Account, val receiverAccount: Account, val amount: Double) { fun execute() { if (senderAccount.balance >= amount) { senderAccount.balance -= amount receiverAccount.balance += amount println("Transaction successful") } else { println("Insufficient funds") } } override fun toString(): String { return "Transaction(senderAccount=$senderAccount, receiverAccount=$receiverAccount, amount=$amount)" } } ``` ### Step 2: Create Instances and Interact Now that we have defined our classes, let's create instances of these classes and interact with them. ```kotlin fun main() { // Create a bank val bank = Bank("My Bank") // Create customers val customer1 = Customer("John Doe", "123 Main St", "1234567890") val customer2 = Customer("Jane Doe", "456 Elm St", "9876543210") // Create accounts val account1 = bank.createAccount(customer1, 1000.0) val account2 = bank.createAccount(customer2, 500.0) // Deposit money account1.deposit(500.0) // Withdraw money account2.withdraw(200.0) // Create a transaction val transaction = Transaction(account1, account2, 300.0) // Execute the transaction transaction.execute() // Print account balances println("Account 1 balance: ${account1.balance}") println("Account 2 balance: ${account2.balance}") } ``` ### Conclusion In this lab topic, we created a class-based system in Kotlin to demonstrate OOP principles such as inheritance, polymorphism, and encapsulation. We defined classes for `Bank`, `Account`, `Customer`, and `Transaction` and interacted with these classes by creating instances and executing transactions. ### Key Takeaways * Inheritance: We used inheritance to create a hierarchy of classes, where `Account` is a subclass of `Any`. * Polymorphism: We used polymorphism to define methods that can be overridden by subclasses, such as the `toString()` method. * Encapsulation: We used encapsulation to hide the implementation details of our classes and provide a public interface through methods. ### External Resources * [Kotlin documentation: Classes and Objects](https://kotlinlang.org/docs/classes.html) * [Kotlin documentation: Inheritance](https://kotlinlang.org/docs/inheritance.html) * [Kotlin documentation: Polymorphism](https://kotlinlang.org/docs/polymorphism.html) * [Kotlin documentation: Encapsulation](https://kotlinlang.org/docs/encapsulation.html) ### Leave a Comment/Ask for Help If you have any questions or need help with this lab topic, please leave a comment below. We would be happy to help you understand the material better. Note: There are no other discussion boards for this course.