Method visibility controls how methods can be accessed in Ruby. Understanding public, private, and protected methods is essential for proper object-oriented design and encapsulation.
Understanding Method Visibility
Method Visibility: Controls who can call a method. Ruby has three levels: public (default), private, and protected.
Basic Example
# Method visibility example
class
BankAccount
def initialize(balance)
@balance = balance
end
# Public methods (default)
def deposit(amount)
@balance += amount
end
def withdraw(amount)
@balance -= amount
end
private
# Private methods
def validate_amount(amount)
amount > 0
end
protected
# Protected methods
def balance
@balance
end
end
Public: Can be called from anywhere (default)
Private: Can only be called from within the same object
Protected: Can be called from the same class or subclasses
Public Methods
Public Methods: The default visibility. Can be called from anywhere - outside the class, from subclasses, or from within the class itself.
Public Method Examples
# Public methods are accessible from anywhere
class
Calculator
# These are public by default
def add(a, b)
a + b
end
def subtract(a, b)
a - b
end
public
# Explicitly declare public (optional)
def multiply(a, b)
a * b
end
end
# Usage - can call from outside the class
calc = Calculator.new
puts calc.add(5, 3)
# 8
puts calc.multiply(4, 6)
# 24
Key Points:
Public is the default visibility for all methods
Can be called from anywhere - outside the class, subclasses, or within the class
Use public keyword to explicitly declare (optional)
Most interface methods should be public
Private Methods
Private Methods: Can only be called from within the same object. Cannot be called with an explicit receiver (no dot notation from outside).
Cannot be called with explicit receiver (no object.private_method)
Can only be called from within the same object
Use for internal implementation details and helper methods
All methods after private keyword become private
Protected Methods
Protected Methods: Can be called from the same class or its subclasses. Cannot be called from outside the class hierarchy.
Protected Method Examples
# Protected methods - accessible within class hierarchy
class
Animal
def initialize(name, age)
@name = name
@age = age
end
def compare_age(other_animal)
if age > other_animal.age
# Can access protected method
"\#{@name} is older than \#{other_animal.name}"
else
"\#{@name} is younger than \#{other_animal.name}"
end
end
protected
def age
@age
end
end
class
Dog
< Animal
def dog_years
age * 7
# Can access protected method from parent
end
end
# Usage
cat = Animal.new("Whiskers", 3)
dog = Dog.new("Buddy", 2)
puts cat.compare_age(dog)
# "Whiskers is older than Buddy"
puts dog.dog_years
# 14
# puts cat.age
# Error! Protected method
Key Points:
Can be called from the same class or its subclasses
Cannot be called from outside the class hierarchy
Useful for methods that subclasses need but shouldn't be public
Less commonly used than public and private
Advanced Visibility Patterns
Advanced Patterns: Ruby provides flexible ways to control method visibility including selective visibility changes, module inclusion, and dynamic visibility control.
Selective Visibility Changes
# Selective visibility changes
class
AdvancedCalculator
defadd(a, b)
a + b
end
defsubtract(a, b)
a - b
end
defmultiply(a, b)
a * b
end
defdivide(a, b)
a / b
end
# Make only specific methods private
private
:divide
# Make specific methods protected
protected
:multiply
end
calc = AdvancedCalculator.new
puts calc.add(5, 3)
# 8 (public)
puts calc.subtract(5, 3)
# 2 (public)
# puts calc.multiply(5, 3)
# NoMethodError (protected)
# puts calc.divide(10, 2)
# NoMethodError (private)
Module Inclusion & Visibility
# Module with different visibility levels
module
Logging
deflog_info(message)
puts"[INFO] \#{message}"
end
deflog_error(message)
puts"[ERROR] \#{message}"
end
private
defformat_timestamp
Time.now.strftime("%Y-%m-%d %H:%M:%S")
end
end
class
UserService
include Logging
defcreate_user(name)
log_info("Creating user: \#{name}")
# User creation logic
log_info("User created successfully")
end
end
service = UserService.new
service.create_user("Alice")
# Uses public logging methods
# service.format_timestamp
# NoMethodError (private from module)
Interactive Practice: Method Visibility
Practice Exercise
# Complete this class with proper method visibility
class
BankAccount
def initialize(account_number, initial_balance)
@account_number = account_number
@balance = initial_balance
end
# Public methods - interface for external use
def deposit(amount)
# TODO: Add validation and update balance
end
def withdraw(amount)
# TODO: Add validation and update balance
end
def balance
# TODO: Return formatted balance
end
# TODO: Add private methods for validation
# TODO: Add protected methods for account comparison
end
Challenge: Implement the BankAccount class with proper method visibility. Make validation methods private and comparison methods protected.
Best Practices & Common Pitfalls
✅ Best Practices
Keep the public interface minimal and focused
Use private for internal implementation details
Use protected sparingly - only when subclasses need access
Group methods by visibility for better readability
Document public methods thoroughly
Use descriptive names for private methods
❌ Common Pitfalls
Making everything public (breaks encapsulation)
Using protected when private would suffice
Forgetting that private methods can't use explicit receivers
Not grouping methods by visibility
Making internal methods public for testing
Overusing private methods (can make code hard to test)
Method Visibility Mastery Summary
You've Mastered Method Visibility!
Public Methods
Default visibility, accessible from anywhere
Private Methods
Internal implementation, same object only
Protected Methods
Class hierarchy access, subclasses included
Method visibility is essential for proper object-oriented design. Use it to create clean, maintainable interfaces while protecting internal implementation details.
