Exploring Encapsulation in Ruby

Welcome! Today's subject is encapsulation, a cornerstone of object-oriented programming (OOP). Encapsulation bundles data and the operations that we perform on them into one unit, namely, an object. It protects data from unwanted alterations, ensuring the creation of robust and maintainable software.

Prepare yourself for an exciting journey as we delve into how encapsulation works in Ruby and explore the vital role it plays in data privacy.

Starting with the basics, encapsulation involves combining data and the methods that modify this data into a single unit known as a class. It protects the data within an object from external interference.

In classes, you will often work with instance variables. These variables are declared with a @ in front and are central to encapsulation in Ruby. They hold data specific to an object and persist across different methods within the same object. These variables are private by default, meaning they can’t be accessed directly from outside the object, which helps maintain data privacy and integrity.

To illustrate, consider a Ruby class representing a bank account. Without encapsulation, the account balance would be accessible to outside functions and subject to unsolicited alterations from within. However, with encapsulation, we can provide a standardized and streamlined approach to alter the balance, like depositing or withdrawing.

class BankAccount
  def initialize(account_no, balance)
    @account_no = account_no  # Instance variable
    @balance = balance        # Instance variable
  end
  
  # Methods for depositing and withdrawing will be defined here
end

Encapsulation restricts direct access to an object's data and prevents unwanted data alteration. This principle is comparable to window blinds, allowing you to look out while preventing others from peeping in.

In Ruby, encapsulation pertains to marking methods as private, which is integral to data privacy. Private methods can only be accessed from within the class where they are defined.

To illustrate, let's consider a Ruby class named Person, which includes a private method name.

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

  def get_name
    name  # Accessor method
  end

  private

  def name
    @name
  end
end

person = Person.new('Alice')
puts person.get_name # Accessing private method via a public method. Output: Alice
puts person.name     # Error: private method `name' called 

In this example, name is private, and get_name enables us to access name. We specify that direct access to the name method is not allowed.