Object Inheritance in Ruby
Tags: ruby, flatiron, beginners, oo
Published: 2022-11-20 21:27:00

## Introduction

In real life, different categories or groups 
(like people, reptiles, buildings, etc.) are related in all sorts of ways. Within a single group, or class, there are many ways things can be classified. For example, the "people" category or class includes garbage men, shop owners, scientists, etc. Each class shares common features because they are all people. Even though they are different, they all have specialized and unique traits too.

In coding, we know we always want to cut out repetitious sequences from our code. Object inheritance in Ruby allows us to simplify our code and keep repititious 'code smell' down. We see the similarities between related classes and we abstract out the common methods and behaviors into a parent class.

## Basics of Inheritance
 
Inheritance is one of the most important features in an object-oriented language.
It is when a class inherits behavior from another class. If a programmer wants to create a new class and there is a class that already includes some of the code that the programmer wants, then they can derive a new class from the existing class. The class that is passing along behavior is called the superclass and the class that inherits it is called the subclass. The use of inheritance allows us to create a family of classes with shared behavior, while still differentiating those classes. Using this system reuses existing code and allows new classes (sub-classes) to need less new code written. 

Implementing class inheritance creates a family of classes with shared behavior and differentiation. Code that would have been used repetitively gets abstracted and simplified. The new child or subclass adopts attributes and behaviors that are already contained in the parent class. (superclass)

**Key terms in Inheritance:** 

- Super-class: Classes whose characteristics (methods and behaviors) are inheritable are known as "superclass" (aka. base class or parent class).
- Sub-class: The class which is derived from another class is known as a subclass or derived class or child class. They are sometimes written with their own objects and methods in addition to the superclass methods and objects, etc.

## Examples:

## Defining the Superclass:

Below we have written a class called `Bear`. It has many methods, all of which can be passed down and available to its children, aka. subclass. The superclass normally provides the bulk of key code content, that which is inheritable by the children (aka. subclasses).

```
class Bear

  attr_accessor :coat_color, :favorite_food

  def initialize(coat_color, favorite_food)
    @coat_color = coat_color
    @favorite_food = favorite_food
  end

  def speak
    "Grrrowlll!"
  end

  def feed
    "om nom nom!"
  end

end
```
Here we see our `Bear` super-class. It is initialized with `coat_color` and a `favorite_food`. Also present are instance methods, such as `speak` and `feed`. Each of these methods will be available to any children, inheriters of this `Bear` super-class.


## Subclass:

The subclass is the class which has been derived from the super's code and which extends the usability of that code. (i.e. class methods, instance methods, etc.)
In the code block below we see `Bear`'s class characteristics being inherited by `Panda`. We also see the general syntax for inheriting , which is the `<` placed between the sub-class and the super-class. `Panda` now inherits all of the methods and behavior of the parent class. It can now use any of the methods found inside of the `Bear` class and can even have some Panda-specific ones of its own.  

```
class Panda < Bear
  
  def speak
    "Grrr..."

end
```

Because `Panda` is a child of `Bear`, all of the methods defined within `Bear` are available for `Panda` to use. All of the methods of the parent are inherited by the child. For example, `Panda.feed` returns `"om nom nom!"` Also, a panda could be initialized with  a `coat_color` and `favorite_food`.

## Overwriting Inherited Methods

One feature that differs between the parent class and child class here is how in the parent `Bear` class the `speak` method returns `"Grrrowlll!"` and the child `Panda` class has it's own instance method called speak which overwrites its parent. When `speak` is called on the `Panda` class, `"Grrr..."` is returned instead of `"Grrrowlll!"`. This illustrates how the subclass can overwrite methods of it's superclass.

Another example of this would be if we had a superclass of `Human` the `greet` instance method might say `"Hello!"` whereas a member of the `Cowboy` class might have a `greet` instance method overwriting that of it's parent `Human` class. The `greet` method of the `Cowboy` subclass might return `"HOWDY!!"` instead of `"Hello!"`.

## Conclusion

Because of ruby's object orientation and subsequent object inheritance, cleaner less repetitive code can be produced. Also, using the principles of inheritance, we can define generic Ruby classes which can have greater reusability. Smaller subclasses result in more detailed behaviors. With object inheritance we can also code multiple, non-repetitive methods, reducing the total amount of code needed, cleaning and optimizing the code that's useful to us.