Object-Oriented Programming (OOP) is a powerful paradigm that allows developers to organize code into reusable and modular structures. Ruby, with its elegant syntax and dynamic nature, is an excellent language for implementing OOP principles. In this blog, we will explore the foundations of Object-Oriented Ruby and how it enables us to build efficient and scalable applications. We will dive into classes, objects, instance variables and methods, class variables and methods, self, and demonstrate how these concepts come together to enhance code organization and reusability. Let's get started!

Classes and Objects:
In Ruby, everything is an object, and classes act as blueprints for creating objects. Let's take a closer look at classes and objects:

class Person
  def initialize(name)
    @name = name
  end

  def greet
    puts "Hello, #{@name}!"
  end
end

person = Person.new("John")
person.greet # Output: Hello, John!

In the above code, we define a Person class with an initialize method that takes a parameter name and assigns it to the instance variable @name. The initialize method is a special method in Ruby that gets called when a new object of the class is created using the new method. We create a new object of the Person class and call the greet method on it. This demonstrates the fundamental concept of OOP, where objects are instances of classes and can invoke methods defined within those classes.

Instance Variables and Methods:
Instance variables, denoted with the @ symbol, are used to store data that is unique to each object instance. Instance methods are defined within the class and can access and manipulate instance variables. Let's see an example:

class Person
  def initialize(name)
    @name = name
  end

  def introduce
    puts "Hello, my name is #{@name}."
  end
end

person = Person.new("Jane")
person.introduce # Output: Hello, my name is Jane.

In the above code, the Person class has an instance variable @name, which stores the name of the person. The introduce method accesses the @name instance variable and outputs a greeting along with the name of the person.

Class Variables and Methods:
In addition to instance variables and methods, Ruby also supports class variables and methods. Class variables, denoted with @@, are shared among all instances of a class. Class methods are defined at the class level and can be called on the class itself rather than an instance of the class. Let's see an example:

class Person
  @@count = 0

  def initialize(name)
    @name = name
    @@count += 1
  end

  def self.total_count
    puts "Total number of people: #{@@count}"
  end
end

person1 = Person.new("John")
person2 = Person.new("Jane")

Person.total_count # Output: Total number of people: 2

In the above code, the Person class has a class variable @@count, which keeps track of the total number of instances created. The initialize method increments the @@count variable whenever a new object is created. The total_count method is a class method denoted with self, which can be called on the class itself to display the total count.

Self:
The keyword self refers to the current object or class within Ruby code. It allows us to access the current object's instance variables and invoke its methods. Let's see an example:

class Person
  def initialize(name)
    @name = name
  end

  def introduce
    puts "Hello, my name is #{self.name}."
  end

  def name
    @name
  end
end

person = Person.new("Alice")
person.introduce # Output: Hello, my name is Alice.

In the above code, the introduce method uses self.name to access the instance variable @name of the current object. Using self allows us to differentiate between local variables and instance variables of the object.

Object-Oriented Ruby provides a powerful and flexible approach to building efficient and scalable applications. By leveraging classes, objects, instance variables and methods, class variables and methods, self, and other OOP concepts, we can organize code into reusable and modular structures. Understanding and applying these concepts allows us to write cleaner, more maintainable, and extensible code.

Happy coding!