This document provides an overview of key Ruby object-oriented programming concepts including: 1) Ruby objects consist of a reference to their class, instance variables, and flags. Ruby classes are also objects that consist of a reference to their superclass, instance variables, methods, and flags. 2) Classes inherit behavior from other classes and encapsulate an object's state within instance variables and methods. Polymorphism allows different objects to respond to the same message. 3) Modules are used as namespaces and mixins to enhance classes. The Kernel module mixes instance methods into Object to define core functionality for all objects. 4) Ruby uses various variable types including instance variables (@), class variables (@@), local

1. 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

2. What you will find in this presentation
OOP concepts
Definition of object
Ruby Objects
Ruby Classes
Objects and classes interaction
Ruby Modules
Ruby and Meta-programming
Ruby Variables
Ruby Methods
The Top Level
2

3. 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

4. Object? what is that?
The OOP definition: 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

5. 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 flags: Singleton, Mark, Finalize, Taint, Exivar, Freeze, etc.
5

6. 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 flags: 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

7. 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

8. 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 flag 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

9. 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

10. 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

11. Ruby Modules
As a namespace As a Mixin
Kernel#require
loads an external file
Module#include
Module#append_features
it makes a reference from
the class to the included
module
11

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

13. 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

14. 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 definition
14

15. 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

16. 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 find methods.
AccessorsStudy.read_class_iv
AccessorsStudy -----> [<AccessorsStudy>]
16

17. 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

18. Ruby Methods - object methods
object-specific singleton classes
Object
message
value = “”
String
klass = String super = Object
18

19. Ruby Methods - object methods
object-specific singleton classes
Object
String
super = Object
message Singleton
value = “” super = String
klass = Singleton methods: /, first
19

20. 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

21. 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

22. 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

23. 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 define at the top level is
stored as a private instance method of the
Object class.
Methods defined in Object are visible to all
objects
23

24. The End
raf.magana@gmail.com
24