Object-Oriented Programming (OOP) in Ruby

Introduction

Ruby is recognized for its readability and simplicity, making it a great choice for both inexperienced and seasoned developers. Its comprehensive support for object-oriented programming is one of the major factors for it. By structuring their code around objects and their interactions, OOP enables developers to produce modular, reusable, and maintainable code.

What is Object-Oriented Programming?

Object-oriented programming (OOP) organizes and designs software by treating it as a collection of individual objects. These objects represent real-world entities, like a person, car, or bank account. Each object possesses unique attributes and performs specific tasks through methods. OOP promotes encapsulation, modularity, and code reusability, leading to cleaner and more maintainable programs.

Why Use Object-Oriented Programming in Ruby?

Object-oriented programming (OOP) is advantageous in Ruby because it offers a systematic method for creating software. It enables programmers to arrange their code in a logical and modular fashion, simplifying understanding, maintainability, and reusability.

Take a banking application as an example to demonstrate this. We can design a class named BankAccount that acts as a blue print for displaying a customer’s bank account. The account_number, balance, and customer_name are a few possible properties for this class. Additionally, we may define class-level methods like deposit, withdraw, and check_balance.

For each of the clients, we can build a BankAccount class object. Each of the accounts' properties will be kept in these objects. Using the class's methods, we can additionally carry out actions like withdrawals, deposits, and balance checks.

Classes and Objects in Ruby

In Ruby, classes provide a reusable framework using which objects can be instantiated, which are also of the same type. It is a user-defined block containing the features of the object in consideration and related functions for performing related operations. Let's take a deeper look into objects and classes, which form the basic backbone of OOP in Ruby.

What are Objects?

Objects are instances of a class in object-oriented programming. They communicate with one another through method calls and contain both the data and the behavior specified by the class. Each object has a distinct state (data), as well as behavior (methods).

What is a Class in Ruby?

Ruby uses classes much like a blueprint for creating objects of the same type. The characteristics and abilities that objects in that class will possess are specified. A class is created and defined in Ruby using the class keyword, followed by the body of the class which contains the data members and member functions of the class.

Creating an Object from a Class

The Ruby new keyword is used to create an object belonging to a particular class. By doing so, memory is allotted for the object and a fresh instance of the class is initialized. For example, if we have a class called Shape, we can make an object of that class by using Shape.new. This creates a new object based on the class definition that is prepared to be used in our program.

Defining Classes in Ruby

How to Define a Class in Ruby?

In Ruby, the class keyword must be included before the class name to declare a class. A class definition allows for the specification of characteristics and methods of the class's objects. Methods define an object's behavior, whereas attributes show an object's current state. Consider the following example:

Creating an Instance of a Class

We create an instance of a class using the new method. The new method calls the class's constructor, which is equivalent to Ruby's initialize method. The constructor is required to initialize the object's state.

Explanation

In the example above, the person's name is passed as a parameter to the initialize method, which then assigns it to the instance variable @name. The name is then printed by the greet method.

Instance Variables and Methods

Object instance variables are denoted in Ruby by the @ symbol. These variables can be accessed and modified by class-specific methods, and they serve as a representation of the object's current state. In the above illustration, greet is a method of the class Person, and @name is an instance variable.

Constructor in Ruby

Calling the constructor creates the object's initial state in Ruby and is used to create object instances. This constructor's name in Ruby is initialize. The @name variable of the class object is set in the above example's initialize method.

Attribute Accessors

The Ruby programming language provides an advantageous feature known as attribute accessors for interacting with instance variables. Attribute accessors can be used to read and modify the values of the instance variables of a class. Attribute accessors come in three basic categories, each of which fulfills a particular need.

• attr_reader:

  First, there is attr_reader, which is used in the development of read-only accessors. While we cannot directly alter an instance variable's value using attr_reader, we can obtain it. When we wish to expose a variable's value to other areas of our program without permitting external modifications, this kind of accessor comes in handy.

• attr_writer:

  Access to instance variables using this accessor is restricted to writing. With attr_writer, an instance variable's value can be modified, but it cannot be directly retrieved. This form of accessor is helpful when we want to restrict direct access to a variable's value while still allowing external updates.

• attr_accessor:

  The attr_reader and attr_writer functionalities are combined to jointly form the attr_accessor. Our access to an instance variable using this accessor is for reading as well as writing so that we can retrieve its value and make the appropriate adjustments. The attr_accessor makes it simple to get and modify an instance variable's value, making it particularly useful when we need total control over the variable.

Let's see an example:

In this example, we define a Person class with three attribute accessors: attr_reader:name, attr_writer :age, and attr_accessor :email. The attr_reader creates a read-only accessor for the name attribute, allowing us to retrieve the person's name but not modify it externally. The attr_writer creates a write-only accessor for the age attribute, enabling external updates to the person's age but preventing direct retrieval. Lastly, the attr_accessor creates both read and write accessors for the email attribute, allowing us to both retrieve and modify the person's email address as needed. The initialize method sets the initial values for the attributes when a new Person object is created.

Access Control

Access control in Ruby determines which methods are visible in different scopes of the program. There are three keywords for access control, to be specific:

• private methods:

  The only way to access private methods is from within the scope of the parent class and their objects themselves.

• public methods:

  Public methods are the most unprotected, and accessible from any location in the program.

• protected methods:

  Methods that are protected can only be accessed by members of the class and its subclasses.

Let's see an example:

In this example, we have a Rectangle class with two methods: calculate_area (public) and calculate_perimeter (private). When we create an instance of the Rectangle class and call the calculate_area method, it works as expected and displays the area of the rectangle. However, if we try to call the calculate_perimeter method from outside the class, it raises an error because private methods cannot be accessed directly outside the class scope.

The Four Pillars of Object-Oriented Programming

OOP revolves around four essential concepts, known as the Four Pillars of Object-Oriented Programming. Let's explore each of them:

• Inheritance:

  Inheritance allows classes to inherit attributes and methods from other classes. It promotes code reuse and enables the creation of specialized classes from existing ones.

• Polymorphism:

  Polymorphism allows objects of different classes to be treated as instances of a common superclass. It enables writing code that can work with objects of multiple types.

• Encapsulation:

  Encapsulation is the practice of bundling data and methods within a class, hiding the internal details. It promotes data integrity and protects the internal state of objects.

• Abstraction:

  Abstraction involves simplifying complex systems by breaking them into smaller, more manageable parts. It allows developers to focus on essential features while hiding unnecessary implementation details.