Understanding Method Visibility in Ruby

When working with Ruby, it's important to understand the concept of method visibility. In Ruby, methods can have different levels of visibility, which determine who can access and call them. In this article, we will explore the three levels of method visibility in Ruby: public, private, and protected.

Public Methods

Public methods are the default visibility level in Ruby. This means that any method defined in a class is public by default, and can be called from outside the class. Public methods are accessible to all objects, regardless of their class or inheritance hierarchy.

Here is an example of a public method in Ruby:

class MyClass
  def public_method
    puts "This is a public method"
  end
end

obj = MyClass.new
obj.public_method

In this example, the public_method is accessible from outside the class MyClass and can be called on an instance of the class.

Private Methods

Private methods in Ruby can only be called from within the class where they are defined. They cannot be called from outside the class or by any other object. Private methods are typically used for internal implementation details that should not be exposed to external code.

Here is an example of a private method in Ruby:

class MyClass
  def public_method
    puts "This is a public method"
    private_method
  end

  private

  def private_method
    puts "This is a private method"
  end
end

obj = MyClass.new
obj.public_method
obj.private_method # This will raise an error

In this example, the private_method is only accessible from within the class MyClass and cannot be called from outside the class.

Protected Methods

Protected methods in Ruby are similar to private methods, but with one key difference: they can be called by any instance of the defining class or its subclasses. Protected methods are typically used when you want to restrict access to certain methods, but still allow subclasses to call them.

Here is an example of a protected method in Ruby:

class MyClass
  def public_method
    puts "This is a public method"
    protected_method
  end

  protected

  def protected_method
    puts "This is a protected method"
  end
end

class MySubclass < MyClass
  def call_protected_method
    protected_method
  end
end

obj = MyClass.new
obj.public_method
obj.protected_method # This will raise an error

sub_obj = MySubclass.new
sub_obj.call_protected_method

In this example, the protected_method can be called by instances of the class MyClass or its subclasses, such as MySubclass.

Conclusion

Understanding method visibility in Ruby is essential for writing clean and maintainable code. By using public, private, and protected methods effectively, you can control access to your class's behavior and ensure that your code is well-organized and secure.