Ruby Classes and Objects

An object is a collection of data (variables) and methods. A class is a blueprint for creating such an object.

Before we learn about objects, let's first understand classes in Ruby.

Ruby Classes

A class is like a blueprint for creating objects.

We can think of the class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows, etc.

Based on these descriptions, we build the house (here, the house is the object).

Since many houses can be made from the same description, we can create many objects from a class.

Defining a Class in Ruby

We use the class keyword to create a class in Ruby. For example,

class ClassName
  # Class definition
end

Here, we have created a class named ClassName. All the code that defines the class goes between the class keyword and the end keyword.

Note: Class names should be written in PascalCase, i.e., the first letter of each word should be capitalized.

Example

class Dog
  def bark
      puts "Woof!"
  end
end

Here,

• Dog - The name of the class.
• bark - A method inside the class that prints the string "Woof!".

Ruby Objects

An object is called an instance of a class. You can create an object by using .new after the class name like this:

object_name = ClassName.new

Example

class Dog
  def bark
      puts "Woof!"
  end
end

# Create objects of the class
dog1 = Dog.new
dog2 = Dog.new

Here, dog1 and dog2 are objects (instances) of the Dog class. Now, we can use this object to access the method defined in the class.

Note: Use snake_case for object names and method names in Ruby, like dog1, bark, wag_tail, etc.

Access Methods Using Objects

Once you've created an object/instance, you can use it to access instance methods defined inside the class. For example,

class Dog
  # Instance method
  def bark
      puts "Woof!"
  end
end

# Create an object of the class
dog1 = Dog.new

# Access the 'bark' method using dog1 object
dog1.bark

Output

Woof!

Here, we created an object named dog1.

As you can see, we accessed the bark method defined inside the Dog class using the code dog1.bark.

Note: Here, bark is called an instance method because it's called on an instance/object of the class. You can also define class methods that are called on the class itself, not its instances. You'll learn about those later.

Ruby Instance Variables

Instance variables store information about an object. They always start with @ and are available throughout the object. For example,

class Dog

  # Initializer method to initialize instance variables
  def initialize

      # Create and initialize instance variables
      @name = "Maple"
      @breed = "Border Collie"
  end

  # Instance method
  def greet
      puts "Woof! My name is #{@name} and I'm a #{@breed}."
  end
end

dog1 = Dog.new
dog1.greet

Output

Woof! My name is Maple and I'm a Border Collie.

Here, @name and @breed are instance variables of the Dog class.

Notice that we've used the initialize method to create and initialize the instance variables — it's the preferred way to perform this task.

Let's learn about this method next.

Ruby initialize Method

In Ruby, the initialize method is a special method that is automatically called when a new object is created from a class.

It sets up (or "initializes") the instance variables of an object when it's first created.

Note: The initialize method doesn't need to be called manually — it runs automatically when you create an object with .new.

Example

class Dog

  # Initializer method to initialize instance variables
  # Takes parameters 'name' and 'breed'
  def initialize(name, breed)

      # Assign arguments to the instance variables
      @name = name
      @breed = breed
  end

  # Instance method
  def greet
      puts "Woof! My name is #{@name} and I'm a #{@breed}."
  end
end

# Create an object
# Pass "Honey" and "Wolfdog" as arguments to initialize
dog1 = Dog.new("Honey", "Wolfdog")
dog1.greet

# Create another object and pass another set of arguments
dog2 = Dog.new("Maple", "Border Collie")
dog2.greet

Output

Woof! My name is Honey and I'm a Wolfdog.
Woof! My name is Maple and I'm a Border Collie.

Here, the initialize method accepts two arguments, which are stored in the name and breed parameters.

The values of these parameters are then assigned to the instance variables @name and @breed.

Note: Here, name and @name are different variables. The same goes for breed and @breed.

Passing Arguments to the initialize Method

We pass arguments to initialize when creating the object like this:

# Pass "Honey" and "Wolfdog" as arguments
dog1 = Dog.new("Honey", "Wolfdog")

# Pass "Maple" and "Border Collie" as arguments
dog2 = Dog.new("Maple", "Border Collie")

Example: Ruby Class and Objects

# Define a Circle class
class Circle
  def initialize(radius)
      @radius = radius
  end

  # Instance method that returns area of circle
  def calculate_area
      3.14 * @radius * @radius
  end
end

# Create a circle object with radius 7
circle = Circle.new(7)

# Call the instance method and store its value in a variable
circle_area = circle.calculate_area

# Print the area of the circle
puts "Area of the Circle: #{circle_area}"

Output

Area of the Circle: 153.86

In the above example, we defined a class named Circle with the following components:

• @radius - An instance variable that stores the radius of the circle.
• initialize - An initializer method to create and initialize the instance variable(s).
• calculate_area - An instance method that returns the area of the circle.

We then created an object named circle and passed 7 as an argument to its initializer.

# Create a circle object with radius 7
circle = Circle.new(7)

This value is then assigned to the @radius instance variable.

Finally, we accessed its calculate_area method using the . notation:

# Call the instance method and store its value in a variable
circle_area = circle.calculate_area

class Dog
  def initialize(name, breed)
      @name = name
      @breed = breed
  end
end

dog1 = Dog.new("Honey", "Wolfdog")

# Invalid: Accessing instance variable 'name'
# NoMethodError: undefined method 'name' for an instance of Dog
puts dog1.name

# Invalid: Accessing instance variable 'breed'
# NoMethodError: undefined method 'breed' for an instance of Dog
puts dog1.breed

class Dog

  # Use attr_accessor on instance variables
  attr_accessor :name
  attr_accessor :breed
    
  def initialize(name, breed)
      @name = name
      @breed = breed
  end
end

dog1 = Dog.new("Honey", "Wolfdog")

# Access instance variables
puts dog1.name
puts dog1.breed

Honey
Wolfdog