Ruby Object-Oriented Programming

Master Ruby's elegant object-oriented programming features. Ruby is a pure object-oriented language where everything is an object.

Class Definition

Basic Class Structure

class Person

Class variable (shared across all instances)

@@count = 0

Constant

MAX_AGE = 150

Class method

def self.count @@count end

Constructor

def initialize(name, age) @name = name # Instance variable @age = age @@count += 1 end

Instance method

def introduce "Hi, I'm #{@name} and I'm #{@age} years old" end

Attribute accessors (getter and setter)

attr_accessor :name attr_reader :age # Read-only attr_writer :email # Write-only end

person = Person.new("Alice", 30) puts person.introduce person.name = "Alicia"

Method Visibility

class BankAccount def initialize(balance) @balance = balance end

Public methods (default)

def deposit(amount) @balance += amount log_transaction(:deposit, amount) end

def balance format_currency(@balance) end

Protected methods - callable by instances of same class/subclass

protected

def log_transaction(type, amount) puts "[#{type}] #{amount}" end

Private methods - only callable within this instance

private

def format_currency(amount) "$#{amount}" end end

Inheritance

Single Inheritance

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

def speak "Some sound" end end

class Dog < Animal def speak "Woof! My name is #{@name}" end

Call parent method with super

def introduce super # Calls parent's speak method puts "I'm a dog" end end

dog = Dog.new("Buddy") puts dog.speak

Method Override and Super

class Vehicle def initialize(brand) @brand = brand end

def start_engine puts "Engine starting..." end end

class Car < Vehicle def initialize(brand, model) super(brand) # Call parent constructor @model = model end

def start_engine super # Call parent method puts "#{@brand} #{@model} is ready to drive" end end

Modules and Mixins

Module as Namespace

module MyApp module Utils def self.format_date(date) date.strftime("%Y-%m-%d") end end end

MyApp::Utils.format_date(Time.now)

Module as Mixin

module Swimmable def swim "I'm swimming!" end end

module Flyable def fly "I'm flying!" end end

class Duck include Swimmable # Instance methods include Flyable

def quack "Quack!" end end

duck = Duck.new puts duck.swim puts duck.fly

Extend vs Include

module Greetable def greet "Hello!" end end

class Person include Greetable # Adds as instance method end

class Company extend Greetable # Adds as class method end

Person.new.greet # Works Company.greet # Works

Advanced OOP Patterns

Singleton Pattern

class Database @instance = nil

private_class_method :new

def self.instance @instance ||= new end

def connect puts "Connected to database" end end

db1 = Database.instance db2 = Database.instance db1.object_id == db2.object_id # true

Method Missing (Dynamic Methods)

class DynamicAttributes def method_missing(method_name, *args) attribute = method_name.to_s

if attribute.end_with?("=")
  # Setter
  instance_variable_set("@#{attribute.chop}", args.first)
else
  # Getter
  instance_variable_get("@#{attribute}")
end

end

def respond_to_missing?(method_name, include_private = false) true end end

obj = DynamicAttributes.new obj.name = "Ruby" puts obj.name # "Ruby"

Class Instance Variables

class Product @inventory = []

class << self attr_accessor :inventory

def add(product)
  @inventory &#x3C;&#x3C; product
end

end end

Product.add("Laptop")

Struct and OpenStruct

Struct (Immutable-ish)

Person = Struct.new(:name, :age) do def introduce "I'm #{name}, #{age} years old" end end

person = Person.new("Bob", 25) puts person.name person.age = 26

OpenStruct (Dynamic Attributes)

require 'ostruct'

person = OpenStruct.new person.name = "Charlie" person.age = 30 person.email = "charlie@example.com"

puts person.name

Composition Over Inheritance

class Engine def start "Engine started" end end

class Wheels def rotate "Wheels rotating" end end

class Car def initialize @engine = Engine.new @wheels = Wheels.new end

def start @engine.start end

def drive @wheels.rotate end end

Comparable and Enumerable

Making Classes Comparable

class Person include Comparable

attr_reader :age

def initialize(name, age) @name = name @age = age end

def <=>(other) age <=> other.age end end

people = [Person.new("Alice", 30), Person.new("Bob", 25)] puts people.sort.map(&:age) # [25, 30]

Class Variables vs Instance Variables

class Counter @@count = 0 # Class variable (shared) @instances = [] # Class instance variable (not shared with subclasses)

def initialize @@count += 1 end

def self.count @@count end end

Best Practices

Prefer composition over inheritance for complex relationships
Use modules for mixins to share behavior across unrelated classes
Keep classes small and focused (Single Responsibility Principle)
Use attr_accessor/reader/writer instead of manual getters/setters
Make use of private/protected to encapsulate implementation details
Prefer instance variables over class variables to avoid unexpected sharing
Use Struct for simple data objects instead of full classes
Override to_s for debugging to provide meaningful string representations

Anti-Patterns

❌ Don't use class variables unnecessarily - they're shared across inheritance hierarchy ❌ Don't create god objects - keep classes focused and small ❌ Don't expose internal state - use methods instead of direct instance variable access ❌ Don't overuse inheritance - prefer composition or modules ❌ Don't ignore visibility modifiers - they exist for encapsulation

Related Skills

ruby-metaprogramming - For dynamic class/method generation
ruby-blocks-procs-lambdas - For functional programming patterns
ruby-modules - For advanced module usage

ruby-oop

Safety Notice

Copy this and send it to your AI assistant to learn