MENU
  1. ホーム
  2. Ruby
  3. Rubyで学ぶ！クラスの再利用を考慮した継承とインターフェース設計の実践

Rubyで学ぶ！クラスの再利用を考慮した継承とインターフェース設計の実践

Ruby

Rubyのプログラム設計では、コードの再利用性や拡張性を考慮したクラス設計が重要な役割を果たします。特に、クラスの再利用を目的とした「継承」や、異なるクラス間で共通の機能を持たせる「インターフェース設計」は、効率的かつ保守しやすいコードを実現するための基本的なテクニックです。本記事では、Rubyを使ったクラス設計の基礎から、継承とインターフェース設計の実践的な方法までを、サンプルコードを交えて解説します。これにより、再利用性を重視した設計手法を理解し、より堅牢なRubyプログラムを作成できるようになることを目指します。

目次
  1. クラスの継承とインターフェース設計の基礎
    1. 継承の基本構文
    2. インターフェースの役割
  2. 継承を使ったクラス再利用のメリットとデメリット
    1. メリット
    2. デメリット
    3. 継承の適切な利用
  3. インターフェース設計の実践例
    1. モジュールを用いたインターフェースの実装
    2. インターフェースの活用例
    3. まとめ
  4. 抽象クラスとモジュールの活用
    1. 抽象クラスの実装
    2. モジュールの活用による機能共有
    3. 抽象クラスとモジュールの組み合わせ
    4. まとめ
  5. 依存性の注入を用いたインターフェースの実装
    1. 依存性の注入の基本概念
    2. 依存性の注入の実装例
    3. 依存性の注入を用いるメリット
    4. まとめ
  6. 多重継承の回避とミックスインによるインターフェースの実現
    1. ミックスインを使ったインターフェースの実装
    2. 多重継承を回避する理由
    3. ミックスインの活用例
    4. インターフェースとミックスインを用いた設計のメリット
    5. まとめ
  7. クラス設計のアンチパターン
    1. 1. ゴッドオブジェクト
    2. 2. アンチシンボリズム
    3. 3. 不必要な継承
    4. 4. 設計の早すぎる最適化
    5. 5. マジックナンバーの使用
    6. まとめ
  8. インターフェース設計におけるユニットテストの重要性
    1. インターフェースに対するユニットテストの実装
    2. ユニットテストのメリット
    3. テスト駆動開発（TDD）によるインターフェース設計
    4. まとめ
  9. 実践例：継承とインターフェースを活用したシステム設計
    1. 抽象クラスとインターフェースの設計
    2. 具体的な支払いクラスの実装
    3. 支払い処理を統一するインターフェースの利用
    4. 実装のメリット
    5. まとめ
  10. まとめ

クラスの継承とインターフェース設計の基礎


オブジェクト指向プログラミングにおいて、継承は親クラスの特性を子クラスに引き継ぐ仕組みを指します。Rubyでは、<記号を用いて親クラスを指定することで継承を行います。たとえば、Animalクラスを基にしたDogクラスのように、共通の機能を親クラスにまとめることで、子クラスは重複のないコードを利用できます。

継承の基本構文


Rubyでは、以下のように継承を表現します。

class Animal
  def speak
    "Some sound"
  end
end

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

この例では、DogクラスはAnimalクラスを継承しており、Animalのメソッドを上書きしています。Rubyでは、このようなオーバーライドが柔軟に行えるため、特定の機能を再定義して異なる振る舞いをさせることができます。

インターフェースの役割


RubyにはJavaのような明示的なインターフェースは存在しませんが、モジュールを用いることでクラス間で共通のメソッドを共有し、インターフェースのように機能させることが可能です。モジュールを使ったインターフェースは、多様なクラスが共通の機能を持てるため、柔軟で再利用性の高い設計を可能にします。

module Walkable
  def walk
    "I'm walking"
  end
end

class Dog
  include Walkable
end

このように、モジュールを使って共通のインターフェースを持たせることで、コードの一貫性を保ちながら、再利用性の高い設計が可能です。

継承を使ったクラス再利用のメリットとデメリット

継承を用いることで、親クラスに定義された機能やプロパティを子クラスが再利用でき、コードの重複を避けることができます。これにより、変更が親クラスに対して一度行われれば、その変更がすべての子クラスに自動的に適用されるため、メンテナンスが効率化されます。しかし、継承には注意すべきデメリットも存在します。

メリット


継承によって得られる主なメリットは以下の通りです。

1. コードの再利用性


親クラスに共通の機能を実装することで、子クラスは重複なく機能を再利用できます。これにより、重複コードを削減し、開発効率が向上します。

2. 保守性の向上


親クラスのコードに変更を加えることで、すべての子クラスにも反映されるため、一括してメンテナンスが可能です。たとえば、エラーハンドリングのロジックを親クラスに一度追加することで、すべての子クラスに適用できます。

デメリット


継承には以下のようなデメリットもあります。

1. クラス間の強い結合


継承関係はクラス間に強い結びつきを生むため、親クラスの変更が子クラス全体に影響を与える可能性があります。このため、予期せぬエラーが発生しやすくなる場合があります。

2. 過度な継承による設計の複雑化


継承を重ねると、クラス階層が深くなり、コードの理解が難しくなる場合があります。多層の継承はデバッグやメンテナンスを複雑にし、依存関係が増加するため、設計が複雑化しやすい点に注意が必要です。

継承の適切な利用


これらのメリットとデメリットを考慮し、継承は共通する性質を持つクラス群に対してのみ適用し、過度に利用しないことが重要です。適切に継承を活用することで、メンテナンス性と拡張性の高いクラス設計が可能になります。

インターフェース設計の実践例

Rubyにおいて、異なるクラス間で共通の機能を持たせる場合、インターフェース設計が役立ちます。RubyにはJavaのような明示的なインターフェースはありませんが、モジュールを利用してインターフェースの役割を担うことができます。モジュールを使うことで、異なるクラスに同一のメソッド群を提供し、共通の振る舞いを実現できます。

モジュールを用いたインターフェースの実装


以下の例では、Speakableというモジュールを用意し、異なるクラスに同じ「speak」メソッドを提供します。これにより、異なるクラスが共通のインターフェースを持ち、同様のメソッドを利用できるようになります。

module Speakable
  def speak
    "I can speak!"
  end
end

class Dog
  include Speakable
end

class Cat
  include Speakable
end

この例では、DogクラスとCatクラスの両方にSpeakableモジュールを組み込むことで、両クラスがspeakメソッドを持つようになります。これにより、DogとCatは同様の「話す」動作を持ち、共通のインターフェースとして利用可能です。

インターフェースの活用例


以下のように、インターフェースを用いて複数のクラスを一括して扱えるようになります。たとえば、異なるクラスのオブジェクトに対してSpeakableインターフェースを適用することで、一貫性のある呼び出しが可能です。

animals = [Dog.new, Cat.new]

animals.each do |animal|
  puts animal.speak  # それぞれのクラスに応じた`speak`メソッドが実行される
end

このコードは、DogとCatのオブジェクトに対してSpeakableインターフェースを介して共通のメソッドを実行します。これにより、異なるクラスでも同じ方法でアクセスでき、コードの拡張性やメンテナンス性が向上します。

まとめ


Rubyのモジュールは、インターフェースを設計する手段として非常に有用です。異なるクラスに共通の機能を持たせることで、コードの一貫性と再利用性が高まります。適切なインターフェース設計を行うことで、柔軟かつ堅牢なRubyプログラムを実現できます。

抽象クラスとモジュールの活用

Rubyでは、抽象クラスやモジュールを活用することで、より柔軟で再利用性の高いインターフェース設計が可能になります。抽象クラスは、共通の機能をまとめるための土台となり、直接インスタンス化はしません。一方、モジュールは複数のクラスに共通の機能を提供し、インターフェースとしての役割を果たします。

抽象クラスの実装


Rubyでは、抽象クラスを明確に指定する構文はありませんが、直接インスタンス化しないことを前提としたクラスを作成し、サブクラスに継承させることで抽象クラスのように扱うことができます。以下は、Animalという抽象クラスを定義し、共通のメソッドを子クラスで実装させる例です。

class Animal
  def speak
    raise NotImplementedError, "This method must be implemented in a subclass"
  end
end

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

class Cat < Animal
  def speak
    "Meow!"
  end
end

このコードでは、Animalクラスのspeakメソッドが抽象メソッドとして機能しており、子クラスでの実装が必須となっています。この設計により、DogとCatの両方に共通のインターフェースが保証され、各クラスでの振る舞いが統一されます。

モジュールの活用による機能共有


モジュールを使えば、複数のクラスに共通の機能を提供できます。抽象クラスの代わりにモジュールを利用することで、複数のクラスに対して同じ機能を共有し、Rubyの単一継承制限を回避することが可能です。

module Swimmable
  def swim
    "I can swim!"
  end
end

class Fish
  include Swimmable
end

class Duck
  include Swimmable
end

この例では、FishとDuckクラスがSwimmableモジュールを利用してswimメソッドを持っています。これにより、異なるクラスに共通の動作が定義され、コードの一貫性が保たれます。

抽象クラスとモジュールの組み合わせ


抽象クラスとモジュールは組み合わせることもでき、複雑なインターフェースを実装する際に有効です。抽象クラスで基本的な機能を定義し、モジュールで追加の共通機能を提供することで、より柔軟な設計が可能になります。

class Animal
  def speak
    raise NotImplementedError, "This method must be implemented in a subclass"
  end
end

module Runnable
  def run
    "I'm running"
  end
end

class Dog < Animal
  include Runnable

  def speak
    "Woof!"
  end
end

このように、DogクラスはAnimalクラスを継承し、さらにRunnableモジュールを活用することで、両方の機能を持つクラスが完成します。

まとめ


抽象クラスとモジュールを組み合わせることで、Rubyにおいて柔軟で再利用性の高いクラス設計が可能になります。抽象クラスを用いた強制的なインターフェースの実装と、モジュールによる機能の共有を活用することで、堅牢かつ効率的なプログラムを構築できます。

依存性の注入を用いたインターフェースの実装

依存性の注入（Dependency Injection）は、オブジェクトが必要とする依存オブジェクトを外部から注入する設計手法です。Rubyでは、依存性の注入を利用することで、クラス間の結合を緩め、柔軟でテストしやすいインターフェース設計が可能になります。特に、インターフェースを意識した設計では、依存性の注入を活用することで、異なるクラスでも共通のインターフェースを利用できる利点があります。

依存性の注入の基本概念


依存性の注入では、クラス内で直接オブジェクトを生成するのではなく、外部からオブジェクトを渡すことで、依存関係を管理します。これにより、外部で異なるクラスを差し替えることができ、テストやメンテナンスが容易になります。

依存性の注入の実装例


以下の例では、Loggerインターフェースを用意し、異なるロギング手法をUserクラスに注入します。Loggerインターフェースは、共通のlogメソッドを持つクラスを想定しています。

# Loggerインターフェースとしての役割を持つモジュール
module Logger
  def log(message)
    raise NotImplementedError, "This method must be implemented"
  end
end

# FileLoggerクラス
class FileLogger
  include Logger

  def log(message)
    File.open("log.txt", "a") { |f| f.puts(message) }
  end
end

# ConsoleLoggerクラス
class ConsoleLogger
  include Logger

  def log(message)
    puts message
  end
end

# Userクラスが依存性の注入を用いる
class User
  def initialize(name, logger)
    @name = name
    @logger = logger
  end

  def create
    @logger.log("User #{@name} has been created")
  end
end

この例では、UserクラスがLoggerインターフェースに依存し、FileLoggerやConsoleLoggerのインスタンスを外部から注入します。これにより、Userクラスは異なるロギング手法に依存せず、柔軟に動作します。

依存性の注入を用いるメリット

1. クラス間の結合度の低下


依存するオブジェクトを外部から注入することで、クラス間の結合が緩くなり、変更が容易になります。たとえば、FileLoggerからConsoleLoggerへの切り替えが簡単に行えます。

2. テストが容易になる


依存性の注入を利用することで、テスト時にモックやスタブといった代替オブジェクトを注入できます。これにより、特定の挙動を確認するユニットテストが容易になります。

# テスト用のスタブLogger
class StubLogger
  include Logger

  def log(message)
    # テスト時にはログ出力を行わない
  end
end

user = User.new("Alice", StubLogger.new)
user.create  # テスト用の動作確認

まとめ


依存性の注入を用いることで、インターフェースに依存するクラスの設計が柔軟になり、テストしやすくなります。外部からの依存オブジェクト注入によって、異なる実装間での切り替えが簡単に行えるため、メンテナンス性や拡張性が向上します。

多重継承の回避とミックスインによるインターフェースの実現

RubyにはJavaやC++のような多重継承の機能がありませんが、その代わりにミックスインという手法を使って複数のクラスに共通の機能を提供することができます。ミックスインはモジュールを利用してクラスに機能を追加するもので、インターフェースのように共通のメソッド群を定義するのに適しています。これにより、コードの再利用性を高めつつ、継承による複雑さを回避できます。

ミックスインを使ったインターフェースの実装


モジュールを用いることで、特定の機能を複数のクラスに共有させ、インターフェースとして機能させることができます。以下の例では、Drivableというモジュールを作成し、異なるクラスにドライブ機能を提供します。

module Drivable
  def drive
    "I'm driving!"
  end
end

class Car
  include Drivable
end

class Motorcycle
  include Drivable
end

ここでは、CarクラスとMotorcycleクラスの両方がDrivableモジュールを利用しています。これにより、両クラスは共通のインターフェースを持ち、それぞれでdriveメソッドが利用できるようになります。

多重継承を回避する理由


多重継承は、複数の親クラスから継承した機能が重複したり、競合したりする可能性があるため、設計が複雑化する原因になります。Rubyではモジュールを使ったミックスインにより、共通の機能を複数のクラスに柔軟に提供し、こうした複雑さを回避しています。

ミックスインの活用例


複数の異なるインターフェースを組み合わせることができるため、異なる機能をもつモジュールを組み込んで、クラスに複数の機能を追加できます。

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

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

class Duck
  include Swimmable
  include Flyable
end

この例では、DuckクラスはSwimmableとFlyableの両方のインターフェースを持つことができ、swimとflyメソッドの両方を利用できます。ミックスインを使用することで、必要に応じた機能を簡単に追加でき、コードがシンプルで保守しやすくなります。

インターフェースとミックスインを用いた設計のメリット

1. 柔軟な機能追加


モジュールを使ったミックスインにより、既存のクラスに柔軟に機能を追加できます。これにより、必要なインターフェースを後から簡単に追加し、クラスの振る舞いを変えることが可能です。

2. コードの再利用性向上


異なるクラスに対して共通の機能を提供できるため、同じコードを再利用しやすくなり、冗長な記述を減らすことができます。

まとめ


Rubyのミックスインは多重継承の複雑さを回避しながら、複数のクラスに共通のインターフェースや機能を提供する手段として非常に有効です。モジュールを活用したミックスイン設計は、コードの柔軟性と再利用性を高め、保守性の高いクラス設計を実現します。

クラス設計のアンチパターン

クラス設計を行う際に避けるべき「アンチパターン」は、コードの保守性や拡張性に悪影響を及ぼします。これらのアンチパターンを理解し、意識的に回避することで、より堅牢でメンテナンス性の高いコードを作成できます。以下に、Rubyにおける代表的なクラス設計のアンチパターンをいくつか紹介します。

1. ゴッドオブジェクト


ゴッドオブジェクト（God Object）は、システム内の多くの機能やデータを1つのクラスに集約しすぎた結果、巨大で複雑なクラスになってしまうアンチパターンです。ゴッドオブジェクトはコードの把握を困難にし、変更時のリスクを高めるため、責務を適切に分割し、クラスごとの役割を明確にすることが重要です。

対策


クラスを分割し、各クラスが単一の責務を持つようにします。例えば、ユーザー管理の処理とログ管理の処理を分離し、それぞれのクラスで担当させると良いでしょう。

2. アンチシンボリズム


Rubyにおいて、状態を示す場合にシンボルを多用すると、変更や拡張が難しくなることがあります。例えば、状態を文字列やシンボルで直接管理することで、新しい状態が追加されるたびにクラスのコードを変更する必要が生じます。

対策


状態をシンボルや文字列で管理する代わりに、状態ごとに専用のクラスやモジュールを定義することで、拡張性が向上します。

3. 不必要な継承


継承を過度に使うと、クラス間の結合が強くなり、親クラスの変更が子クラスに影響を及ぼします。不必要な継承は、コードの複雑化と予期しないバグの原因となります。

対策


継承の代わりにコンポジション（集約）を利用することで、クラス間の結合を緩め、柔軟性を確保します。例えば、CarクラスがEngineクラスのインスタンスを持つことで、エンジンの機能を継承ではなく組み込みで活用できます。

4. 設計の早すぎる最適化


システムの規模が小さいうちから複雑な最適化を行うと、設計が複雑化し、結果として保守性が損なわれる場合があります。必要以上のメソッドやモジュールが増加することで、設計が過剰になり、理解が難しくなることがあります。

対策


プログラムの規模や実際の必要性を考慮し、シンプルな設計を心がけます。不要な機能は実装せず、拡張の必要が生じたときにリファクタリングするようにします。

5. マジックナンバーの使用


コード内で意味のない数字や文字列（マジックナンバー）を直接記述すると、意味が分かりにくく、変更が発生した場合にミスを引き起こしやすくなります。マジックナンバーは、コードの可読性を低下させ、バグの原因にもなり得ます。

対策


マジックナンバーは定数に置き換え、意味のある名前を付けます。たとえば、DISCOUNT_RATE = 0.1といった定数を使うことで、意図が分かりやすくなり、変更が容易になります。

まとめ


クラス設計のアンチパターンを避けることで、Rubyでの開発がより効率的かつ堅牢になります。適切な設計原則を守り、過剰な継承や結合を避けることで、コードの拡張性や保守性を向上させることができます。

インターフェース設計におけるユニットテストの重要性

インターフェース設計においてユニットテストを行うことは、コードの品質と安定性を保証するために欠かせません。特に、共通のインターフェースを持つ複数のクラスに対してテストを行うことで、期待どおりの動作がすべてのクラスで確保されていることを確認できます。Rubyでは、RSpecやMinitestなどのテストフレームワークを使用してユニットテストを簡単に実装できます。

インターフェースに対するユニットテストの実装


ユニットテストでは、インターフェースが定義するメソッドが期待通りの動作をするかを確認します。以下は、Speakableというインターフェースを持つクラス群に対するユニットテストの例です。テストでは、すべてのクラスがSpeakableインターフェースのspeakメソッドを正しく実装しているかを確認します。

# インターフェースとしてのモジュール
module Speakable
  def speak
    raise NotImplementedError, "This method must be implemented"
  end
end

# クラスの実装
class Dog
  include Speakable

  def speak
    "Woof!"
  end
end

class Cat
  include Speakable

  def speak
    "Meow!"
  end
end

# テストケース
require 'minitest/autorun'

class SpeakableTest < Minitest::Test
  def setup
    @dog = Dog.new
    @cat = Cat.new
  end

  def test_dog_speak
    assert_equal "Woof!", @dog.speak
  end

  def test_cat_speak
    assert_equal "Meow!", @cat.speak
  end
end

このテストケースでは、DogクラスとCatクラスがSpeakableインターフェースを正しく実装しているかを確認しています。これにより、各クラスがインターフェースに準拠していることを保証できます。

ユニットテストのメリット

1. 動作保証とリグレッションテスト


インターフェースを持つクラスにユニットテストを行うことで、実装が期待通りに動作することを保証できます。また、コードの変更後に再度テストを行うことで、過去のバグが再発しないか（リグレッション）を確認でき、変更の影響範囲を把握するのにも役立ちます。

2. インターフェースの整合性の確認


複数のクラスが同一のインターフェースを実装する場合、インターフェースが一貫して動作することを確認するためにテストが不可欠です。これにより、異なるクラスでも同じインターフェースを利用できる一貫性が確保されます。

3. 開発効率の向上


ユニットテストを用意することで、各クラスが期待通りに動作するかを迅速に確認できます。これにより、エラーの発見が早まり、開発効率が向上します。

テスト駆動開発（TDD）によるインターフェース設計


テスト駆動開発（TDD）を取り入れると、まずインターフェースのテストを記述し、その後にテストをパスするコードを実装するという流れで開発が進められます。TDDはインターフェース設計において特に有効で、テストを通して実装すべきインターフェースが明確になるため、堅牢な設計が可能になります。

まとめ


インターフェース設計におけるユニットテストは、コードの信頼性と保守性を向上させる重要な手段です。テストを通して一貫性を確認し、コードのリグレッションを防止することで、変更に強く堅牢なインターフェース設計を実現できます。

実践例：継承とインターフェースを活用したシステム設計

ここでは、Rubyで継承とインターフェースを組み合わせて、実践的なシステムを設計する例を紹介します。このシステムでは、さまざまな支払い方法を持つPaymentクラス群を構築し、共通のインターフェースを使って一貫した処理を行います。Paymentクラスは抽象クラスとして定義し、具体的な支払い方法（クレジットカード、銀行送金、キャッシュ）をサブクラスで実装します。インターフェースにはprocessメソッドを含み、各支払い方法に応じた処理を実装します。

抽象クラスとインターフェースの設計

まず、Paymentという抽象クラスを作成し、processメソッドをインターフェースとして定義します。各支払い方法のクラスでこのメソッドを具体的に実装することで、異なる支払い方法に対応した処理を行います。

class Payment
  def process
    raise NotImplementedError, "This method must be implemented in a subclass"
  end
end

具体的な支払いクラスの実装

各支払い方法のクラスがPaymentを継承し、processメソッドを実装します。以下の例では、CreditCardPayment、BankTransferPayment、CashPaymentの3種類の支払いクラスを定義しています。

class CreditCardPayment < Payment
  def process
    "Processing credit card payment..."
  end
end

class BankTransferPayment < Payment
  def process
    "Processing bank transfer payment..."
  end
end

class CashPayment < Payment
  def process
    "Processing cash payment..."
  end
end

これにより、各クラスは異なる支払い方法に対応した処理を持ち、それぞれのクラスで個別のロジックを実装できるようになります。

支払い処理を統一するインターフェースの利用

以下のように、支払い方法にかかわらず、すべての支払いオブジェクトでprocessメソッドを呼び出すことができます。これにより、異なる支払い方法でも一貫した操作が可能です。

def process_payment(payment)
  puts payment.process
end

# 支払いインスタンスの作成
credit_payment = CreditCardPayment.new
bank_payment = BankTransferPayment.new
cash_payment = CashPayment.new

# 支払い処理の実行
process_payment(credit_payment)  # Output: "Processing credit card payment..."
process_payment(bank_payment)    # Output: "Processing bank transfer payment..."
process_payment(cash_payment)    # Output: "Processing cash payment..."

このprocess_paymentメソッドは、共通のインターフェースを利用して支払いオブジェクトを受け取り、どの支払い方法であってもprocessメソッドを実行します。この設計により、システムに新たな支払い方法が追加された場合も、新しいクラスでprocessメソッドを実装するだけで統一的に処理できるようになります。

実装のメリット

1. 拡張性の向上


新しい支払い方法を追加する際に、新しいクラスを追加し、processメソッドを実装するだけでシステム全体に影響を与えずに拡張可能です。

2. メンテナンス性の向上


支払い処理のロジックを各支払い方法クラスに分離することで、特定の支払い方法に関する変更が必要な場合、該当クラスのみの修正で対応でき、メンテナンスが容易になります。

3. 一貫性のあるインターフェース


processメソッドという共通のインターフェースを使用することで、異なる支払い方法を一貫して操作でき、コードの可読性が向上します。

まとめ


継承とインターフェースを用いたシステム設計は、拡張性とメンテナンス性を向上させ、柔軟で一貫性のある操作を実現します。この設計を活用することで、異なるクラスに共通のインターフェースを持たせ、再利用性の高いコードを構築できます。

まとめ

本記事では、Rubyにおける継承とインターフェース設計の基礎から実践例までを解説しました。継承を利用して親クラスの機能を再利用しつつ、インターフェースやミックスインを活用することで、多様なクラスに共通の機能を持たせる設計が可能です。特に、インターフェースに基づく設計は、拡張性やメンテナンス性の向上に貢献し、柔軟で一貫性のあるコードを実現します。

継承やモジュール、依存性の注入といった設計パターンを適切に組み合わせることで、Rubyプログラムの再利用性と保守性が高まります。今回紹介した実践的な設計手法をもとに、より堅牢で拡張性の高いシステム構築に役立ててください。

Ruby
インターフェース 継承 クラス設計 Ruby

コメント

コメントする

目次
  1. クラスの継承とインターフェース設計の基礎
    1. 継承の基本構文
    2. インターフェースの役割
  2. 継承を使ったクラス再利用のメリットとデメリット
    1. メリット
    2. デメリット
    3. 継承の適切な利用
  3. インターフェース設計の実践例
    1. モジュールを用いたインターフェースの実装
    2. インターフェースの活用例
    3. まとめ
  4. 抽象クラスとモジュールの活用
    1. 抽象クラスの実装
    2. モジュールの活用による機能共有
    3. 抽象クラスとモジュールの組み合わせ
    4. まとめ
  5. 依存性の注入を用いたインターフェースの実装
    1. 依存性の注入の基本概念
    2. 依存性の注入の実装例
    3. 依存性の注入を用いるメリット
    4. まとめ
  6. 多重継承の回避とミックスインによるインターフェースの実現
    1. ミックスインを使ったインターフェースの実装
    2. 多重継承を回避する理由
    3. ミックスインの活用例
    4. インターフェースとミックスインを用いた設計のメリット
    5. まとめ
  7. クラス設計のアンチパターン
    1. 1. ゴッドオブジェクト
    2. 2. アンチシンボリズム
    3. 3. 不必要な継承
    4. 4. 設計の早すぎる最適化
    5. 5. マジックナンバーの使用
    6. まとめ
  8. インターフェース設計におけるユニットテストの重要性
    1. インターフェースに対するユニットテストの実装
    2. ユニットテストのメリット
    3. テスト駆動開発（TDD）によるインターフェース設計
    4. まとめ
  9. 実践例：継承とインターフェースを活用したシステム設計
    1. 抽象クラスとインターフェースの設計
    2. 具体的な支払いクラスの実装
    3. 支払い処理を統一するインターフェースの利用
    4. 実装のメリット
    5. まとめ
  10. まとめ