Inheritance in Ruby: Exploring Attributes and Methods

Welcome back! In this part of our Ruby Class Basics Review, we’ll dive into inheritance, a core concept in Ruby’s object-oriented programming (OOP). Inheritance enables code-sharing between classes, making our code more efficient and easier to read.

This lesson covers how inheritance works in Ruby, including attribute and method inheritance, along with the super keyword to access superclass functionality. Ready to dive in? Let’s get started!

Inheritance in Ruby allows us to create a subclass that inherits attributes and methods from a superclass. This approach is especially useful when multiple classes share common features or behaviors.

Let’s explore with a superclass named Vehicle and a subclass named Car:

# Define the superclass 'Vehicle'
class Vehicle
  # Initialize the Vehicle with color and brand attributes
  def initialize(color, brand)
    @color = color
    @brand = brand
  end
end

# Define the subclass 'Car', inheriting from 'Vehicle'
class Car < Vehicle
  def initialize(color, brand, doors)
    # Use 'super' to call the superclass's initialize method
    super(color, brand)
    @doors = doors
  end
end

In this example, Car inherits properties from Vehicle. Ruby supports several types of inheritance, but here we’re focusing on single inheritance, where a subclass has a single superclass.

With attribute inheritance, a subclass can inherit instance variables from its superclass.

class Artist
  attr_reader :name  # Getter for @name

  def initialize(name)
    @name = name  # Superclass's attribute
  end
end

class Musician < Artist
  attr_reader :instrument  # Getter for @instrument

  def initialize(name, instrument)
    super(name)  # Inheriting superclass's attribute
    @instrument = instrument  # Subclass's own attribute
  end
end

john = Musician.new('John Lennon', 'Guitar')
puts john.name        # Output: John Lennon
puts john.instrument  # Output: Guitar

The Musician class inherits the @name attribute from Artist, while also introducing its own attribute, @instrument. Getters can be conveniently defined using attr_reader to access instance variables of each class.