• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
The Ruby Object Model by Rafael Magana
 

The Ruby Object Model by Rafael Magana

on

  • 3,345 views

Explanation of how Ruby implements OOP.

Explanation of how Ruby implements OOP.

Statistics

Views

Total Views
3,345
Views on SlideShare
3,345
Embed Views
0

Actions

Likes
8
Downloads
113
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

CC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    The Ruby Object Model by Rafael Magana The Ruby Object Model by Rafael Magana Presentation Transcript

    • 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 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
    • 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 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
    • 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
    • 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
    • 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 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
    • 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 file 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 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
    • 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 definition 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 find 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-specific singleton classes Object message value = “” String klass = String super = Object 18
    • Ruby Methods - object methods object-specific singleton classes Object String super = Object message Singleton value = “” super = String klass = Singleton methods: /, first 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 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
    • The End raf.magana@gmail.com 24