Ruby Private Method

last modified April 27, 2025

This tutorial explains how to use Ruby's private method modifier. Private methods are an essential part of object-oriented programming in Ruby.

The private keyword makes methods accessible only within the class. They cannot be called with an explicit receiver, only the current object (self).

Private methods enforce encapsulation by hiding implementation details. They help create clean interfaces and prevent misuse of internal class functionality.

Basic Private Method Example

This simple example demonstrates the basic usage of private methods in Ruby. Private methods can only be called within the class definition.

class Person
 def greet
 puts "Hello, #{name}"
 end
 private
 
 def name
 "John Doe"
 end
end
person = Person.new
person.greet
# person.name # This would raise NoMethodError

The name method is private and can only be called internally. Attempting to call it directly on an instance raises a NoMethodError.

Private Method Calling Convention

Private methods can only be called without an explicit receiver. They must be called on the implicit self or from within other methods.

class Calculator
 def add(a, b)
 validate(a)
 validate(b)
 a + b
 end
 private
 
 def validate(num)
 raise "Not a number" unless num.is_a?(Numeric)
 end
end
calc = Calculator.new
puts calc.add(5, 3)
# calc.validate(5) # This would raise NoMethodError

The validate method is private and used internally by add. It cannot be called directly on a Calculator instance.

Private Class Methods

To make class methods private, we need to use the private_class_method method or define them within a class << self block.

class Logger
 def self.log(message)
 format_message(message)
 end
 private_class_method def self.format_message(msg)
 "[#{Time.now}] #{msg}"
 end
end
puts Logger.log("Test message")
# Logger.format_message("Test") # This would raise NoMethodError

The format_message class method is private and can only be called internally by other class methods.

Private Methods in Inheritance

Private methods are inherited by subclasses but remain private. They can be called by subclass methods but not directly on instances.

class Animal
 def speak
 make_sound
 end
 private
 
 def make_sound
 "Generic animal noise"
 end
end
class Dog < Animal
 def bark
 make_sound + " - Woof!"
 end
end
dog = Dog.new
puts dog.bark
# dog.make_sound # This would raise NoMethodError

The Dog class inherits the private make_sound method from Animal. It can call it internally but not expose it directly.

Private Methods with send

Ruby's send method can bypass private method restrictions. This should be used cautiously as it breaks encapsulation.

class Secret
 private
 
 def hidden_method
 "Top secret information"
 end
end
secret = Secret.new
# puts secret.hidden_method # Would raise NoMethodError
puts secret.send(:hidden_method)

While send can access private methods, this is generally considered bad practice. It should only be used in special cases like testing.

Private Methods in Modules

Modules can define private methods that become private when included in classes. This is useful for creating reusable private functionality.

module Validations
 def validate_presence(value)
 raise "Cannot be blank" if value.nil? || value.empty?
 end
 private :validate_presence
end
class User
 include Validations
 
 def save(name)
 validate_presence(name)
 puts "User saved"
 end
end
user = User.new
user.save("John")
# user.validate_presence("") # This would raise NoMethodError

The validate_presence method is private in the module and remains private when included in the User class.

Private Setter Methods

Setter methods (ending with =) must be explicitly made private since they can't be called without a receiver by default.

class BankAccount
 def initialize(balance)
 self.balance = balance
 end
 def deposit(amount)
 self.balance += amount
 end
 private
 
 attr_reader :balance
 attr_writer :balance
end
account = BankAccount.new(100)
account.deposit(50)
# account.balance = 200 # This would raise NoMethodError

The balance setter is made private while still being usable within the class. The reader is also private to fully encapsulate the balance attribute.

Source

Ruby Visibility Documentation

This tutorial covered Ruby's private methods with practical examples showing their usage in classes, modules, inheritance, and special cases.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.