Inheritance In Ruby On Rails

Introduction

Today, we are going to learn some interesting concepts about inheritance. You have learned this concept in other languages also. Here, you can see how it will be used and performed in the Ruby language.

Contents

Super Method

Inheritance

Inheritance is when a class receives or inherits the attributes and behavior of another class.
The class that is inheriting the behavior is called the subclass (or derived class) and the class it inherits from is called the superclass (or base class).
Imagine several classes - Cat, Dog, Rabbit, and so on.
Although they may differ in some ways (like, only Dog might have the method bark), they are likely to be similar in others (all having color and name).
This similarity can be expressed by making them all inherit from a super class Animal, which contains the shared functionality.
The < symbol is used to inherit a class from another class.

Example

Class Dog < Animal
# some code
End

In the code above, Dog is the subclass and Animal is the super class.
Now, let’s define the Animal and Dog classes.

Example

Class Animal
def initialize (name, color)
@name = name
@color = color
End
def speak
Puts “Hi”
End
End
Class Dog < Animal
End

Dog is a subclass of Animal so it inherits Animal’s methods and attributes.

Example

d = Dog.new (“Deva”, “Blue”)
d.speak

Output

Now, Dog has all the methods and attributes of the Animal class, which is why we can initiate the object and all the speaking.

Example

Class vehicle
def make_sound
Puts “Hi”
End
End
Class car < vehicle
End
c = car.new
c.make_sound

The subclass can also have its own methods and attributes.
Let’s define a Cat class and inherit it from the same Animal class.

Example

Class Animal
def initialize (name, color)
@name = name
@color = color
End
def speak
Puts “Hi”
End
End
Class Dog < Animal
End
Class cat < Animal
attr_accessor:age
def speak
Puts “Meow”
End
End
c = cat.new (“lucy”, “white”)
c.speak

Output

Meow

In the code above, Cat inherits from Animal.
It has an instance variable age and also defines its own speak.
This is called method overloading because the speak method in Cat overrides or replaces the one in the Animal class.
When we called the speak method for our Dog object, its super class method was called because Dog did not override it.
The Cat object called its own speak method because it defined its own implementation.
Inheritance is a great way to remove duplication in your code by writing the shared and common functionality in the super class and then adding individual functionality in the sub class.
You can have multiple levels of inheritance, for example,

Example

Class Animal
End
Class Mammal < Animal
End
Class Dog < Mammal
End

Here, Dog inherits from Mammal, which inherits from Animal.
This can be described as an “is a” relationship because a Dog is a Mammal
This is an example of single inheritance with multiple levels of hierarchy.
However, Ruby does not support multiple inheritance, meaning you cannot inherit a class simultaneously from multiple classes (a class cannot have multiple super classes).

SUPER

Ruby has a built-in method called super, which is used to call methods from the super class.
When you call super in a method for the sub class, the method of the same name gets called from the super class.

Example

Class Animal
def speak
Puts “Hi”
End
End
Class cat < Animal
def speak
super
Puts “Meow”
End
End

Super class the speak method of the Animal class.
Now, if we create an object of class cat and call its speak method, we will get the following:

Example

c = cat.new
c.speak

Output

Meow

The use of super allows us to remove duplicate code by using and extending the behavior of the super class in our super class.
Super is more commonly used in the initialize
For example, our super class has na initialize method that takes one argument and initializes an instance variable.

Example

Class Animal
def initialize (name)
@name = name
End
End

Now, we need a sub class cat that also has an @age instance variable, and we need to define its own initialization
Instead of repeating ourselves, and setting the name instance variable in the cat class, we can use its super class with the super method as follows:

Example

Class Cat < Animal
def initialize (name, age)
Super (name)
@age = age
End
def to_s
“#{@name} is #{@age} years old.”
End
End

We passed one of the arguments to the super method, which calls the initialize method of the Animal call and sets the @name instance variable.
Now we can instantiate an object and output its info:

Example

c = Cat.new (“Bob”, 3)
Puts c

Output

Bob is 3 years old

In the example we used super for a simple assignment.
Imagine having a complex program with complex calculations and operations being carried out.
That’s where the real benefits of “not repeating yourself” come in, and calling the super where applicable is one way of achieving it.

Example

Class A
def initialize (x)
Puts x/2
End
End
Class B < A
def initialize (y)
Super (y +2)
End
End
ob = B.new (6)

Output

CONCLUSION

I hope you understand. If you have any queryies please ask me anything. We'll see more in the future.