There are three widely used programming paradigms there.
Procedural programming
Functional programming
Object-oriented programming.
Ruby is an object-oriented language. It has some functional and procedural
features too.
Object-oriented
programming (OOP) is
a programming paradigm that uses objects and their interactions to design
applications and computer programs.
There are some basic programming concepts in OOP:
Abstraction
Polymorphism
Encapsulation
Inheritance
The abstraction is
simplifying complex reality by modeling classes appropriate to the problem.
The
polymorphism is the process of using
an operator or function in different ways for different data input.
The encapsulation hides the implementation
details of a class from other objects.
The inheritance
is a way to form new classes using classes that have already been defined.
Objects
Objects are basic building blocks of a Ruby OOP program. An
object is a combination of data and methods. In a OOP program, we create
objects. These objects communicate together through methods.
Each object can
receive messages, send messages and process data.
There are two steps in creating an object.
First, we define a
class. A class is a template for an
object. It is a blueprint, which describes the state and behavior that the
objects of the class all share.
A class can be used to create many objects.
Objects created at runtime from a class are called instances of that particular class.
#!/usr/bin/ruby
class Being
end
b = Being.new
puts b
In our first example, we create a simple object.
class Being
end
This is a simple class definition. The body of the template
is empty. It does not have any data or methods.
b = Being.new
We create a new instance of the Being class. For this we have
the new method. The b variable stores the newly created object.
puts b
We print the object to the console to get some basic
description of the object.
What does it mean, to print an object? When we print
an object, we in fact call its to_s method. But we have not defined any method
yet. It is because every object created inherits from the base Object. It has
some elementary functionality, which is shared among all objects created. One
of this is the to_s method.
$ ./simple.rb
#<Being:0x9f3c290>
We get the object class name.
The constructor
A constructor is a special kind of a method. It is
automatically called, when the object is created. Constructors do not return
values. The purpose of the constructor is to initiate the state of an object.
The constructor in Ruby is called initialize. Constructors do not return any
values.
Constructors cannot be inherited. The constructor of a parent
object is called with a super method. They are called in the order of
inheritance.
#!/usr/bin/ruby
class Being
def initialize
puts "Being is created"
end
end
Being.new
We have a Being class.
The Being class has a constructor method called initialize.
It prints a message to the console. The definition of a Ruby method is placed
between the def and end keywords.
Being.new
An instance of the Being class is created. At the moment of
the object creation, the constructor method is called.
$ ./constructor.rb
Being is created
This is the output of the program.
Object attributes is the data bundled in an instance of a
class. The object attributes are called instance
variables or member fields. An
instance variable is a variable defined in a class, for which each object in
the class has a separate copy.
In the next example, we initiate data members of the class.
Initiation of variables is a typical job for constructors.
#!/usr/bin/ruby
class Person
def initialize name
@name = name
end
def get_name
@name
end
end
p1 = Person.new "Jane"
p2 = Person.new "Beky"
puts p1.get_name
puts p2.get_name
In the above Ruby code, we have a Person class with one member field.
class Person
def initialize name
@name = name
end
In the constructor of the Person class, we set a member field
to a value name. The name parameter is passed to the constructor at creation. A
constructor is a method called initialize that is being called at the creation
of an instance object. The @name is an instance variable. Instance variables
start with @ character in Ruby.
def get_name
@name
end
The get_name method returns the member field. In Ruby member
fields are accessible only via methods.
p1 = Person.new "Jane"
p2 = Person.new "Beky"
We create two objects of a Person class. A string parameter
is passed to each object constructor. The names are stored inside instance
variables that are unique to each object.
puts p1.get_name
puts p2.get_name
We print the member fields by calling the get_name on each of
the objects.
$ ./person.rb
Jane
Beky
We see the output of the program. Each instance of the Person
class has its own name member field.
We can create an object without calling the constructor. Ruby
has a special allocate method for this. The allocate method allocates space for
a new object of a class and does not call initialize on the new instance.
#!/usr/bin/ruby
class Being
def initialize
puts "Being created"
end
end
b1 = Being.new
b2 = Being.allocate
puts b2
In the example, we create two objects. The first object using
the new method, the second object using the allocate method.
b1 = Being.new
Here we create an instance of the object with the new
keyword. The constructor method initialize is called and the message is printed
to the console.
b2 = Being.allocate
puts b2
In case of the allocate method, the constructor is not
called. We call the to_s method with the puts keyword to show, that the object
was created.
$ ./allocate.rb
Being created
#<Being:0x8ea0044>
Output of the program.
Constructor overloading
Constructor overloading is the ability to have multiple types
of constructors in a class. This way we can create an object with different
number or different types of parameters.
Ruby has no
constructor overloading that we know from other programming languages.
This
behaviour can be simulated to some extent with default parameter values in
Ruby.
#!/usr/bin/ruby
class Person
def initialize
name="unknown", age=0
@name = name
@age = age
end
def to_s
"Name: #{@name}, Age:
#{@age}"
end
end
p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"
p p1, p2, p3, p4
This example shows how we could simulate constructor
overloading on a Person class that has two member fields. If we do not specify
the name of the person, we have "unknown" string instead. For
unspecified age we have 0.
def initialize name="unknown", age=0
@name = name
@age = age
end
The constructor takes two parameters. They have a default
value. The default value is used, if we do not specify our own values at the
object creation. Note that the order of parameters must be kept. First comes
the name, then the age.
p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"
p p1, p2, p3, p4
We create four objects. The constructors take different
number of parameters.
$ ./consover.rb
Name: unknown, Age: 0
Name: unknown, Age: 17
Name: Becky, Age: 19
Name: Robert, Age: 0
Output of the example.
Methods
Methods are functions defined inside the body of a class.
They are used to perform operations with the attributes of our objects. Methods
are essential in encapsulation
concept of the OOP paradigm. For example, we might have a connect method in our
AccessDatabase class. We need not to be informed, how exactly the method
connects to the database. We only have to know, that it is used to connect to a
database. This is essential in dividing responsibilities in programming.
Especially in large applications.
In Ruby, data is accessible only via methods.
#!/usr/bin/ruby
class Person
def initialize name
@name = name
end
def get_name
@name
end
end
per = Person.new "Jane"
puts per.get_name
puts per.send :get_name
The example shows two basic ways to call a method.
puts per.get_name
The common way is to use a dot operator on an object followed
by a method name.
puts per.send :get_name
The alternative is to use a built-in send method. It takes a
symbol of the method to be called as a parameter.
Methods typically perform some action on the data of the
object.
#!/usr/bin/ruby
class Circle
@@PI = 3.141592
def initialize
@radius = 0
end
def set_radius radius
@radius = radius
end
def area
@radius * @radius * @@PI
end
end
c = Circle.new
c.set_radius 5
puts c.area
In the code example, we have a Circle class. We define two
methods.
@@PI = 3.141592
We have defined a @@PI variable in our Circle class. It is a
class variable. Class variables start with @@ sigils in Ruby. Class variables
belong to a class, not to an object. Each object has access to its class
variables. We use the @@PI to compute the area of the circle.
def initialize
@radius = 0
end
We have one member field. It is the radius of the circle. If
we want to modify this variable from the outside, we must use the publicly
available set_radius method. The data is protected.
def set_radius radius
@radius = radius
end
This is the set_radius method. It gives the @radius instance
variable a new value.
def area
@radius * @radius * @@PI
end
The area method returns the area of a circle. This is a
typical task for a method. It works with data and produces some value for us.
c = Circle.new
c.set_radius 5
puts c.area
We create an instance of the Circle class. And set its radius
by calling the set_radius method on the object of the circle. We use the dot
operator to call the method.
$ ./circle.rb
78.5398
Running the example.
Access modifiers
Access modifiers set the visibility of methods and member
fields. Ruby has three access modifiers:
public, protected and private.
In
Ruby, all data members are private. Access modifiers can be used only on
methods.
Ruby methods are public, unless we say otherwise.
The public methods can be accessed from inside the definition
of the class as well as from the outside of the class.
The difference between
the protected and the private methods is subtle.
They both cannot be accessed
outside the definition of the class. They can be accessed only within the class
itself and by inherited or parent classes.
Note that unlike in other object-oriented programming
languages, inheritance does not play
role in Ruby access modifiers.
Only two things are important. First, if we
call the method inside or outside the class definition. Second, if we use or do
not use the self keyword which points to the current receiver.
Access modifiers protect data against accidental
modifications. They make the programs more robust. The implementation of some
methods is subject to change. These methods are good candidates for being
private. The interface that is made public to the users should only change when
really necessary. Over the years users are accustomed to using specific methods
and breaking backward compatibility is generally frowned upon.
#!/usr/bin/ruby
class Some
def method1
puts "public method1
called"
end
public
def method2
puts "public method2
called"
end
def method3
puts "public method3
called"
method1
self.method1
end
end
s = Some.new
s.method1
s.method2
s.method3
The example explains the usage of public Ruby methods.
def method1
puts "public method1
called"
end
The method1 is public, even if we did not specify the public
access modifier. It is because methods are public by default, if not specified
otherwise.
public
def method2
puts "public method2
called"
end
...
Methods following the public keyword are public.
def method3
puts "public method3 called"
method1
self.method1
end
From inside the public method3, we call other public method.
With and without the self keyword.
s = Some.new
s.method1
s.method2
s.method3
Public methods are the only methods that can be called
outside the definition of a class as shown here.
$ ./public_methods.rb
public method1 called
public method2 called
public method3 called
public method1 called
public method1 called
Running the example.
The next example looks at private methods.
#!/usr/bin/ruby
class Some
def initialize
method1
# self.method1
end
private
def method1
puts "private method1
called"
end
end
s = Some.new
# s.method1
Private methods are tightest methods in Ruby. They can be
called only inside a class definition and without the self keyword.
def initialize
method1
# self.method1
end
In the constructor of the method, we call the private
method1. Calling the method with the self is commented. Private methods cannot
be specified with a receiver.
private
def method1
puts "private method1
called"
end
Methods following the private keyword are private in Ruby.
s = Some.new
# s.method1
We create an instance of the Some class. Calling the method
outside the class definition is prohibited. If we uncomment the line, the Ruby
interpreter gives an error.
$ ./private_methods.rb
private method called
Output of the example code.
Finally, we will work with protected methods. The distinction
between the protected and the private methods in Ruby is subtle. Protected
methods are like private. There is only one small difference. They can be
called with the self keyword specified.
#!/usr/bin/ruby
class Some
def initialize
method1
self.method1
end
protected
def method1
puts "protected method1
called"
end
end
s = Some.new
# s.method1
The above example shows protected method in usage.
def initialize
method1
self.method1
end
Protected methods can be called with and without the self
keyword.
protected
def method1
puts "protected method1
called"
end
Protected methods are preceded by the protected keyword.
s = Some.new
# s.method1
Protected methods cannot be called outside the class definition.
Uncommenting the line would lead to an error.
Inheritance
The inheritance is a way to form new classes using classes
that have already been defined. The newly formed classes are called derived classes, the classes that we
derive from are called base classes.
Important benefits of inheritance are code reuse and reduction of complexity of
a program. The derived classes (descendants) override or extend the
functionality of base classes (ancestors).
#!/usr/bin/ruby
class Being
def initialize
puts "Being class created"
end
end
class Human < Being
def initialize
super
puts "Human class
created"
end
end
Being.new
Human.new
In this program, we have two classes. A base Being class and
a derived Human class. The derived class inherits from the base class.
class Human < Being
In Ruby, we use the < operator to create inheritance
relations. The Human class inherits from the Being class.
def initialize
super
puts "Human class created"
end
The super method calls the constructor of the parent class.
Being.new
Human.new
We instantiate the Being and the Human class.
$ ./inheritance.rb
Being class created
Being class created
Human class created
First the Being class is created. The derived Human class
also calls the costructor of its parent.
An Object may be involved in comlicated relationships. A
single object can have multiple ancestors. Ruby has a method ancestors which
gives a list of ancestors for a specific class.
Each Ruby object is automatically a descendant of Object,
BasicObject classes and Kernel Module. They are built-in the core of the Ruby
language.
#!/usr/bin/ruby
class Being
end
class Living < Being
end
class Mammal < Living
end
class Human < Mammal
end
p Human.ancestors
We have four classes in this example. A Human is a Mammal a
Living and a Being.
p Human.ancestors
We print the ancestors of a Human class.
$ ./ancestors.rb
[Human, Mammal, Living, Being, Object, Kernel, BasicObject]
A Human class has three custom and three built-in ancestors.
A more complex example follows.
#!/usr/bin/ruby
class Being
@@count = 0
def initialize
@@count += 1
puts "Being class
created"
end
def show_count
"There are #{@@count}
beings"
end
end
class Human < Being
def initialize
super
puts "Human is created"
end
end
class Animal < Being
def initialize
super
puts "Animal is created"
end
end
class Dog < Animal
def initialize
super
puts "Dog is created"
end
end
Human.new
d = Dog.new
puts d.show_count
We have four classes. The inheritance hierarchy is more
complicated. The Human and the Animal classes inherit from the Being class. And
the Dog class inherits directly from the Animal class and further from the
Being class. We also use a class variable to count the number of beings
created.
@@count = 0
We define a class variable. A class variable begins with @@
sigils and it belongs to the class, not to the instance of the class. We use it
to count the number of beins created.
def initialize
@@count += 1
puts "Being class created"
end
Each time the Being class is instantiated, we increase the
@@count variable by one. This way we keep track of the number of instances
created.
class Animal < Being
...
class Dog < Animal
...
The Animal inherits from the Being and the Dog inherits from
the Animal. Further, the Dog inherits from the Being as well.
Human.new
d = Dog.new
puts d.show_count
We create instances from the Human and from the Dog classes.
We call the show_count method on the Dog object. The Dog class has no such
method; the grandparent's (Being) method is called then.
$ ./inheritance2.rb
Being class created
Human is created
Being class created
Animal is created
Dog is created
There are 2 beings
The Human object calls two constructors. The Dog object calls
three constructors. There are two Beings instantiated.
Inheritance does not play role in the visibility of methods
and data members. This is a notable difference from many common object-oriented
programming languages.
In C# or Java, private data members and methods are not
inherited. Only public and protected. In contrast to this, private data members
and methods are inherited in Ruby as well. The visibility of data members and
methods is not affected by inheritance in Ruby.
#!/usr/bin/ruby
class Base
def initialize
@name = "Base"
end
private
def private_method
puts "private method
called"
end
protected
def protected_method
puts "protected_method
called"
end
public
def get_name
return @name
end
end
class Derived < Base
def public_method
private_method
protected_method
end
end
d = Derived.new
d.public_method
puts d.get_name
In the example we have two classes. The Derived class
inherits from the Base class. It inherits all three methods and one data field.
def public_method
private_method
protected_method
end
In the public_method of the Derived class we call one private
and one protected method. They were defined in the parent class.
d = Derived.new
d.public_method
puts d.get_name
We create an instance of the Derived class. We call the
public_method. And call the get_name method, which returns the private @name
variable. Remember that all instance variables are private in Ruby. The
get_name method returns the variable regardless of the fact, that it is private
and defined in the parent class.
$ ./inheritance3.rb
private method called
protected_method called
Base
The output of the example confirms that in Ruby language,
public, protected, private methods and private member fields are inherited by
child objects from their parents.
The super method
The super method calls a method of the same name in the
parent's class. If the method has no arguments it automatically passes all its
arguments. If we write super() no arguments are passed to parent's method.
#!/usr/bin/ruby
class Base
def show x=0, y=0
p "Base class, x: #{x}, y:
#{y}"
end
end
class Derived < Base
def show x, y
super
super x
super x, y
super()
end
end
d = Derived.new
d.show 3, 3
In the example, we have two classes in a hierarchy. They both
have a show method. The show method in the Derived class calls the show method
in the Base class using the super method.
def show x, y
super
super x
super x, y
super()
end
The super method without any arguments calls the parent's
show method with the arguments that were passed to the show method of the
Derived class. In our case x=3, y=3. The super() method passes no arguments to
the parent's show method.
$ ./super.rb
"Base class, x: 3, y: 3"
"Base class, x: 3, y: 0"
"Base class, x: 3, y: 3"
"Base class, x: 0, y: 0"
Output of the example.