The Ruby Object Model by Rafael Magana

Ruby
The (good) compulsive obsession for the objects
(or the object of obsession)

An introduction to the Ruby Object Model

raf.magana@gmail.com
1

What you will ﬁnd in this presentation
OOP concepts
Deﬁnition of object
Ruby Objects
Ruby Classes
Objects and classes interaction
Ruby Modules
Ruby and Meta-programming
Ruby Variables
Ruby Methods
The Top Level
2

OOP concepts
Inheritance
It allows a class to have the same behavior as another class
Ruby uses < (less than) for inheritance: class Human < Mammal
The default parent class is Object
Encapsulation
To modify an object's state, one of the object's behaviors must be used
In “my_object.something”, “something” must be a method, not a variable
Polymorphism
It allows two or more objects respond to the same message
person.wake_up / computer.wake_up / animal.wake_up
3

Object? what is that?
The OOP deﬁnition: Object = state + behavior
state is described by variables (attributes)
behavior is described by methods
Every object of the same type will have its own state
All the objects of the same type will share the same behavior

4

Ruby Objects
A Ruby object consist of the following
A reference to the object immediate class (interpreter stores this in ‘klass’)
A hash table of instance variables
Objects does not have a table of methods, they are in the class.
Only classes can have methods.
A set of ﬂags: Singleton, Mark, Finalize, Taint, Exivar, Freeze, etc.

5

Ruby Classes (get ready to become insane)
A Ruby class: it’s an instance object of class Class, an consists of the following:
A reference to the object immediate class (interpreter stores this in ‘klass’)
A hash table of instance variables
A hash table of methods
A set of ﬂags: Singleton, Mark, Finalize, Taint, Exivar, Freeze, etc.
A reference to the superclass (interpreter stores it in “super”)
my_object.class denotes "instance of" (my_object = MyClass.new)
MyClass.superclass denotes "inherits from" ( MyClass < OtherClass)

In Ruby, always remember this, CLASSES ARE OBJECTS!!!

6

Ruby Classes
since classes are objects, class objects are instances of other class
“but, if classes are objects, and you just said objects doesn’t have
methods, only classes does, so what’s going on here?”, you’d say.
well, I have to say that a class isn’t really an object (x_X)
look at the following code taken from the Ruby source

but a class is still an object:
* you can store instance variables
* inherits from the Object class

7

Ruby Classes
In Ruby there are two types of classes
“Real” classes and “meta”-classes (singleton, virtual, Eigen or ghost classes)

What is the difference?
“meta”-classes are “Real” classes with a ﬂag set to ‘virtual’
a “meta”-class is created as needed and inserted in the inheritance chain before
the object "real" class and they are hidden.
What are meta-classes useful for?
If the instance methods of my_object are in MyClass and MyClass is an instance
of class Class, so it can’t have its own instance methods, then where are the
instance methods of MyClass object?
The instance methods of MyClass object are in a meta-class, a Singleton class.

8

How classes and instances interact
Every method call nominate a receiver and a message.
“my_obj.my_method”: my_obj is the receiver and my_method is the message.

my_guitar = receiver; dup/play = message Guitar = receiver; strings = message

9

Ruby modules
A Ruby module is an object that acts as a placeholder for classes,
methods and constants.
A module is like a class with 3 key differences
It isn’t a class, (but it is an object and it has instance methods),
Module is actually the superclass of Class - class Class < Module

It cannot be instantiated (you cannot do x = MyModule.new)
It can be mixed in a class to enhance its possibilities
A module can be two things
A namespace, a way to regroup similar things.
A Mixin (mixed in), they eliminate the need of multiple inheritance

10

Ruby Modules
As a namespace As a Mixin
Kernel#require

loads an external ﬁle

Module#include

Module#append_features

it makes a reference from
the class to the included
module

11

Hierarchy diagram
Kernel is a module, not a class
Object class mixes in the Kernel module
it deﬁnes the instance methods of Object
Module inherits from Object Up
Class inherits from Module
How Ruby walks hierarchy to ﬁnd methods? Up
The “Out and up” way
Out
Out = klass = object.class
Up = super = MyClass.superclass

12

Ruby Variables
Pseudo Variables (their values can’t be changed with the assignment operator)
self #execution context of the current method
nil, true and false #sole-instances of NilClass, TrueClass and FalseClass
A variable can be distinguished by the characters at the start of its name.
‘@’ = instance variable of self.
‘@@’ = class variable
^[a-z_] = local variables
^[A-Z] = constant (we can change the state of the objects they reference)
^$ = global variables

13

Ruby Variables - self
it is only a reference to the current receiver
If you omit the receiver, it defaults to self, the
current object.
self != this (other languages)
self is a pseudo-variable, but it is still a variable,
so it changes at some point, who changes the
value of self?
a method call
a class/module deﬁnition

14

Ruby Variables - @ and @@
class variables (@@)
A class variable is shared among all
instances of a class and must be initialized
before they are used.
Example.class_v
class instance variables (@)
aka instance variables (wrong)
Example.class_instance_variable
instance variables (@)
Each instance of a class has a unique set of
instance variables
Example.new.iv
15

Ruby Variables - accessors
accessors are Module methods
<< is a way to access singleton classes (meta-
classes), in this case, we’re accessing the self’s
singleton class, which means AccessorsStudy
If we send a message to AccessorsStudy class,
the Ruby Interpreter uses the “out and up” way
to ﬁnd methods.
AccessorsStudy.read_class_iv
AccessorsStudy -----> [<AccessorsStudy>]

16

Ruby Methods
Instance methods
we don’t specify the receiver, so it’s
self, which means the current instance
Class methods
They don’t even exist, they are
singleton methods, because they are in
a singleton class
In this case we have 3 singleton
methods but Ruby only creates one
singleton class, hence the name.

17

Ruby Methods - object methods
object-speciﬁc singleton classes

Object

message
value = “”
String
klass = String super = Object

18

Ruby Methods - object methods
object-speciﬁc singleton classes

Object

String
super = Object

message Singleton
value = “” super = String
klass = Singleton methods: /, ﬁrst

19

Ruby Methods - object creation
obj = Object.new
creates a blank object and calls the
initialize method
initialize method
initializes the object (variables, etc)
super
The call to super can access a
parent’s method regardless of its
visibility, that allows the subclass to
override its parent’s visibility rules
(X_o), believe it or not.

20

Ruby Methods - Access control
Ruby defines 3 levels of protection for module and class constants and
methods:
Public: accessible to anyone. Methods are public by default (except for
initialize, which is always private).
Protected: Can be invoked only by objects of the defining class and its
subclasses. Access is kept within the family.
Private: Can be called only in functional form (that is, with an implicit self
as the receiver). Private methods therefore can be called only in the
defining class and by direct descendants within the same object.
You specify access levels to methods within class or module definitions
using one or more of the three functions public, protected, and private

21

Ruby Methods - Access control
protected level:

if you want one
instance of a certain
class to do something
with another instance
of its class.

private level

you don’t want the
instances to access
some methods of its
class

public level

you want methods to
be accessed from the
outside world.
22

Last but not least - Top level
The top-level default object, main, which is an
instance of Object brought into being
automatically for the sole reason that
something has to be self, even at the top level.
A method that you deﬁne at the top level is
stored as a private instance method of the
Object class.
Methods deﬁned in Object are visible to all
objects

23

The End

raf.magana@gmail.com

24

The Ruby Object Model by Rafael Magana

More Related Content

What's hot (20)

Similar to The Ruby Object Model by Rafael Magana (20)

Recently uploaded (20)

The Ruby Object Model by Rafael Magana