Inheritance in Ruby

Direct Answer

Ruby supports single class inheritance with class Child < Parent. The child receives accessible behaviour from its ancestor chain, may override a method, and can call the overridden implementation with super. Bare super forwards the current method's arguments and block; super() deliberately sends none. Use inheritance for a real substitutable 'is-a' relationship and modules or composition for reusable behaviour that is not one.

Deep Dive & Architecture

Ruby does not copy parent methods into the subclass. When a message is sent, it searches the receiver's singleton class, its class, included or prepended modules in their lookup order, then superclasses and their ancestors. Admin.ancestors exposes the effective chain and is often the fastest way to explain which implementation will run.

Overriding places a method earlier in that search. super does not mean 'call a class named Parent'; it means 'continue searching for this method after the current owner'. That is why super also works cleanly with modules in the chain. Bare super preserves the current arguments and block, whereas super() is an explicit empty call.

Constructors are ordinary methods in this model. If a subclass defines initialize, the parent's initializer does not run automatically. The subclass calls super with the parent inputs, then establishes its own state. Missing that step often leaves inherited methods reading unset instance variables.

The design boundary is substitutability. A subclass should preserve what callers rely on: accepted inputs, meaningful outputs, and object invariants. If the child merely needs a helper service or one capability, composition and module inclusion avoid coupling its entire identity to a parent implementation.

Code Example

class User
  def initialize(name)
    @name = name
  end

  def greeting
    "Hello #{@name}"
  end
end

class Admin < User
  def initialize(name, area)
    super(name)                 # send the parent exactly one argument
    @area = area
  end

  def greeting
    "#{super} — admin for #{@area}"
  end
end

Admin.new('Ravi', 'billing').greeting
# => 'Hello Ravi — admin for billing'
Admin.ancestors.first(2)        # => [Admin, User]

Common Mistakes & Pitfalls

Using inheritance for code reuse alone (prefer composition/modules), or forgetting super passes args automatically.