w2d2

Question 1

Say we want to have a subclass/child class overwrite a method of the superclass/parent class. How can this be accomplished?

Answer 1

Use the ‘super’ function to reference the parent’s version:

def initialize(first_name, last_name, super_powers)
super(first_name, last_name)
@super_powers = super_powers
end

Question 2

When is it a good idea for classes to use inheritance?

Answer 2

The more two classes have in common, the more it pays for them to share a single base class.

Question 3

What are the two ways in which we can call ‘super’

Answer 3

Using the ‘super’ keyword without arguments will implicitly pass any arguments given to the child version of the function to parent version of the function. Including arguments will only pass those arguments to the parent version of the function.

Question 4

What is the basic syntax to raise an error?

Answer 4

raise “message”

Question 5

How do we raise a specific kind of error?

Answer 5

raise ErrorClass.new “message”

Question 6

What does a method do when an exception is raised?

Answer 6

Unless it is handled, the exception is thrown and the execution of the method stops.

Question 7

When an exception is raised, how do we stop it from being thrown?

Answer 7

Catch it.

Question 8

Explain the following code:

 begin
      sqrt(num)
    rescue ArgumentError => e
      puts "Couldn't take the square root of #{num}"
      puts "Error was: #{e.message}"
    end

Answer 8

First, the sqrt method is run with the variable ‘num’.

Then, an ArgumentError is anticipated with the keyword ‘rescue’. If one is raised then it is saved in the variable ‘e’. We can then retrieve its message and send it to the user without crashing the method execution by retrieving ‘e.message’.

Question 9

Describe what happens when a method raises an unhandled exception.

Answer 9

The exception “bubbles up” the call stack, with each stack frame having a change to handle (rescue/catch are synonyms) the exception, and if ultimately unhanded the exception is printed to the user and the program exits.

Question 10

When would we use the ‘ensure’ keyword, and how do we use it?

Answer 10

It is used to execute important code that must be run even if an exception is raised. It is used with a begin-rescue block:

begin
a_dangerous_operation
rescue StandardError => e
puts “Something went wrong: #{e.message}”
ensure
puts “No matter what, make sure to execute this!”
end

Question 11

Give one example of using the ‘ensure’ keyword appropriately.

Answer 11

f = File.open
begin
  f << a_dangerous_operation
ensure
  # must. close. file.
  f.close
end

Question 12

What does the ‘retry’ keyword do, and how is it used?

Answer 12

It causes Ruby to loop the begin-rescue block until an exception is no longer raised. It is placed at the end of a rescue statement:

def echo_name # this method uses an implicit begin block
  fname, lname = prompt_name

  puts "Hello #{fname} of #{lname}"
rescue
  puts "Please only use two names."
  retry
end

Question 13

How can we make an implicit begin statement?

Answer 13

Use a return statement without a corresponding begin statement; this will place the begin statement at the start of the method.

Question 14

What is the exception used for generic errors?

Answer 14

RuntimeError

Question 15

What is the exception used to signal that an argument to a method is invalid?

Answer 15

ArgumentError

Question 16

What is a way to create custom errors?

Answer 16

Have them inherit from StandardError:

class EngineStalledError < StandardError
end

Question 17

When would you use more than one rescue statement in a begin-rescue block?

Answer 17

When you anticipate different exceptions may arise under different circumstances:

begin
  drive_car
rescue EngineStalledError => e
  puts "Rescued from engine stalled!"
rescue CollisionOccurredError => e
  puts "Rescued from collision!"
ensure
  puts "Car stopped."
end

Question 18

What does “hardened” code refer to?

Answer 18

Code that has been proofed to handle all possible exceptions, and ensure that execution continues in spite of these exceptions.

Question 19

T/F: You should try to harden code as you write it.

Answer 19

F; It is inefficient and impossible to anticipate all things that can go wrong in a program, so you should write the program first and then go back and error-proof it. Remember YAGNI!

Question 20

What is the difference between an object’s state and its behavior?

Answer 20

Its state is its data (IVs), and its behavior is what it can do (methods)

Question 21

What is a rule of thumb when decomposing a problem into objects?

Answer 21

Each object should only do 1 thing, at the level of abstraction where you would like to make changes.

Question 22

What is the approximate threshold where a class becomes large and unwieldy?

Answer 22

> 125 lines

Question 23

When should you introduce inheritance from a base class?

Answer 23

When your code needs it to keep different classes DRY.

Question 24

Why does inheriting from a base class make other methods more useful?

Answer 24

If they inherit from the same base class, they can use that base class’s API to interface with the same methods as another class which inherits from that base class.

Question 25

T/F: Instance variables are always private by default.

Answer 25

T; they can be made public with methods or attr_accessor

Question 26

When should a method be made private?

Answer 26

When the caller runs the risk of tampering with the object in a dangerous way, or to abstract the caller from unnecessary low-level details.

Question 27

When thinking about program maintenance, why is keeping a limited API (many private methods) important?

Answer 27

The more objects that rely on another’s methods, the greater the likelihood of multiple points of failure; what you expose will be that much harder to change later.

Question 28

What is a good principle of OO design relating to privacy?

Answer 28

Minimize the interfaces between your classes; expose the least possible amount of state and behavior, and have a good reason for every piece of information that you expose.

Question 29

ALGORITHM FOR DEEP DUPING AN ARRAY!

Answer 29

def dd_map 
     map { |el| el.is_a?(Array) ? el.dd_map : el } 
   end