You specify access levels to methods within class or module
definitions using one or more of the three functions
public
,
protected
, and
private
. Each function can be used in two
different ways.
If used with no arguments, the three functions set the default access
control of subsequently defined methods. This is probably familiar
behavior if you're a C++ or Java programmer, where you'd use keywords
such as
public
to achieve the same effect.
class MyClass
def method1 # default is 'public'
#...
end
protected # subsequent methods will be 'protected'
def method2 # will be 'protected'
#...
end
private # subsequent methods will be 'private'
def method3 # will be 'private'
#...
end
public # subsequent methods will be 'public'
def method4 # and this will be 'public'
#...
end
end
|
Alternatively, you can set access levels of named methods by listing
them as arguments to the access control functions.
class MyClass
def method1
end
# ... and so on
public :method1, :method4
protected :method2
private :method3
end
|
A class's
initialize
method is automatically declared
to be private.
It's time for some examples. Perhaps we're modeling an accounting
system where every debit has a corresponding credit. Because we want
to ensure that no one can break this rule, we'll make the methods that
do the debits and credits private, and we'll define our external
interface in terms of transactions.
class Accounts
private
def debit(account, amount)
account.balance -= amount
end
def credit(account, amount)
account.balance += amount
end
public
#...
def transferToSavings(amount)
debit(@checking, amount)
credit(@savings, amount)
end
#...
end
|
Protected access is used when objects need to access the internal
state of other objects of the same class. For example, we may want to
allow the individual
Account
objects to compare their raw
balances, but may want to hide those balances from the rest of the
world (perhaps because we present them in a different form).
class Account
attr_reader :balance # accessor method 'balance'
protected :balance # and make it protected
def greaterBalanceThan(other)
return @balance > other.balance
end
end
|
Because the attribute
balance
is protected, it's available
only within
Account
objects.