Object-oriented Programming Concepts in Ruby

Ruby is a versatile and dynamic programming language renowned for its simplicity and readability. It is considered a fully object-oriented language, meaning that everything in Ruby is an object. Whether it's numbers, strings, or even functions, everything is an object with its own set of properties and methods.

Classes and Objects

At the core of object-oriented programming (OOP) is the concept of classes and objects. A class is like a blueprint or template that defines the properties and behaviors of objects belonging to that class. Objects, on the other hand, are instances of classes that can interact with each other.

In Ruby, defining a class is as simple as using the class keyword followed by the name of the class. For example, here's a basic class definition for a Person:

class Person
  def initialize(name, age)
    @name = name
    @age = age

  def speak
    puts "Hello, my name is #{@name} and I'm #{@age} years old."

To create an object of this class, we can simply call the new method on the class:

person = Person.new("John", 25)

This will output: Hello, my name is John and I'm 25 years old.

Encapsulation and Data Hiding

Encapsulation is the concept of bundling data and methods together within a class. It helps in organizing and structuring code in a logical manner. By encapsulating data, we can make sure that it's not directly accessible outside of the class, protecting it from unintended modifications.

In Ruby, encapsulation is achieved through instance variables. These variables are prefixed with the @ symbol and can be accessed and modified only within the instance methods of the class. For example, in our Person class, @name and @age are instance variables.

Inheritance and Polymorphism

Inheritance is a fundamental concept in OOP that allows a class to inherit properties and behaviors from another class. This promotes code reuse and modularity. In Ruby, a class can inherit from another class using the < symbol.

Here's an example to illustrate inheritance:

class Student < Person
  def initialize(name, age, grade)
    super(name, age)
    @grade = grade

  def study
    puts "#{@name} is studying hard for the #{@grade} grade."

In this example, the Student class inherits from the Person class, and it adds an additional @grade instance variable and a study method.

Polymorphism is another essential concept in OOP that allows objects of different classes to be treated as interchangeable. It allows methods to be called on objects without knowing their specific types. In Ruby, polymorphism is implicit, and any object can respond to any method call as long as it implements the required behavior.


Abstraction is the practice of hiding unnecessary details and exposing only essential information to users. It allows us to work with complex systems without dealing with their internal complexity.

In Ruby, abstraction can be achieved by defining class methods and instance methods. Class methods are defined using the self keyword, while instance methods are defined without it. Class methods are accessible directly from the class, while instance methods can be called on objects.

class MathUtils
  def self.square(number)

  def square_root(number)

puts MathUtils.square(5) # Output: 25

math = MathUtils.new
puts math.square_root(25) # Output: 5.0

In this example, square is a class method that can be called directly on the MathUtils class without creating an object. On the other hand, square_root is an instance method that can only be called on an object of the MathUtils class.


Understanding object-oriented programming concepts is crucial for writing clean, modular, and maintainable code in Ruby. With classes, objects, encapsulation, inheritance, polymorphism, and abstraction, you have a powerful set of tools at your disposal to organize and structure your code effectively. So go ahead, embrace the beauty of Ruby's object-oriented nature, and start building amazing applications!

noob to master © copyleft