Inheritance in Ruby

Welcome back! Now that you have a solid understanding of classes and objects in Ruby, it's time to build on that knowledge by exploring inheritance. Consider it a natural progression in our journey into object-oriented programming (OOP).

Inheritance allows you to create a new class based on an existing class. By using inheritance, you can reuse code, add new features, and make your programs easier to manage and understand. Let's dive in and see what it's all about.

In this lesson, you'll understand how to use inheritance in Ruby. We'll cover:

1. What Inheritance Is
2. How to Implement Inheritance in Ruby
3. Why Inheritance Is Beneficial

Inheritance is a way to establish a relationship between a new class (subclass) and an existing class (superclass). The subclass inherits properties and behaviors (methods) from the superclass.

Here’s a simple example:

# Define the superclass Person with name and age attributes
class Person
  # Constructor to initialize name and age
  def initialize(name, age)
    @name = name
    @age = age
  end

  # Display method to show name and age
  def display
    puts "Name: #{@name}, Age: #{@age}"
  end

  # Greet method to display a greeting message
  def greet
    puts "Hello, there!"
  end
end

# Define the subclass Student, inheriting from Person
class Student < Person
  # Constructor to initialize name, age of the superclass, and the major of the student
  def initialize(name, age, major)
    super(name, age)
    @major = major
  end

  # Display method to show name, age using the superclass's display method, and major of the student
  def display
    greet
    super
    puts "Major: #{@major}"
  end
end

# Create a Student object and display its details
student = Student.new("Bob", 25, "Computer Science")
student.display
student.greet

In this snippet, the Student class inherits from the Person class. It reuses the @name and @age attributes and methods from the Person class and adds a new attribute @major and a new display method to show the student's major.

When you declare a subclass in Ruby, you specify the class it inherits from using the < symbol. The subclass can then extend or override the functionality of the superclass.

In our example:

• The Person class is the superclass.
• The Student class is the subclass, inheriting @name and @age from the Person class.
• The Student class also adds a new member, @major, and overrides the display method to include information about the major.
  • Notice how Student#display calls super to reuse the superclass functionality before adding its own details.
  • The greet method is also called from the display method to show how the subclass can access superclass methods.
• Pay attention, that the student object can call the greet method, which is defined in the superclass.

It is important to note that the super keyword in Ruby is used to call a method in the superclass with the same name as the current method:

• Without Arguments: When called without parentheses (super), it automatically forwards all arguments from the subclass method to the superclass method. This is convenient when the arguments in the subclass and superclass methods are identical, reducing redundancy.
• With Arguments: When called with explicit arguments (super(arg1, arg2)), only the specified arguments are passed to the superclass method. This provides greater control and is useful when the arguments in the subclass differ from those in the superclass or require modification before passing.

In this specific case, using super with or without arguments would have the same effect because the arguments match.

Inheritance is powerful for several reasons:

1. Code Reusability: Instead of rewriting common functionalities, you can inherit them from a superclass, making maintenance easier and reducing errors.
2. Extension: You can extend existing code by adding new features to a subclass without changing the existing superclass.
3. Hierarchy: It helps in organizing code in a hierarchical manner, which reflects real-world relationships and improves code readability and structure.

Inheritance is a cornerstone of OOP, and understanding it will enable you to design more flexible and scalable applications. It's an essential concept for mastering OOP.

Excited to start practicing? Let's move on and put this theory into action!