**Course Title:** Ruby Programming: From Basics to Advanced Techniques **Section Title:** Object-Oriented Programming (OOP) in Ruby **Topic:** Understanding self and class methods In this topic, we'll delve into the world of `self` and class methods in Ruby, exploring how to define and use them effectively in your object-oriented programming endeavors. We'll also examine the differences between instance and class methods, and when to use each. ### What are class methods? Class methods are methods that belong to a class rather than an instance of a class. They can be used to perform actions related to the class itself, such as creating a new instance or modifying the class's state. ```ruby class MyClass def self.class_method "This is a class method" end end ``` In this example, `class_method` is a class method that can be called on the `MyClass` class. ```ruby puts MyClass.class_method # Output: "This is a class method" ``` ### What are instance methods? Instance methods, on the other hand, are methods that belong to an instance of a class. They can be used to perform actions on a specific instance of a class. ```ruby class MyClass def instance_method "This is an instance method" end end my_instance = MyClass.new puts my_instance.instance_method # Output: "This is an instance method" ``` ### Defining class methods using `self` In Ruby, you can define a class method using the `self` keyword. When `self` is used inside a class definition, it refers to the class itself. ```ruby class MyClass def self.class_method "This is a class method" end end ``` Alternatively, you can use the `<<` keyword to define a class method. ```ruby class MyClass class << self def class_method "This is a class method" end end end ``` ### When to use class methods Class methods are useful when you need to perform actions that involve the class itself, rather than a specific instance. For example, you might use a class method to: * Create a new instance of a class * Modify the class's state * Retrieve information about the class ### When to use instance methods Instance methods are useful when you need to perform actions that are specific to a particular instance of a class. For example, you might use an instance method to: * Retrieve or modify the state of an instance * Perform actions that depend on the instance's state * Use an instance as a parameter for another method ### Best practices Here are some best practices to keep in mind when using `self` and class methods: * Use class methods when you need to perform actions that involve the class itself. * Use instance methods when you need to perform actions that are specific to a particular instance of a class. * Use the `self` keyword to define class methods. * Avoid using instance methods when you need to perform actions that involve the class itself. ### Example code Here's an example code snippet that demonstrates the use of class and instance methods: ```ruby class BankAccount def self.create_account(name, balance) puts "Creating account for #{name} with balance #{balance}" new(name, balance) end def initialize(name, balance) puts "Initializing account for #{name} with balance #{balance}" @name = name @balance = balance end def deposit(amount) puts "Depositing #{amount} into account for #{@name}" @balance += amount end def get_balance puts "Getting balance for #{@name}" @balance end end # Create a new account using the class method account = BankAccount.create_account("John Doe", 1000) # Perform actions on the instance using instance methods account.deposit(500) puts account.get_balance # Output: 1500 ``` ### Conclusion In this topic, we've explored the use of `self` and class methods in Ruby. We've learned how to define and use class methods to perform actions that involve the class itself, and how to use instance methods to perform actions that are specific to a particular instance of a class. Remember to use class methods when you need to perform actions that involve the class itself, and use instance methods when you need to perform actions that are specific to a particular instance of a class. **Do you have any questions about `self` and class methods? Please leave a comment below.** Additional resources: * [Ruby documentation: Class Methods](https://ruby-doc.org/core/doc/syntax/classes_rdoc.html#label-Defining+Class+Methods) * [Ruby documentation: Instance Methods](https://ruby-doc.org/core/doc/syntax/methods_rdoc.html#label-Defining+Instance+Methods) * [Stack Overflow: What's the difference between a class method and an instance method in Ruby?](https://stackoverflow.com/questions/10938543/whats-the-difference-between-a-class-method-and-an-instance-method-in-ruby) Next topic: **Working with arrays: creation, manipulation, and iteration.** (From: Data Structures: Arrays, Hashes, and Sets)