Access Modifiers in Ruby

Introduction

In Ruby, developers have access to three distinct access modifiers: public, private, and protected. Modifiers help control how different parts of a program can access the members of a class. By using these modifiers, we can ensure that the software system remains organized and functions properly. They play a crucial role in maintaining the overall quality and consistency of the program.

Understanding Access Modifiers in Ruby

Access modifiers are essential for attaining the goals of encapsulation, data abstraction, and code organization in object-oriented programming (OOP) with Ruby. They provide a number of advantages that improve the codebase's general design and maintainability.

We can keep certain parts of a class hidden from outside access and protect them from unauthorized changes. We do this by marking them as private or protected. This makes sure that implementation-specific information is kept private and is only accessible through clearly specified interfaces.

By differentiating between public, private, and protected members, we can easily determine whether methods and variables are meant for internal use, subclass use, or external interaction.

Public Access Modifier

The public access modifier in Ruby is the default modifier for class members. It allows unrestricted access to methods and variables from anywhere in the program. Any method defined in a class is public by default unless explicitly specified otherwise.

Example

Output

Explanation

A new object instance named car is created, of the type Car. The start_engine method for this object instance is called, which is accessible as it is a public member of the class by default. The function is executed and the output is shown.

Private Access Modifier

• The private access modifier restricts visibility of methods and variables to within the class itself.
• Methods declared as private cannot be called from outside the class scope; they can only be invoked by other methods within the same class.
• Private variables cannot be accessed directly from instances of the class.
• The private modifier ensures encapsulation and hides internal implementation details.

Example

Output

Explanation

• The class Car is defined with two member functions: a public function called start_engine() and a private function called start_engine_pvt().
• An object instance of the Car class is created and named car.
• The public member function start_engine() is called on the car object and executes successfully.
• However, when trying to access the private member function start_engine_pvt() from outside the class, it is not accessible.
• As a result, a NoMethodError occur, indicating that the private function cannot be accessed from outside the class itself.

Protected Access Modifier

The protected access modifier is used to define methods that can only be accessed within the class where they are defined or within subclasses of that class. This means that protected methods are not accessible from outside the class, but they can be called by other instances of the same class or instances of its subclasses.

Example

Output

Explanation

• There's a Car class with a protected method called start_engine_protected.
• The SportsCar class is a subclass of Car and uses the protected method within its own start_engine method.
• An instance of SportsCar is created, and we call the start_engine method on it.
• The protected method is accessed and executed successfully. The protected access modifier ensures that the method is accessible within the class hierarchy but not from outside.

Access Modifiers and Inheritance

In Ruby, inheritance allows a subclass to inherit public and protected methods from its superclass, but private methods are not inherited to maintain the privacy of the superclass's implementation details. This promotes a clear separation of concerns between classes and enhances code organization and security.

• Public methods:
  Create a well-defined interface for external interactions.
• Protected methods:
  Enable shared functionality between related classes.
• Private methods:
  Encapsulate internal implementation details, ensuring data abstraction.

By using access modifiers effectively, we can create code with better organization, security, and maintain a clean and robust inheritance relationship.