【Ruby 57日目】オブジェクト指向 - オブジェクトモデル

はじめに

Rubyのオブジェクトモデルについて、Ruby 3.4の仕様に基づいて詳しく解説します。

この記事では、基本的な概念から実践的な使い方まで、具体的なコード例を交えて説明します。

基本概念

Rubyのオブジェクトモデルは、すべてがオブジェクトという設計思想に基づいています：

• すべてがオブジェクト - クラスやモジュールもオブジェクト
• クラスはClassクラスのインスタンス - クラス自体もオブジェクト
• メソッド探索の仕組み - メソッド呼び出しの解決順序
• 特異クラス（Singleton Class） - オブジェクト固有のメソッド定義

オブジェクトモデルを理解することで、Rubyの動作原理を深く理解できます。

基本的な使い方

クラスとオブジェクトの関係

# クラスの定義
class Person
  def initialize(name)
    @name = name
  end

  def greet
    "Hello, I'm #{@name}"
  end
end

# オブジェクトの生成
person = Person.new("Alice")
puts person.greet  #=> Hello, I'm Alice

# オブジェクトのクラスを確認
puts person.class  #=> Person

# クラス自体もオブジェクト
puts Person.class  #=> Class

# Classクラスもオブジェクト
puts Class.class   #=> Class

# すべてのオブジェクトはobject_idを持つ
puts person.object_id
puts Person.object_id
puts Class.object_id

クラス階層とsuperclass

# クラスの継承チェーン
class Animal
  def speak
    "Some sound"
  end
end

class Dog < Animal
  def speak
    "Woof!"
  end
end

class Poodle < Dog
  def speak
    super + " (in a fancy way)"
  end
end

poodle = Poodle.new
puts poodle.speak  #=> Woof! (in a fancy way)

# クラス階層を確認
puts Poodle.superclass  #=> Dog
puts Dog.superclass     #=> Animal
puts Animal.superclass  #=> Object
puts Object.superclass  #=> BasicObject
puts BasicObject.superclass  #=> nil

# ancestorsで継承チェーン全体を確認
puts Poodle.ancestors.inspect
#=> [Poodle, Dog, Animal, Object, Kernel, BasicObject]

メソッド探索の仕組み

module Greetable
  def greet
    "Hello from module"
  end
end

module Friendly
  def be_friendly
    "I'm friendly"
  end
end

class Person
  include Greetable
  prepend Friendly

  def greet
    "Hello from class"
  end
end

person = Person.new

# メソッド探索順序を確認
puts Person.ancestors.inspect
#=> [Friendly, Person, Greetable, Object, Kernel, BasicObject]

# メソッド呼び出し
puts person.greet  #=> Hello from module (prependが優先)
puts person.be_friendly  #=> I'm friendly

# メソッドの定義場所を確認
method_obj = person.method(:greet)
puts method_obj.owner  #=> Greetable

method_obj2 = person.method(:be_friendly)
puts method_obj2.owner  #=> Friendly

特異クラス（Singleton Class）

# オブジェクト固有のメソッド定義
person = "Alice"

# 特異メソッドの定義
def person.shout
  self.upcase + "!!!"
end

puts person.shout  #=> ALICE!!!

# 他の文字列オブジェクトには影響しない
other = "Bob"
begin
  other.shout
rescue NoMethodError => e
  puts "Error: #{e.message}"
end

# 特異クラスを確認
singleton_class = person.singleton_class
puts singleton_class  #=> #<Class:#<String:0x...>>
puts singleton_class.instance_methods(false)  #=> [:shout]

# 特異クラスでメソッドを定義
class << person
  def whisper
    self.downcase + "..."
  end
end

puts person.whisper  #=> alice...

クラスメソッドと特異クラス

class Calculator
  # クラスメソッドの定義（方法1）
  def self.add(a, b)
    a + b
  end

  # クラスメソッドの定義（方法2）
  class << self
    def subtract(a, b)
      a - b
    end

    def multiply(a, b)
      a * b
    end
  end
end

# クラスメソッドの呼び出し
puts Calculator.add(5, 3)       #=> 8
puts Calculator.subtract(5, 3)  #=> 2
puts Calculator.multiply(5, 3)  #=> 15

# クラスメソッドは特異メソッド
singleton_class = Calculator.singleton_class
puts singleton_class.instance_methods(false)
#=> [:multiply, :subtract, :add]

# クラスの特異クラスの親は何か
puts Calculator.singleton_class.superclass  #=> #<Class:Object>

インスタンス変数とクラス変数

class Counter
  # クラス変数
  @@total_count = 0

  def initialize
    # インスタンス変数
    @count = 0
    @@total_count += 1
  end

  def increment
    @count += 1
  end

  def count
    @count
  end

  def self.total_count
    @@total_count
  end
end

# インスタンスごとに独立した@count
counter1 = Counter.new
counter2 = Counter.new

counter1.increment
counter1.increment
counter2.increment

puts counter1.count  #=> 2
puts counter2.count  #=> 1

# クラス全体で共有される@@total_count
puts Counter.total_count  #=> 2

# インスタンス変数の確認
puts counter1.instance_variables  #=> [:@count]
puts counter1.instance_variable_get(:@count)  #=> 2

# クラス変数の確認
puts Counter.class_variables  #=> [:@@total_count]
puts Counter.class_variable_get(:@@total_count)  #=> 2

よくあるユースケース

ケース1: 動的なメソッド追加とメソッド探索

メタプログラミングでメソッドを動的に追加し、メソッド探索の仕組みを活用します。

class DynamicModel
  # 属性を動的に定義
  def self.attribute(name)
    # ゲッターの定義
    define_method(name) do
      instance_variable_get("@#{name}")
    end

    # セッターの定義
    define_method("#{name}=") do |value|
      instance_variable_set("@#{name}", value)
    end
  end

  # 検証メソッドを動的に定義
  def self.validates(attribute, &block)
    define_method("validate_#{attribute}") do
      value = send(attribute)
      block.call(value)
    end
  end
end

class User < DynamicModel
  attribute :name
  attribute :email
  attribute :age

  validates(:email) { |email| email&.include?('@') }
  validates(:age) { |age| age.nil? || (age >= 0 && age <= 150) }

  def valid?
    validate_email && validate_age
  end
end

# 使用例
user = User.new
user.name = "Alice"
user.email = "[e-mail]"
user.age = 25

puts "Name: #{user.name}"
puts "Email: #{user.email}"
puts "Age: #{user.age}"
puts "Valid: #{user.valid?}"  #=> Valid: true

# メソッド探索チェーンを確認
puts user.method(:name).owner  #=> User
puts User.instance_methods(false)
#=> [:name, :name=, :email, :email=, :age, :age=, :validate_email, :validate_age, :valid?]

ケース2: モジュールとメソッド探索の制御

モジュールのincludeとprependを使い分けてメソッド探索を制御します。

module Logging
  def perform
    log_start
    result = super
    log_end(result)
    result
  end

  private

  def log_start
    puts "[LOG] Starting #{self.class.name}#perform"
  end

  def log_end(result)
    puts "[LOG] Finished with result: #{result.inspect}"
  end
end

module Timing
  def perform
    start_time = Time.now
    result = super
    elapsed = Time.now - start_time
    puts "[TIMING] Elapsed: #{elapsed.round(3)}s"
    result
  end
end

class Task
  def perform
    sleep(0.1)
    "Task completed"
  end
end

# includeの場合
class IncludeTask < Task
  include Logging
  include Timing
end

# prependの場合
class PrependTask < Task
  prepend Logging
  prepend Timing
end

puts "=== Include version ==="
puts IncludeTask.ancestors.inspect
#=> [IncludeTask, Timing, Logging, Task, Object, Kernel, BasicObject]
task1 = IncludeTask.new
result1 = task1.perform

puts "\n=== Prepend version ==="
puts PrependTask.ancestors.inspect
#=> [Timing, Logging, PrependTask, Task, Object, Kernel, BasicObject]
task2 = PrependTask.new
result2 = task2.perform

ケース3: 特異クラスを使った柔軟な設計

特異クラスを活用して、特定のオブジェクトにのみ振る舞いを追加します。

class Configuration
  def initialize
    @settings = {}
  end

  def set(key, value)
    @settings[key] = value
  end

  def get(key)
    @settings[key]
  end
end

# 開発環境用の設定
dev_config = Configuration.new
dev_config.set(:database, 'localhost')
dev_config.set(:debug, true)

# 開発環境専用のメソッドを追加
class << dev_config
  def reload!
    puts "Reloading development configuration..."
    # 設定の再読み込み処理
  end

  def debug_info
    puts "Debug mode: #{get(:debug)}"
    puts "Database: #{get(:database)}"
  end
end

# 本番環境用の設定
prod_config = Configuration.new
prod_config.set(:database, 'production-db.example.com')
prod_config.set(:debug, false)

# 本番環境専用のメソッドを追加
class << prod_config
  def validate_ssl!
    puts "Validating SSL certificates..."
    # SSL検証処理
  end

  def security_check
    puts "Running security checks..."
    # セキュリティチェック処理
  end
end

# それぞれのメソッドは独立している
dev_config.reload!
dev_config.debug_info

prod_config.validate_ssl!
prod_config.security_check

# 特異メソッドの確認
puts "Dev config singleton methods: #{dev_config.singleton_methods.sort}"
#=> [:debug_info, :reload!]
puts "Prod config singleton methods: #{prod_config.singleton_methods.sort}"
#=> [:security_check, :validate_ssl!]

ケース4: クラス階層とメソッドオーバーライド

クラス階層を活用してポリモーフィズムを実現します。

class Shape
  def area
    raise NotImplementedError, "Subclass must implement area method"
  end

  def describe
    "#{self.class.name} with area: #{area}"
  end
end

class Circle < Shape
  def initialize(radius)
    @radius = radius
  end

  def area
    Math::PI * @radius ** 2
  end
end

class Rectangle < Shape
  def initialize(width, height)
    @width = width
    @height = height
  end

  def area
    @width * @height
  end
end

class Square < Rectangle
  def initialize(side)
    super(side, side)
  end

  # 正方形専用のメソッド
  def side
    @width
  end
end

# ポリモーフィズムの活用
shapes = [
  Circle.new(5),
  Rectangle.new(4, 6),
  Square.new(5)
]

shapes.each do |shape|
  puts shape.describe
  puts "  Ancestors: #{shape.class.ancestors.take(4).join(' < ')}"
end

#=> Circle with area: 78.53981633974483
#     Ancestors: Circle < Shape < Object < Kernel
#   Rectangle with area: 24
#     Ancestors: Rectangle < Shape < Object < Kernel
#   Square with area: 25
#     Ancestors: Square < Rectangle < Shape < Object

# メソッドの定義場所を確認
circle = Circle.new(10)
puts circle.method(:area).owner       #=> Circle
puts circle.method(:describe).owner   #=> Shape

ケース5: オブジェクトモデルを活用したプラグインシステム

オブジェクトモデルの理解を活かして、柔軟なプラグインシステムを構築します。

class PluginSystem
  def initialize
    @plugins = []
  end

  def register_plugin(plugin_class)
    # プラグインクラスが正しいインターフェースを持つか確認
    required_methods = [:name, :execute]
    required_methods.each do |method|
      unless plugin_class.instance_methods.include?(method)
        raise "Plugin must implement #{method} method"
      end
    end

    @plugins << plugin_class
    puts "Registered plugin: #{plugin_class.name}"
  end

  def execute_all(context)
    @plugins.each do |plugin_class|
      plugin = plugin_class.new
      puts "\nExecuting: #{plugin.name}"
      plugin.execute(context)
    end
  end

  def plugin_info
    @plugins.each do |plugin_class|
      puts "\nPlugin: #{plugin_class.name}"
      puts "  Ancestors: #{plugin_class.ancestors.take(5).join(' < ')}"
      puts "  Methods: #{plugin_class.instance_methods(false).sort.join(', ')}"
    end
  end
end

# プラグインの基底クラス
class Plugin
  def name
    self.class.name
  end

  def execute(context)
    raise NotImplementedError
  end
end

# 具体的なプラグイン
class LoggingPlugin < Plugin
  def name
    "Logging Plugin"
  end

  def execute(context)
    puts "  [LOG] Processing: #{context[:data]}"
  end
end

class ValidationPlugin < Plugin
  def name
    "Validation Plugin"
  end

  def execute(context)
    if context[:data].nil? || context[:data].empty?
      puts "  [VALIDATION] Error: Data is empty"
    else
      puts "  [VALIDATION] OK: Data is valid"
    end
  end
end

class TransformPlugin < Plugin
  def name
    "Transform Plugin"
  end

  def execute(context)
    transformed = context[:data].upcase
    puts "  [TRANSFORM] #{context[:data]} => #{transformed}"
    context[:data] = transformed
  end
end

# プラグインシステムの使用
system = PluginSystem.new
system.register_plugin(LoggingPlugin)
system.register_plugin(ValidationPlugin)
system.register_plugin(TransformPlugin)

# プラグイン情報の表示
system.plugin_info

# すべてのプラグインを実行
context = { data: "hello world" }
system.execute_all(context)

puts "\nFinal context: #{context.inspect}"

注意点とベストプラクティス

注意点

1. クラス変数の共有範囲

# BAD: クラス変数は継承先でも共有される
class Parent
  @@count = 0

  def self.increment
    @@count += 1
  end

  def self.count
    @@count
  end
end

class Child < Parent
end

Parent.increment
Child.increment

puts Parent.count  #=> 2 (意図しない共有)
puts Child.count   #=> 2

# GOOD: クラスインスタンス変数を使う
class BetterParent
  @count = 0

  class << self
    attr_accessor :count

    def increment
      @count += 1
    end
  end
end

class BetterChild < BetterParent
  @count = 0
end

BetterParent.increment
BetterChild.increment

puts BetterParent.count  #=> 1
puts BetterChild.count   #=> 1

2. メソッド探索の理解

module A
  def greet
    "A"
  end
end

module B
  def greet
    "B"
  end
end

# BAD: includeの順序を理解していない
class Confused
  include A
  include B  # こちらが優先される
end

puts Confused.new.greet  #=> B

# GOOD: 意図を明確にする
class Clear
  include A
  include B

  def greet
    # 明示的に呼び分ける
    "Using B: #{super}"
  end
end

puts Clear.new.greet  #=> Using B: B

3. 特異メソッドの適切な使用

# BAD: 多くのオブジェクトに特異メソッドを定義
users = 100.times.map { |i| "User#{i}" }
users.each do |user|
  def user.special_method
    "special"
  end
end
# メモリ効率が悪い

# GOOD: クラスやモジュールにメソッドを定義
class User
  def initialize(name)
    @name = name
  end

  def special_method
    "special for #{@name}"
  end
end

users = 100.times.map { |i| User.new("User#{i}") }

ベストプラクティス

1. 継承よりコンポジション

# GOOD: モジュールで機能を分離
module Persistable
  def save
    puts "Saving #{self.class.name}..."
  end
end

module Validatable
  def valid?
    errors.empty?
  end

  def errors
    @errors ||= []
  end
end

class User
  include Persistable
  include Validatable

  attr_accessor :name, :email

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

user = User.new("Alice", "[e-mail]")
puts user.valid?
user.save

2. メソッド探索チェーンを意識する

# GOOD: ancestorsを確認してメソッド探索を理解
class MyClass
  include Module1
  prepend Module2
end

puts MyClass.ancestors.inspect

# メソッドの定義場所を確認
obj = MyClass.new
method_obj = obj.method(:some_method)
puts "Defined in: #{method_obj.owner}"

3. オブジェクトの内部構造を理解する

# GOOD: オブジェクトの詳細情報を取得
class Inspector
  def self.inspect_object(obj)
    puts "Class: #{obj.class}"
    puts "Object ID: #{obj.object_id}"
    puts "Instance variables: #{obj.instance_variables}"
    puts "Methods (first 10): #{obj.methods.first(10).join(', ')}"
    puts "Singleton methods: #{obj.singleton_methods}"
    puts "Ancestors: #{obj.class.ancestors.take(5).join(' < ')}"
  end
end

user = User.new("Alice", "[e-mail]")
Inspector.inspect_object(user)

4. 適切なスコープでメソッドを定義

# GOOD: 用途に応じてメソッドを定義
class Account
  # インスタンスメソッド: 個々のアカウント操作
  def deposit(amount)
    @balance ||= 0
    @balance += amount
  end

  # クラスメソッド: クラス全体に関わる操作
  def self.total_accounts
    ObjectSpace.each_object(self).count
  end

  # プライベートメソッド: 内部実装
  private

  def validate_amount(amount)
    amount > 0
  end
end

5. メタプログラミングは慎重に

# GOOD: メタプログラミングを使う場合は文書化
class DynamicAttribute
  # 動的に属性を定義します
  # @param name [Symbol] 属性名
  # @param options [Hash] オプション（:default, :type など）
  def self.define_attribute(name, options = {})
    # ゲッター
    define_method(name) do
      instance_variable_get("@#{name}") || options[:default]
    end

    # セッター（型チェック付き）
    define_method("#{name}=") do |value|
      if options[:type] && !value.is_a?(options[:type])
        raise TypeError, "Expected #{options[:type]}, got #{value.class}"
      end
      instance_variable_set("@#{name}", value)
    end
  end
end

class Person < DynamicAttribute
  define_attribute :name, type: String
  define_attribute :age, type: Integer, default: 0
end

person = Person.new
person.name = "Alice"
person.age = 25
puts "#{person.name} is #{person.age} years old"

Ruby 3.4での改善点

• Prismパーサー - オブジェクトモデルの解析がより高速に
• YJIT最適化 - メソッド探索とメソッド呼び出しの高速化
• メモリ効率の向上 - オブジェクト生成とメモリ管理の改善
• デバッグ情報の充実 - オブジェクトの内部状態の可視化が向上

# Ruby 3.4では、メソッド探索がより効率的に
class Base
  def method1
    "base"
  end
end

100.times do |i|
  Class.new(Base) do
    define_method("dynamic_#{i}") do
      "dynamic method #{i}"
    end
  end
end

# メソッド呼び出しのパフォーマンスが向上
require 'benchmark'

obj = Base.new
time = Benchmark.realtime do
  100_000.times { obj.method1 }
end
puts "Method call time: #{time.round(5)}s"

まとめ

この記事では、Rubyのオブジェクトモデルについて以下の内容を学びました：

• 基本概念 - すべてがオブジェクト、クラス階層、メソッド探索、特異クラス
• 基本的な使い方 - クラスとオブジェクト、継承チェーン、メソッド探索、特異クラス、インスタンス変数
• 実践的なユースケース - 動的メソッド追加、メソッド探索制御、特異クラス活用、クラス階層、プラグインシステム
• 注意点とベストプラクティス - クラス変数の共有、メソッド探索理解、適切な設計パターン

オブジェクトモデルの理解は、Rubyプログラミングの根幹となる重要な知識です。

参考資料

• Ruby 3.4 公式ドキュメント
• Ruby リファレンスマニュアル
• Ruby Style Guide