**Course Title:** Mastering Dart: From Fundamentals to Flutter Development **Section Title:** Object-Oriented Programming in Dart **Topic:** Build a Dart application that implements classes, inheritance, and encapsulation. **Introduction:** In this lab topic, we will apply the concepts learned in Object-Oriented Programming in Dart to build a real-world application. We will design and implement classes, inheritance, and encapsulation to create a simple banking system. This exercise will help you grasp the practical applications of OOP concepts in Dart. **Lab Objective:** Create a Dart application that models a basic banking system using classes, inheritance, and encapsulation. The system should have the following features: 1. Ability to create different types of bank accounts (e.g., Checking, Savings, Credit Card) 2. Ability to perform basic account operations (e.g., deposit, withdraw, check balance) 3. Ability to apply interest to Savings accounts **Step 1: Design the Classes** We will start by designing the classes for our banking system. We will create an abstract class `Account` and concrete classes `Checking`, `Savings`, and `CreditCard`. Each class will have its own set of properties and methods. ```dart // account.dart abstract class Account { double _balance; Account(this._balance); void deposit(double amount); void withdraw(double amount); double getBalance(); } // checking.dart class Checking extends Account { double _balance; Checking(double balance) : super(balance); @override void deposit(double amount) { _balance += amount; } @override void withdraw(double amount) { _balance -= amount; } @override double getBalance() { return _balance; } } // savings.dart class Savings extends Account { double _balance, _interestRate; Savings(double balance, double interestRate) : super(balance), _interestRate = interestRate; @override void deposit(double amount) { _balance += amount; } @override void withdraw(double amount) { _balance -= amount; } @override double getBalance() { return _balance; } void applyInterest() { _balance += _balance * _interestRate / 100; } } // creditcard.dart class CreditCard extends Account { double _balance, _limit; CreditCard(double balance, double limit) : super(balance), _limit = limit; @override void deposit(double amount) { _balance += amount; } @override void withdraw(double amount) { if (_balance - amount < -_limit) { print('Insufficient funds'); } else { _balance -= amount; } } @override double getBalance() { return _balance; } } ``` **Step 2: Implement Encapsulation** We have implemented encapsulation by making the properties of our classes private and providing public methods to access and modify them. This is an important feature of Object-Oriented Programming that helps prevent code from being changed from outside the class, and ensures that methods are used to access the properties. **Step 3: Test the Application** Now that we have implemented our classes, let's test the application: ```dart // main.dart void main() { // Create a checking account and perform transactions Checking checkingAccount = Checking(1000.0); print('Checking account balance: ' + checkingAccount.getBalance().toString()); checkingAccount.deposit(500.0); print('Checking account balance after deposit: ' + checkingAccount.getBalance().toString()); checkingAccount.withdraw(200.0); print('Checking account balance after withdrawal: ' + checkingAccount.getBalance().toString()); // Create a savings account and perform transactions Savings savingsAccount = Savings(2000.0, 5.0); print('Savings account balance: ' + savingsAccount.getBalance().toString()); savingsAccount.deposit(1000.0); print('Savings account balance after deposit: ' + savingsAccount.getBalance().toString()); savingsAccount.withdraw(500.0); print('Savings account balance after withdrawal: ' + savingsAccount.getBalance().toString()); savingsAccount.applyInterest(); print('Savings account balance after applying interest: ' + savingsAccount.getBalance().toString()); // Create a credit card account and perform transactions CreditCard creditCard = CreditCard(1000.0, 2000.0); print('Credit card balance: ' + creditCard.getBalance().toString()); creditCard.deposit(1000.0); print('Credit card balance after deposit: ' + creditCard.getBalance().toString()); creditCard.withdraw(1500.0); print('Credit card balance after withdrawal: ' + creditCard.getBalance().toString()); } ``` **Conclusion:** In this lab topic, we applied the concepts learned in Object-Oriented Programming in Dart to build a simple banking system. We designed classes that implement inheritance, polymorphism, and encapsulation to create a robust application. **Key Concepts:** * Classes * Inheritance * Encapsulation * Polymorphism * Abstract classes * Concrete classes **References:** * Dart Documentation: [https://dart.dev/guides/language/language-tour](https://dart.dev/guides/language/language-tour) * Dart API Reference: [https://api.dart.dev/](https://api.dart.dev/) Do you have any questions or need further clarification? Please leave a comment below or ask for help. After going through the content above, in the next topic, you will learn about Dart collections, including lists, sets, and maps, from the section 'Working with Collections and Generics'.