Information Hiding in Ruby
1.Need-to-Know Basis
Ruby allows you to explicitly make some methods
public and others
private. Public methods allow for an
interface with the rest of the program; they say, "Hey! Ask me if you need to know something about my class or its instances."
Private methods, on the other hand, are for your classes to do their
own work undisturbed. They don't want anyone asking them anything, so
they make themselves unreachable!
3.Going Public
Methods are public by default in Ruby, so if you don't specify
public or
private,
your methods will be public. In this case, however, we want to make it
clear to people reading our code which methods are public. We do this by
putting
public before our method definitions, like so:
class ClassName
public
def public_method
end
end
Note that everything after the
public keyword through the
end of the class definition will now be public unless we say otherwise.For now, let's add a
public method called
bark to
Dog. The
bark method should
puts "Woof!".
class Dog
def initialize(name,breed)
@name = name
@breed = breed
end
public
def bark
puts "Woof!"
end
end
4.Private! Keep Out!
Add a
private method called
id to
Dog. The
id method should create an
@id_number instance variable and set it equal to
12345.
private
def id
@id_number = 12345
end
5.attr_reader, attr_writer
Ruby needs methods in order to access attributes. For instance, if we want to access a
@name instance variable, we had to write something like
def name
@name
end
Well, no longer! We can use
attr_reader to access a variable and
attr_writer to change it. If we write
class Person
attr_reader :name
attr_writer :name
def initialize(name)
@name = name
end
end
Ruby does something like this for us automatically:
def name
@name
end
def name=(value)
@name = value
end
Like magic, we can read and write variables as we please! We just pass our instance variables (as symbols) to
attr_reader or
attr_writer.
(That
name= might look funny, but you're allowed to put an
= sign in a method name. That's just a Ruby convention saying, "hey, this method sets a value!")
class Person
def initialize(name, job)
@name = name
@job = job
end
def name
@name
end
def job=(new_job)
@job = new_job
end
end
We've brought back our
Person class with a method for getting
@name and a method for changing his or her
@job. Go ahead and remove the
name and
job= methods and add an
attr_reader for
:name and an
attr_writer for
:job.
class Person
def initialize(name, job)
@name = name
@job = job
end
attr_reader :name
attr_writer :job
end
If we want to both read and write a particular variable, there's an even shorter shortcut than using attr_reader and attr_writer. We can use attr_accessor to make a variable readable and writeable in one fell swoop.
Here we have an
attr_reader and an
attr_writer for
:job. Go ahead and replace these with an
attr_accessor!
attr_accessor :job
Introduction to Modules
7.What's a Module?
You can think of a module as a toolbox
that contains a set methods and constants. There are lots and lots of
Ruby tools you might want to use, but it would clutter the interpreter
to keep them around all the time. For that reason, we keep a bunch of
them in modules and only pull in those module toolboxes when we need the
constants and methods inside!
You can think of modules as being very much like classes, only
modules can't create instances and can't have subclasses. They're just
used to store things!
module Circle
PI = 3.141592653589793
def Circle.area(radius)
PI * radius**2
end
def Circle.circumference(radius)
2 * PI * radius
end
end
8.Module Syntax
module ModuleName
end
Like class names, module names are written in CapitalizedCamelCase, rather than lowercase
withunderscores.
It doesn't make sense to include variables in modules, since
variables (by definition) change (or vary). Constants, however, are
supposed to always stay the same, so including helpful constants in
modules is a great idea.
Ruby doesn't
make you keep the same value for a constant
once it's initialized, but it will warn you if you try to change it.
Ruby constants are written in ALL_CAPS and are separated with
underscores if there's more than one word.
An example of a Ruby constant is
PI, which lives in the
Math module and is approximately equal to 3.141592653589793.
Create your own module called
MyLibrary in the editor to the right. Include a constant called
FAVE_BOOK and set it equal to a string naming your favorite book!
module MyLibrary
FAVE_BOOK = "Harry Potter"
end
9.Resolve to Keep Learning
One of the main purposes of modules is to separate
methods and constants into named spaces. This is called (conveniently
enough)
namespacing, and it's how Ruby doesn't confuse
Math::PI and
Circle::PI.
See that double colon we just used? That's called the
scope resolution operator, which is a fancy way of saying it tells Ruby
where you're looking for a specific bit of code. If we say
Math::PI, Ruby knows to look inside the
Math module to get that
PI, not any other
PI (such as the one we created in
Circle).
Use the scope resolution operator to
puts the value of
PI from the
Math module to the console.
puts Math::PI
10.A Few Requirements
Some modules, like
Math, are already present in the interpreter. Others need to be explicitly brought in, however, and we can do this using
require. We can do this simply by typing
require 'module'
We want to use the Ruby
Date module to show today's date, but we haven't
required it yet!
require 'date'
puts Date.today
We can do more than just require a module, however. We can also include it!
Any class that includes a certain module can use those module's methods!
A nice effect of this is that you no longer have to prepend your
constants and methods with the module name. Since everything has been
pulled in, you can simply write PI instead of Math::PI.
class Angle
include Math
attr_accessor :radians
def initialize(radians)
@radians = radians
end
def cosine
cos(@radians)
end
end
acute = Angle.new(1)
acute.cosine
Fixin' for a Mixin
12.The Marriage of Modules and Classes
When a module is used to mix additional behavior and information into a class, it's called a
mixin. Mixins allow us to customize a class without having to rewrite code!
module Action
def jump
@distance = rand(4) + 2
puts "I jumped forward #{@distance} feet!"
end
end
class Rabbit
include Action
attr_reader :name
def initialize(name)
@name = name
end
end
class Cricket
include Action
attr_reader :name
def initialize(name)
@name = name
end
end
peter = Rabbit.new("Peter")
jiminy = Cricket.new("Jiminy")
peter.jump
jiminy.jump
13.Imitating Multiple Inheritance
Now you understand why we said mixins could give us the ability to mimic
inheriting from more than one class: by mixing in traits from various
modules as needed, we can add any combination of behaviors to our
classes we like!
Whereas include mixes a module's methods in at the instance level (allowing instances of a particular class to use the methods), the extend keyword mixes a module's methods at the class level. This means that class itself can use the methods, as opposed to instances of the class.
# ThePresent has a .now method that we'll extend to TheHereAnd
module ThePresent
def now
puts "It's #{Time.new.hour > 12 ? Time.new.hour - 12 : Time.new.hour}:#{Time.new.min} #{Time.new.hour > 12 ? 'PM' : 'AM'} (GMT)."
end
end
class TheHereAnd
extend ThePresent
end
TheHereAnd.now
Project
1.What You'll Be Building
In this case, we'll be making an
Account
object with public methods to display balances and transfer funds, but
which rely on private methods to make sure the user's PIN (personal
identification number) is correct before approving transactions.
2.Creating the Account Class
def initialize(name, balance=100)
@name = name
@balance = balance
What's that
balance=100 doing? It's signifying an
optional parameter. Ruby is saying that you can pass one
or two arguments to
initialize; if you pass two, it uses your
balance argument to set
@balance; if you only pass a
name,
balance gets a default value of
100, and that's what gets stored in
@balance.
You probably also noticed we used underscores in our
1_000_000 (one million). Ruby allows this, and it makes it easier to read big numbers!Create an
Account class in the editor. The
:name and
:balance attributes should be readable (but not writeable!). The class'
initialize method should take two parameters,
name and
balance, and the
balance parameter should default to
100.
Finally, go ahead and store your parameters in instance variables
@name and
@balance, respectively.
class Account
attr_reader :name
attr_reader :balance
def initialize(name,balance=100)
@name = name
@balance = balance
end
end
3.Private Affairs
Add two private methods to your Account class, pin and pin_error.
pin should take no arguments and set an instance variable, @pin, equal to the PIN number 1234.
pin_error should take no arguments and should simply return the string "Access denied: incorrect PIN."
class Account
attr_reader :name
attr_reader :balance
def initialize(name,balance=100)
@name = name
@balance = balance
end
private
def pin
@pin = 1234
end
private
def pin_error
return "Access denied: incorrect PIN."
end
end
4.Displaying the Balance
- Define a public
display_balance method to your Account class. It should take a single parameter, pin_number.
- The body of your method should check whether the
pin_number is equal to pin (the result of calling the private pin method)
- If it is,
display_balance should puts "Balance: $#{@balance}."
- Otherwise (
else), it should puts pin_error (the pin_error message)
public
def display_balance(pin_number)
if pin_number == pin.call
puts "Balance: $#{@balance}."
else
puts pin_error
end
end
Add a public
withdraw method to your class that takes two parameters,
pin_number and
amount. If
pin_number matches
pin, your method should subtract the amount from the balance and
puts "Withdrew #{amount}. New balance: $#{@balance}." Otherwise, it should
puts pin_error.
public
def withdraw(pin_number,amount)
if pin_number == pin
@balance -= amount
puts "Withdrew #{amount}. New balance: $#{@balance}."
else
puts pin_error
end
end
6.Opening an Account
Last step: create an instance of your
Account class called
checking_account. Give it whatever name and starting balance you like!
checking_account = Account.new("Becky",123)
