**Course Title:** Ruby Programming: From Basics to Advanced Techniques **Section Title:** Object-Oriented Programming (OOP) in Ruby **Topic:** Create a Ruby class that demonstrates OOP principles. In this lab, you'll apply the OOP concepts learned in the previous topics by creating a Ruby class that incorporates attributes, methods, inheritance, and mixins with modules. This class will demonstrate a real-world example of how OOP principles are applied in Ruby programming. **The Case Study: Bank Account Class** We'll design a class to represent a bank account, which has attributes like account number, balance, and account holder's name, and includes methods for deposit, withdrawal, and checking the account balance. This example illustrates a common use case for OOP in programming. **Step 1: Define the Class** Create a new Ruby file called `bank_account.rb` and define a new class called `BankAccount`: ```ruby # bank_account.rb class BankAccount # Attributes and methods go here end ``` Before we begin implementing the class body, review the OOP concepts that we'll apply in this example: * **Encapsulation**: We'll encapsulate data (attributes) and behavior (methods) within the class, using getter and setter methods to access and modify the attributes. * **Inheritance**: We'll not create a subclass in this example, but we'll apply inheritance principles by inheriting the methods from the parent class, if needed. * **Polymorphism**: We'll apply polymorphism by implementing methods with different parameters and data types. * **Abstraction**: We'll abstract the class to include only the necessary details and methods that can be accessed from outside the class. **Step 2: Define Attributes and Getter/Setter Methods** Add the attributes and getter/setter methods to the class: ```ruby class BankAccount # Attributes @account_number @balance @account_holder_name # Constructor def initialize(account_number, balance, account_holder_name) @account_number = account_number @balance = balance @account_holder_name = account_holder_name end # Getter methods for accessing attributes def account_number @account_number end def balance @balance end def account_holder_name @account_holder_name end # Setter methods for modifying attributes def account_number=(new_account_number) @account_number = new_account_number end def balance=(new_balance) @balance = new_balance end def account_holder_name=(new_account_holder_name) @account_holder_name = new_account_holder_name end end ``` **Step 3: Define Methods** Add the necessary methods for deposit, withdrawal, and checking the account balance: ```ruby class BankAccount # Deposit method def deposit(amount) @balance += amount puts "Deposited $#{amount}. New balance: $#{@balance}" end # Withdrawal method def withdraw(amount) if @balance >= amount @balance -= amount puts "Withdrew $#{amount}. New balance: $#{@balance}" else puts 'Insufficient balance.' end end # Check account balance def check_balance puts "Account balance: $#{@balance}" end end ``` **Testing the Class** To test the `BankAccount` class, create an instance and call the methods: ```ruby bank_account = BankAccount.new(12345, 1000, 'John Doe') # Check initial balance bank_account.check_balance # Deposit $500 bank_account.deposit(500) # Withdraw $200 bank_account.withdraw(200) # Check new balance bank_account.check_balance ``` After creating and testing this class, review the code and ensure that you've applied the OOP principles we've covered: * **Single responsibility principle (SRP)**: The `BankAccount` class has a single responsibility – managing a bank account. * **Open/closed principle (OCP)**: You can extend the `BankAccount` class by adding new methods without modifying the existing class. * **Liskov substitution principle (LSP)**: Any subclass of `BankAccount` should be able to replace `BankAccount` without affecting the program's functionality. In this lab, you applied your knowledge of Ruby classes and OOP principles to design a real-world example. By breaking down the problem into smaller parts and testing the code, you can ensure that your application works as expected. **What to Do Next?** Now that you have a solid understanding of creating a Ruby class that demonstrates OOP principles, review the official [Ruby documentation](https://ruby-doc.org/) for classes and modules. If you've followed this tutorial correctly, you should be able to apply the concepts to your own project. **Have Questions or Issues?** Please comment below or ask for help if you encounter problems or need further clarification on any topic. **Additional Resources:** * [Ruby documentation: Classes](https://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/classes.html) * [Ruby documentation: Modules](https://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/modules.html) * [Object-Oriented Programming (OOP) principles](https://en.wikipedia.org/wiki/Object-oriented_programming#Principles) Next Topic: [Working with Arrays in Ruby](#), from [Data Structures: Arrays, Hashes, and Sets](#). **Practice Exercise (60 minutes):** Design a Ruby class that represents a vehicle and includes attributes like color, brand, and model. Add methods to display the vehicle details and perform actions like accelerating and braking. Use the OOP principles and apply them in a real-world context.