The Project | About Us | Contribute | Donations | License

HOME

In this section, we will delve into the concepts of instance variables and methods in Ruby. These are fundamental aspects of object-oriented programming (OOP) in Ruby, allowing you to create and manage objects with their own state and behavior.

Key Concepts

Instance Variables

Definition: Instance variables are variables that belong to an instance of a class. They are used to store the state of an object.
Syntax: Instance variables are prefixed with an @ symbol.
Scope: They are accessible only within the instance methods of the class.

Instance Methods

Definition: Instance methods are methods that operate on an instance of a class. They can access and modify instance variables.
Syntax: Defined using the def keyword within a class.

Practical Examples

Defining a Class with Instance Variables and Methods

class Person
  # Constructor method to initialize instance variables
  def initialize(name, age)
    @name = name
    @age = age
  end

  # Instance method to display person's details
  def display_details
    puts "Name: #{@name}, Age: #{@age}"
  end

  # Instance method to update age
  def update_age(new_age)
    @age = new_age
  end
end

# Creating an instance of Person
person1 = Person.new("Alice", 30)

# Calling instance methods
person1.display_details  # Output: Name: Alice, Age: 30
person1.update_age(31)
person1.display_details  # Output: Name: Alice, Age: 31

Explanation

Constructor Method (initialize): This method is called when a new instance of the class is created. It initializes the instance variables @name and @age.
Instance Methods (display_details, update_age): These methods can access and modify the instance variables.

Exercises

Exercise 1: Create a `Car` Class

Task: Define a Car class with instance variables for make, model, and year. Include methods to display the car's details and update the year.

class Car
  def initialize(make, model, year)
    @make = make
    @model = model
    @year = year
  end

  def display_details
    puts "Make: #{@make}, Model: #{@model}, Year: #{@year}"
  end

  def update_year(new_year)
    @year = new_year
  end
end

# Test the Car class
car1 = Car.new("Toyota", "Corolla", 2020)
car1.display_details  # Output: Make: Toyota, Model: Corolla, Year: 2020
car1.update_year(2021)
car1.display_details  # Output: Make: Toyota, Model: Corolla, Year: 2021

Solution Explanation

Initialization: The initialize method sets the initial values for @make, @model, and @year.
Display Method: The display_details method prints the car's details.
Update Method: The update_year method updates the @year instance variable.

Common Mistakes and Tips

Forgetting the @ Symbol: Ensure you use the @ symbol to denote instance variables.
Accessing Instance Variables Outside Methods: Remember that instance variables are only accessible within instance methods.

Conclusion

In this section, we covered the basics of instance variables and methods in Ruby. You learned how to define and use instance variables to store the state of an object and how to create instance methods to manipulate that state. These concepts are crucial for building robust and maintainable object-oriented programs in Ruby.

Next, we will explore class variables and methods, which allow you to share data and behavior across all instances of a class.

Instance Variables and Methods

Key Concepts