Notes and Quotes

Question 1

The value returned by a Ruby method is the value of the last expression evaluated, so we can get rid of the temporary variable and the return statement altogether

Answer 1

Example 1:

def say_goodnight(name)
result = "Good night, #{name.capitalize}" return result
end
puts say_goodnight('uncle')
produces:
Good night, Uncle

Example 2:

def say_goodnight(name)
"Good night, #{name.capitalize}"
end
puts say_goodnight('ma')
produces:
Good night, Ma

Question 2

nil

Answer 2

In many languages, the concept of nil (or null) means “no object.” In Ruby, that’s not the case; nil is an object, just like any other, that happens to represent nothing.

Question 3

Optimal way to create an array of words

Answer 3

a = %w{ ant bee cat dog elk }

Question 4

Where do objects come from?

Answer 4

Every object in Ruby was generated either directly or indirectly from a class

Question 5

Understanding Attributes

Answer 5

That state is private (instance variables used to create initialize objects) to those objects—no other object can access an object’s instance variables. In general, this is a Good Thing. It means that the object is solely responsible for maintaining its own consistency.

However, an object that is totally secretive is pretty useless—you can create it, but then you can’t do anything with it. You’ll normally define methods that let you access and manipulate the state of an object, allowing the outside world to interact with the object. These externally visible facets of an object are called its attributes.

Question 6

Accessor Method (reader - long way)

Answer 6

We used accessor methods to access the attributes of our objects (remember, the instance variables can’t be accessed by other objects).

def isbn
@isbn
end

This accessor method returns the value of the instance variable because it’s the last thing evaluated.

This type of accessor method allows you to READ the attribute, but not write to it.

Question 7

Accessor Reader Method (short way)

Answer 7

attr_reader: :isbn, :price

This is the same as writing:

def isbn
@isbn
end

def price
@price
end

Question 8

Accessor Method (writer - long way)

Answer 8

Sometime, your instance variables need have the ability to be set from outside of the object. In this case, it needs to be able to be written to.

You do that by creating a method who name ends in an equal sign.

Example:

def price=(new_price)
@price = new_price
end

So you can follow the structure, this is till just a method that takes a variable. Similar to these constructs.

variable(new_price)
variable!(new_price)
variable?(new_price)

This method just happens to end with an equal sign.

variable=(new_price)

Inside the method, it sets the attribute to the input. Simple Reassignment.

book = BookInStock.new(“isbn1”, 33.80) puts “ISBN = #{book.isbn}”
puts “Price = #{book.price}” book.price = book.price * 0.75
puts “New price = #{book.price}”
produces:
ISBN = isbn1 Price = 33.8 New price = 25.35

Question 9

Accessor Method (writer - short way)

Answer 9

attr_writer :isbn,

This is the same as:

def isbn=(updated_isbn)
@isbn = updated_isbn
end

Question 10

Atrribute Accessor (both read and write)

Answer 10

attr_accessor :isbn, :price

Question 11

Failing to make attributes accessible, reading or writing:

Answer 11

If you fail to make your instance variable readable, you will get an error similar to this:

Test.rb:12:in ': undefined method name’ for # (NoMethodError)

Question 12

What is a virtual attribute?

Answer 12

A virtual attribute is a derivative of the original attribute. It will be defined as a getter and setter and will change the original attribute.

Example:

class BookInStock attr_reader :isbn attr_accessor :price
def initialize(isbn, price)
@isbn = isbn
@price = Float(price) end
def price_in_cents Integer(price*100 + 0.5)
end
def price_in_cents=(cents)
@price = cents / 100.0 end
# ... end

book = BookInStock.new(“isbn1”, 33.80)
puts “Price = #{book.price}”
puts “Price in cents = #{book.price_in_cents}” book.price_in_cents = 1234

puts “Price = #{book.price}”
puts “Price in cents = #{book.price_in_cents}”
produces:
Price = 33.8 Price in cents = 3380 Price = 12.34 Price in cents = 1234

Question 13

Uniform Access Principle (unfinished)

Answer 13

This is more than a curiosity. In his landmark book Object-Oriented Software Construc- tion [Mey97], Bertrand Meyer calls this the Uniform Access Principle. By hiding the dif- ference between instance variables and calculated values, you are shielding the rest of the world from the implementation of your class. You’re free to change how things work in the future without impacting the millions of lines of code that use your class. This is a big win.

Question 14

require_relative

Answer 14

Require relative is used to load in a file where the location is in the same directory.

This is an example of requiring and external library and internal file:

Example:

require ‘csv’
require_relative ‘book_in_stock’

Question 15

When will you get an error for access control (restricted methods)?

Answer 15

Access control is deter- mined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.

Question 16

How do you set access control for entire groups of methods?

Answer 16

class MyClass
      def method1
#... end
  protected
      def method2
#... end
  private
      def method3
#... end
  public
      def method4
#... end
# default is 'public'
# subsequent methods will be 'protected' # will be 'protected'
# subsequent methods will be 'private' # will be 'private'
# subsequent methods will be 'public' # so this will be 'public'
end

Question 17

How do you set access control for individual methods

Answer 17

class MyClass
def method1
end
# ... and so on
public :method1, :method4 protected :method2
      private   :method3
    end

Question 18

Read over this example of when to use access control - a bank.

Answer 18

In this case, we are dealing with accounting for a bank. The transaction dictates what happens to debit or credit section. The debit or credit section can’t be set themselves.

class Account
attr_accessor :balance def initialize(balance)
          @balance = balance
        end
    end
    class Transaction
def initialize(account_a, account_b) @account_a = account_a
@account_b = account_b
end private
def debit(account, amount) account.balance -= amount
end
def credit(account, amount)
account.balance += amount end
public #...
def transfer(amount) debit(@account_a, amount) credit(@account_b, amount)
end
#... end
savings = Account.new(100)
checking = Account.new(200)
trans = Transaction.new(checking, savings) trans.transfer(50)

Question 19

Example of Protected

Answer 19

class Account
attr_reader :cleared_balance # accessor method ‘cleared_balance’ protected :cleared_balance # and make it protected
def greater_balance_than(other)
return @cleared_balance > other.cleared_balance end
end
Because cleared_balance is protected, it’s available only within Account objects.

Question 20

Arrays and hashes. Mastery of these two classes is key to being an effective Ruby programmer.

Answer 20

Arrays and hashes. Mastery of these two classes is key to being an effective Ruby programmer.

Question 21

Where does a class get it’s characteristics?

Answer 21

If you don’t define an explicit superclass when defining a class, Ruby automatically makes the built-in class Object that class’s parent.

class Parent
end

puts “The superclass of Parent is #{Parent.superclass}”

produces:

The superclass of Parent is Object

Further:

puts “The superclass of Object is #{Object.superclass}”

produces:

The superclass of Object is BasicObject

Even further:

puts “The superclass of BasicObject is #{BasicObject.superclass.inspect}”

produces:

The superclass of BasicObject is nil

Question 22

What are the two main benefits of modules?

Answer 22

Modules provide a namespace and prevent name clashes.

Modules support the mixin (a mixin is like a partial class definition) facility. This provides a controlled multiple-inheritance-like capability with none of the drawbacks.

Question 23

How do you bring in a module?

Answer 23

Load in the modules in the new file.

Example:

File 1:

module Trig
      PI = 3.141592654
      def Trig.sin(x)
# .. end
      def Trig.cos(x)
       # ..
end

File 2:

module Moral
VERY_BAD = 0
BAD =1
def Moral.sin(badness)
# ... end
end

File 3:

require ‘trig’
require ‘moral’

Question 24

Mixin Hierarchy

Answer 24

If a class has multiple modules mixed in, the last one included is searched first.

Question 25

are blocks objects?

Answer 25

No.

Because of this, blocks can’t be saved to variables and don’t have all the powers and abilities of a real object.

Question 26

ending a line in ruby

Answer 26

if you want to end a Ruby statement without going to a new line, you can just type a semicolon. This means you can write something like:

class Monkey; end