The Four Pillars of OOP

Direct Answer

The four commonly taught OOP pillars are encapsulation, abstraction, inheritance, and polymorphism. In Ruby, encapsulation protects an object's state behind public methods and visibility; abstraction exposes a small useful interface while hiding steps; inheritance lets a subclass specialise an ancestor's contract; and polymorphism lets different objects respond to the same message in their own way. They are design tools, not a requirement to build deep class hierarchies.

Deep Dive & Architecture

Encapsulation is about authority, not hiding every field. The object should be the one place allowed to move its state between valid conditions. A reader may expose balance safely, while a general balance writer would let every caller bypass withdrawal rules.

Abstraction chooses the vocabulary of that boundary. A good public method names an outcome the caller understands and keeps storage, calculation order, and collaborators replaceable. An abstraction leaks when callers must know those internal steps to use it correctly.

Inheritance affects identity and method lookup. The child inherits the parent's promises as well as its implementation. If the child rejects valid parent inputs or changes the meaning of results, reuse has broken substitutability even if the syntax is legal.

Polymorphism removes conditionals from the caller by moving variation to receivers. A small message contract can be implemented by unrelated classes, test doubles, or adapters. Tests should verify the shared semantics, because matching method names alone do not guarantee matching behaviour.

Code Example

class Account
  attr_reader :balance

  def initialize(balance)
    @balance = balance
  end

  def withdraw(amount)
    raise ArgumentError, 'invalid amount' unless amount.positive?
    raise 'insufficient funds' if amount > @balance
    @balance -= amount
  end
end

class EmailNotifier
  def deliver(message)
    "email: #{message}"
  end
end

class SmsNotifier
  def deliver(message)
    "sms: #{message}"
  end
end

def notify(notifier, message)
  notifier.deliver(message) # polymorphic message
end

Common Mistakes & Pitfalls

Thinking Ruby needs formal interfaces for polymorphism (it uses duck typing), or over-using inheritance where a module fits.