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.

basic_private.rb

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.

private_convention.rb

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.

private_class.rb

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.

inheritance.rb

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.

private_send.rb

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_private.rb

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.

private_setter.rb

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.

Ebooks