By the end of this, developers should be able to:
- Diagram the Ruby method lookup chain
- Write a class which inherits from another class.
- Fork and clone this repository.
- Install dependencies with
bundle install
. - Create a
training
branch and checkout to it.
In Ruby, we have classes instead of prototypes. We attach methods to the class since Ruby doesn't use prototypes. Ruby will be our first example of linking different objects together in a hierarchy. This process is called "inheritance" and the result is what we mean when we say an object "inherits" behavior from another object.
Some objects can be classified in multiple ways. These multiple classifications
often make sense as a hierarchy. For example, a Dog
is a kind of Pet
. It's
also a kind of Animal
. In Ruby, we can share code (data or behavior) between
two classes using inheritance. Let's look at an example of inheritance. Note
that a Ruby class can only inherit from one other class, so whether you name
that class Pet
or Animal
will depend on your application.
class Animal
def eat
puts "Nom nom nom"
end
end
class Dog < Animal
end
dog = Dog.new
dog.eat #=> "Nom nom nom"
class Dog < Animal
def speak
puts "WOOF"
end
def eat
puts "Slop slop slop"
end
end
dog.speak #=> "WOOF"
dog.eat #=> "Slop slop slop"
animal = Animal.new
animal.eat #=> "Nom nom nom"
animal.speak #=> NoMethodError
class Animal
def move
"I can move"
end
end
class Bird < Animal
def move
super + " by flying"
end
end
puts Animal.new.move
puts Bird.new.move
This will print out:
I can move
I can move by flying
Super
will call the same method defined in the parent
or superclass
and
give you the result.
In Ruby, method lookup occurs through classes. In JavaScript, method lookup
occurs through inspecting the .prototype
property on constructor functions.
Let's draw the method lookup chain, first through prototypes in JavaScript, and then through classes in Ruby.
Please diagram the method lookup chain using the following requirements:
- The class
DenverBroncos
has an instance method calledlose
. DenverBroncos
inherits from the classFootballTeam
.- The class
FootballTeam
has an instance method calledplay_game
. - Diagram creating a new instance of the
DenverBroncos
:broncos_2015 = DenverBroncos.new
. - Diagram how Ruby finds and executes the methods called on
broncos_2015
:broncos_2015.lose
andbroncos_2015.play_game
.
In a previous
lab,
you were asked to create and use a Shape
class.
A Rectangle
is a Shape
, and a Square
is a Rectangle
.
Create a Rectangle
in lib/rectangle.rb
that inherits
from Shape
. You will need to override the constructor method inside Rectangle
to take two sides of different lengths. Since all rectangles have four sides,
you can set a default value for @sides
inside Rectangle
's constructor.
Test your code with bin/rake test
.
Requirements for Rectangle
s:
- Rectangles should be instantiated with
Rectangle.new(3, 4)
to create a rectangle with a length of 3 and a width of 4. - Instances of Rectangle should respond to the
#calculate_area
method and give the correct result. - Do not override anything that doesn't need to be overriden.
Next, create a Square
class in lib/square.rb
that inherits
from Rectangle
.
Requirements for Square
s:
- Squares should be instantiated with
Square.new(4)
to create a square with all sides equal to 4. - Instances of Square should respond to the
#calculate_area
method and give the correct result. - Do not override anything that doesn't need to be overriden.
- All content is licensed under a CCBYNCSA 4.0 license.
- All software code is licensed under GNU GPLv3. For commercial use or alternative licensing, please contact legal@ga.co.