MENU
  1. ホーム
  2. Ruby
  3. Rubyで実現する直感的なメソッドチェーンによるクラス設計の実装方法

Rubyで実現する直感的なメソッドチェーンによるクラス設計の実装方法

Ruby

Rubyの特徴的なコーディングスタイルの一つとして、メソッドチェーンがあります。メソッドチェーンとは、複数のメソッドを連続して呼び出すことができる構文で、コードを直感的で簡潔に記述できる点が魅力です。この技法を活用することで、Rubyプログラムにおいて、より読みやすく管理しやすいコードを実現することが可能になります。

本記事では、Rubyでメソッドチェーンを活用したクラス設計の手法について、基礎から応用までを解説します。クラス設計にメソッドチェーンを取り入れることで、どのように直感的なAPI設計や柔軟なオブジェクト構造を実現できるか、具体例を通して学んでいきましょう。

目次
  1. メソッドチェーンとは？
    1. メソッドチェーンの構文例
    2. Rubyでの利用シーン
  2. メソッドチェーンの利点
    1. コードの簡潔性
    2. 可読性の向上
    3. 柔軟で一貫性のある設計
    4. フルエントインターフェースとしての利用
  3. 基本的なクラス設計方法
    1. 1. 初期設定のメソッド
    2. 2. 自身を返すメソッドの定義
    3. 3. チェーンの流れを意識したメソッド設計
    4. 4. インターフェースの一貫性を保つ
    5. 5. チェーン可能なメソッド設計の確認
  4. メソッドチェーンを活用したプロパティ設定
    1. プロパティ設定メソッドの設計
    2. プロパティ設定の例
    3. チェーン可能なプロパティ設定の利点
    4. その他のプロパティ設定メソッドの追加
  5. メソッドチェーンとエラーハンドリング
    1. エラー処理の基本設計
    2. 例外処理を利用したメソッドチェーンの安全性向上
    3. エラー情報の保持と確認
    4. エラーハンドリングのまとめ
  6. メソッドチェーンとファクトリメソッド
    1. ファクトリメソッドとは？
    2. ファクトリメソッドを用いたメソッドチェーンの実装
    3. 複数のファクトリメソッドの活用
    4. ファクトリメソッドとメソッドチェーンの利点
  7. 実装例：メソッドチェーン対応のユーザークラス
    1. ユーザークラスの定義
    2. メソッドチェーンを使ったユーザー設定の例
    3. 応用例：異なるプロパティの組み合わせ設定
    4. この実装の利点
  8. 応用例：複雑なメソッドチェーン構築
    1. 応用例：条件付きメソッドチェーン
    2. 複数の処理を組み合わせたメソッドチェーン
    3. 応用的なメソッドチェーン設計の利点
  9. まとめ

メソッドチェーンとは？


メソッドチェーンとは、オブジェクト指向プログラミングで複数のメソッドを連続して呼び出す技法のことです。Rubyでは、各メソッドがオブジェクト自身を返すことで、メソッドを連鎖的に実行できるため、メソッドチェーンが自然に実現されます。この手法により、コードを一行で簡潔に書き、処理の流れを視覚的に表現することが可能です。

メソッドチェーンの構文例


メソッドチェーンのシンプルな例を以下に示します。この例では、複数のメソッドを連続的に呼び出し、処理が一つのまとまりとしてわかりやすく表現されています。

user = User.new
user.set_name("Alice").set_age(25).activate

この例では、set_name、set_age、activateといったメソッドが連続的に呼び出されており、それぞれがUserオブジェクトを返すことで、チェーンが途切れることなく処理を続けています。

Rubyでの利用シーン


Rubyのメソッドチェーンは、主に以下のような場面で使われます。

  • オブジェクトの初期設定：インスタンス生成後のプロパティ設定を連続的に行う。
  • データ変換処理：データを複数のステップで加工する際、メソッドチェーンで変換手順をまとめる。
  • フルエントインターフェースの実現：直感的なインターフェースを提供し、コードの可読性を高める。

このように、メソッドチェーンを使うことで、可読性が向上し、コードをより表現力豊かに記述できるため、Rubyの開発において頻繁に活用されます。

メソッドチェーンの利点


メソッドチェーンを活用することで、Rubyのコードはより直感的で可読性の高いものになります。メソッドチェーンが持つ主な利点について、以下に詳しく解説します。

コードの簡潔性


メソッドチェーンを使用することで、複数のメソッド呼び出しを1行にまとめられるため、コード全体が簡潔になりやすくなります。これにより、無駄なコードや行数が減少し、プログラムがコンパクトにまとまります。

# メソッドチェーンを使わない場合
user = User.new
user.set_name("Alice")
user.set_age(25)
user.activate

# メソッドチェーンを使った場合
user = User.new.set_name("Alice").set_age(25).activate

メソッドチェーンを使うことで、コードをスッキリさせ、どのような処理が連続して行われているのかを一目で理解できるようになります。

可読性の向上


メソッドチェーンは、コードの流れを視覚的に表現できるため、処理内容を直感的に理解しやすくします。処理のステップが順序通りに並び、コードが自然なフローとして捉えられるため、他の開発者がコードを読みやすくなります。

柔軟で一貫性のある設計


メソッドチェーンを活用すると、オブジェクトが一貫して自身を返す設計が推奨されるため、APIの一貫性を確保しやすくなります。これにより、オブジェクトが持つプロパティの設定や操作が柔軟に行えるようになり、使いやすいインターフェースが実現します。

フルエントインターフェースとしての利用


フルエントインターフェース（fluent interface）は、オブジェクト指向デザインパターンの一つで、メソッドチェーンを多用して直感的なインターフェースを実現するものです。これにより、Rubyコードが自然言語のような流れになり、インターフェースとして非常に使いやすい設計が可能です。

メソッドチェーンの利点を理解することで、直感的かつメンテナンスしやすいコードが書けるようになります。これにより、コードの保守性と可読性が向上し、開発効率も高まります。

基本的なクラス設計方法


メソッドチェーンを活用するためには、クラス設計の段階で各メソッドがオブジェクト自身を返すように工夫する必要があります。この章では、メソッドチェーンに適したクラス設計の基本手順を解説します。

1. 初期設定のメソッド


まず、クラスの初期設定としてインスタンス変数の設定やデフォルト値の定義を行います。初期設定はコンストラクタ内で行い、初期化のための設定をメソッドチェーンで繋げられるようにします。

class User
  def initialize
    @name = ""
    @age = 0
    @active = false
  end
end

2. 自身を返すメソッドの定義


メソッドチェーンに対応するには、各メソッドがオブジェクト自身を返すように設計します。これにより、メソッドを続けて呼び出すことが可能になります。以下の例では、set_name、set_age、activateメソッドを定義し、それぞれselfを返すようにしています。

class User
  def set_name(name)
    @name = name
    self  # selfを返すことでチェーンを実現
  end

  def set_age(age)
    @age = age
    self
  end

  def activate
    @active = true
    self
  end
end

3. チェーンの流れを意識したメソッド設計


メソッドチェーンを設計する際は、クラスのAPIが直感的に利用できるようにすることが重要です。メソッドが順序立てて呼び出されるように意識し、チェーンの流れが自然になるように設計します。例えば、プロパティ設定メソッドの後にアクションメソッドを続けられるようにするなど、ユーザーが思い描く操作順序に従うことがポイントです。

4. インターフェースの一貫性を保つ


各メソッドが一貫してselfを返すことで、利用者にとって予測しやすいインターフェースが提供されます。これにより、クラスを利用する際の迷いが減り、クラスの再利用性や拡張性も向上します。

5. チェーン可能なメソッド設計の確認


メソッドチェーンが正しく動作するかをテストし、期待通りにオブジェクトが返されることを確認します。以下のコード例は、ユーザーが名前と年齢を設定し、アクティブ化する一連の流れを表しています。

user = User.new
user.set_name("Alice").set_age(25).activate

以上が、メソッドチェーンを意識した基本的なクラス設計方法です。このような設計により、コードが直感的に書けるようになり、開発効率も向上します。

メソッドチェーンを活用したプロパティ設定


メソッドチェーンを使用することで、クラスのプロパティを連続して設定することができ、コードが一行でスッキリとまとめられます。この章では、メソッドチェーンを使って複数のプロパティを簡潔に設定する方法を解説します。

プロパティ設定メソッドの設計


メソッドチェーンでプロパティを設定するには、各設定メソッドがselfを返すように設計する必要があります。これにより、他のプロパティ設定メソッドと連続して呼び出すことが可能になります。

class User
  def initialize
    @name = ""
    @age = 0
  end

  def set_name(name)
    @name = name
    self
  end

  def set_age(age)
    @age = age
    self
  end
end

プロパティ設定の例


以下の例では、set_nameとset_ageを連続して呼び出し、名前と年齢の両方を一行で設定しています。こうすることで、コードの流れがわかりやすく、より直感的な設定が可能です。

user = User.new.set_name("Alice").set_age(25)

チェーン可能なプロパティ設定の利点


メソッドチェーンによるプロパティ設定には、以下の利点があります。

  • コードの簡潔化：プロパティ設定をまとめて一行で書くことができるため、コードがスッキリと整理されます。
  • 可読性の向上：設定内容が連続して並ぶため、各設定項目が一目でわかります。
  • 柔軟性の向上：複数のプロパティ設定を組み合わせて使うことができ、クラスの使用方法が自然な形になります。

その他のプロパティ設定メソッドの追加


必要に応じて他のプロパティ設定メソッドを追加することで、チェーンの幅を広げることが可能です。例えば、ユーザーのメールアドレスや住所など、追加の設定メソッドも以下のように設計できます。

class User
  def set_email(email)
    @email = email
    self
  end

  def set_address(address)
    @address = address
    self
  end
end

このようにしてメソッドチェーンを活用することで、必要なプロパティを一度に設定でき、使いやすいAPIを提供するクラスを設計することができます。

メソッドチェーンとエラーハンドリング


メソッドチェーンはコードを簡潔にする一方で、エラーが発生した際の処理が重要になります。特に、プロパティ設定やオブジェクトの状態に依存する操作がチェーン内に含まれる場合、適切なエラーハンドリングが不可欠です。この章では、メソッドチェーンにおけるエラーハンドリングの実装方法について解説します。

エラー処理の基本設計


メソッドチェーン内でエラーが発生した場合、通常はエラーメッセージを表示したり、例外を発生させたりしますが、エラーが発生してもチェーンが途切れないようにselfを返す設計も可能です。この方法により、エラー発生後のメソッドを安全に呼び出せるようになります。

class User
  def set_name(name)
    if name.is_a?(String) && !name.empty?
      @name = name
    else
      puts "Error: Invalid name"
    end
    self
  end

  def set_age(age)
    if age.is_a?(Integer) && age > 0
      @age = age
    else
      puts "Error: Invalid age"
    end
    self
  end
end

この例では、set_nameとset_ageメソッド内で、データが無効な場合にエラーメッセージを表示し、無効なデータが入力されてもチェーンを継続できるようになっています。

例外処理を利用したメソッドチェーンの安全性向上


メソッドチェーンの途中で重大なエラーが発生した場合、例外を発生させることでより厳密なエラーチェックを行うことも可能です。例外を発生させた場合、通常はチェーン全体が中断されるため、重大なエラーがあった場合にのみ例外を発生させる設計が推奨されます。

class User
  def set_age(age)
    raise ArgumentError, "Age must be a positive integer" unless age.is_a?(Integer) && age > 0
    @age = age
    self
  end
end

この設計では、年齢に無効なデータが入力された場合、ArgumentError例外が発生し、以降の処理が停止します。

エラー情報の保持と確認


エラー情報をオブジェクトに保持しておき、チェーン終了後にエラーがあったかどうかを確認する設計も考えられます。この場合、エラーが発生したメソッドではエラーメッセージやフラグを保持し、後で確認できるようにします。

class User
  attr_reader :errors

  def initialize
    @errors = []
  end

  def set_name(name)
    if name.is_a?(String) && !name.empty?
      @name = name
    else
      @errors << "Invalid name"
    end
    self
  end

  def set_age(age)
    if age.is_a?(Integer) && age > 0
      @age = age
    else
      @errors << "Invalid age"
    end
    self
  end
end

user = User.new.set_name("").set_age(-5)
puts user.errors unless user.errors.empty?

この例では、エラーがある場合にそのエラー情報を保持し、後で確認することができます。こうすることで、エラーの詳細を確認しやすくし、適切な対処が可能になります。

エラーハンドリングのまとめ


メソッドチェーンを安全かつ効果的に利用するためには、エラーハンドリングが重要です。必要に応じてエラーメッセージの表示、例外の発生、エラー情報の保持などを組み合わせることで、チェーンを途切れさせずに柔軟なエラーハンドリングを実現できます。

メソッドチェーンとファクトリメソッド


メソッドチェーンとファクトリメソッドを組み合わせることで、より直感的で柔軟なクラス設計が可能になります。ファクトリメソッドを使うと、特定の条件に応じたオブジェクトの生成や初期設定を簡単に行え、メソッドチェーンを通して直感的なインターフェースを提供できます。この章では、ファクトリメソッドとメソッドチェーンの組み合わせ方について解説します。

ファクトリメソッドとは？


ファクトリメソッドは、オブジェクトの生成や初期化を行うメソッドで、通常のコンストラクタよりも柔軟なオブジェクト生成が可能になります。特定のパラメータに応じて異なる初期設定を行いたい場合や、オブジェクト生成時に必要な前処理を実行したい場合に便利です。

class User
  def self.create_with_name(name)
    new.set_name(name)
  end
end

このcreate_with_nameメソッドは、Userオブジェクトを生成し、名前を設定した状態で返します。ファクトリメソッドがselfを返すことで、メソッドチェーンに自然に組み込むことができます。

ファクトリメソッドを用いたメソッドチェーンの実装


ファクトリメソッドを使って、オブジェクトの生成とプロパティの初期設定をチェーン化することで、柔軟なオブジェクト生成が可能になります。例えば、ユーザーの名前と年齢を同時に設定してからオブジェクトを返すファクトリメソッドを以下のように実装できます。

class User
  def self.create_with_name_and_age(name, age)
    new.set_name(name).set_age(age)
  end

  def set_name(name)
    @name = name
    self
  end

  def set_age(age)
    @age = age
    self
  end
end

user = User.create_with_name_and_age("Alice", 25)

この例では、create_with_name_and_ageメソッドがユーザーの名前と年齢を設定し、それを連続したメソッドチェーンで行っています。これにより、オブジェクト生成と初期設定が一行で行え、より簡潔なコードが実現できます。

複数のファクトリメソッドの活用


複数のファクトリメソッドを用意することで、ユーザーが求める異なる初期設定に応じたオブジェクト生成を簡単に実現できます。例えば、ユーザーの初期状態がアクティブかどうかを設定するファクトリメソッドを追加することも可能です。

class User
  def self.create_active_user(name, age)
    new.set_name(name).set_age(age).activate
  end

  def activate
    @active = true
    self
  end
end

user = User.create_active_user("Bob", 30)

この例では、create_active_userメソッドが名前と年齢を設定し、さらにユーザーをアクティブ化するメソッドチェーンを使用しています。これにより、生成時の初期設定がより柔軟になり、直感的に使えるインターフェースを提供できます。

ファクトリメソッドとメソッドチェーンの利点


ファクトリメソッドとメソッドチェーンを組み合わせることで、以下のような利点が得られます。

  • コードの簡潔化：オブジェクト生成と初期設定を一行で行えるため、コードが簡潔で読みやすくなります。
  • 柔軟なインターフェース提供：ファクトリメソッドを使うことで、ユーザーが選択できる生成パターンが増え、使いやすいAPIが実現します。
  • 再利用性の向上：ファクトリメソッドに初期設定をまとめることで、同じ設定が必要な場合にコードを再利用しやすくなります。

このように、ファクトリメソッドとメソッドチェーンを組み合わせると、Rubyのコードはさらに直感的で使いやすいものになります。クラス設計の柔軟性を高め、ユーザーが自然に使えるインターフェースを提供できるため、複雑なオブジェクトの生成や設定が求められる場面で特に有効です。

実装例：メソッドチェーン対応のユーザークラス


ここでは、メソッドチェーンを活用した実際のユーザークラスの実装例を紹介します。このクラスは、ユーザー情報の設定をチェーンで行うことができ、可読性と使いやすさを両立した設計になっています。プロフィール設定などを一度に完結させられるため、実用的な例として応用が効きます。

ユーザークラスの定義


以下は、名前、年齢、メールアドレス、住所の設定に対応したメソッドチェーン対応のUserクラスです。また、ユーザーのステータス（アクティブ/非アクティブ）を管理するactivateメソッドも含まれています。

class User
  attr_reader :name, :age, :email, :address, :active

  def initialize
    @name = ""
    @age = 0
    @active = false
  end

  def set_name(name)
    @name = name
    self
  end

  def set_age(age)
    @age = age
    self
  end

  def set_email(email)
    @email = email
    self
  end

  def set_address(address)
    @address = address
    self
  end

  def activate
    @active = true
    self
  end
end

このUserクラスでは、各メソッドがselfを返しており、メソッドチェーンが可能です。各設定メソッドでは、@nameや@ageなどのインスタンス変数に値を割り当ててからselfを返しています。

メソッドチェーンを使ったユーザー設定の例


以下のコード例では、ユーザーの名前、年齢、メールアドレス、住所を一行で設定し、アクティブ化しています。これにより、ユーザーのプロフィール情報を簡潔にまとめて設定することが可能です。

user = User.new
user.set_name("Alice")
     .set_age(25)
     .set_email("alice@example.com")
     .set_address("123 Ruby Lane")
     .activate

# 出力確認
puts "Name: #{user.name}"
puts "Age: #{user.age}"
puts "Email: #{user.email}"
puts "Address: #{user.address}"
puts "Active: #{user.active}"

このように、メソッドチェーンを使用することで、ユーザーの設定が一貫したフローとしてまとめられ、コードがわかりやすくなります。各メソッドの呼び出しが連続しているため、設定内容が一目で理解できる点も利点です。

応用例：異なるプロパティの組み合わせ設定


このクラスは、必要に応じて様々なプロパティの組み合わせで設定を行うことができます。たとえば、メールアドレスの設定を省略して住所だけを設定する場合でも、メソッドチェーンを崩さずに実行可能です。

user = User.new
user.set_name("Bob")
     .set_age(30)
     .set_address("456 Ruby Road")
     .activate

puts "Name: #{user.name}"
puts "Age: #{user.age}"
puts "Address: #{user.address}"
puts "Active: #{user.active}"

この実装の利点


メソッドチェーン対応のクラスを実装することで、以下のような利点が得られます。

  • コードの可読性向上：一連の設定が流れるように記述でき、コードの意図がわかりやすくなります。
  • 直感的な操作：各メソッドが一貫してselfを返すため、設定操作が直感的に行えます。
  • 柔軟な組み合わせ：必要なプロパティだけを選んで設定することができ、柔軟性が高まります。

この実装例により、メソッドチェーンを使ったクラス設計の効果を実感できるでしょう。ユーザー設定のような複数のプロパティを持つクラスで特に役立ちます。

応用例：複雑なメソッドチェーン構築


メソッドチェーンは、シンプルなプロパティ設定だけでなく、複雑な操作をまとめる際にも有効です。ここでは、さらに高度なメソッドチェーンを使って、条件付き設定や複数の処理を組み合わせる応用例を紹介します。この応用例を通じて、複雑な処理を直感的にまとめ、効率よく実装する方法を学びましょう。

応用例：条件付きメソッドチェーン


複雑なチェーン操作には、条件付きでメソッドを呼び出す処理を組み込むと、さらに柔軟な設定が可能になります。以下の例では、ユーザーが年齢に応じてアクティブ化されるかを決定するメソッドを追加しています。

class User
  attr_reader :name, :age, :email, :address, :active

  def initialize
    @name = ""
    @age = 0
    @active = false
    @vip = false
  end

  def set_name(name)
    @name = name
    self
  end

  def set_age(age)
    @age = age
    self
  end

  def set_email(email)
    @email = email
    self
  end

  def set_address(address)
    @address = address
    self
  end

  def activate_if_adult
    @active = true if @age >= 18
    self
  end

  def mark_as_vip
    @vip = true
    self
  end
end

この例のactivate_if_adultメソッドは、ユーザーが18歳以上であれば自動的にアクティブ化される条件付き設定を行っています。以下のようにメソッドチェーンで利用することで、年齢に基づいた柔軟な設定が可能です。

user = User.new
user.set_name("Alice")
     .set_age(20)
     .set_email("alice@example.com")
     .set_address("123 Ruby Lane")
     .activate_if_adult
     .mark_as_vip

# 出力確認
puts "Name: #{user.name}"
puts "Age: #{user.age}"
puts "Active: #{user.active}"  # => true (20歳なのでアクティブ化される)
puts "VIP: #{user.vip}"        # => true

複数の処理を組み合わせたメソッドチェーン


さらに、複数の処理をチェーンで組み合わせて、ユーザーが特定の条件を満たした場合にのみ追加の設定を行うケースを作り出せます。例えば、ユーザーをVIPとしてマークし、特別な設定を行うメソッドを追加することで、条件によって異なる処理を柔軟にチェーンできます。

class User
  # 既存のコード...

  def grant_special_privileges
    @special_privileges = true if @vip
    self
  end
end

このgrant_special_privilegesメソッドは、ユーザーがVIPである場合に特別な権限を付与します。メソッドチェーンを用いることで、複数の条件を満たす場合のみに特別な設定を行うことが可能です。

user = User.new
user.set_name("Bob")
     .set_age(25)
     .set_email("bob@example.com")
     .mark_as_vip
     .grant_special_privileges

puts "Name: #{user.name}"
puts "VIP: #{user.vip}"                       # => true
puts "Special Privileges: #{user.special_privileges}" # => true

応用的なメソッドチェーン設計の利点


このような複雑なメソッドチェーンを活用することで、以下のようなメリットが得られます。

  • 柔軟な条件分岐：条件に応じて異なる処理や設定を自然に組み込むことができます。
  • 直感的なコード：条件付きの設定がメソッドチェーンで表現され、コードがさらに読みやすくなります。
  • 一貫した操作フロー：複雑な操作や設定を一貫して行うことができ、操作の流れが明確になります。

複雑なメソッドチェーンを用いることで、Rubyのクラス設計がさらにパワフルになり、様々な操作を自然に組み合わせられるようになります。特に条件付き設定や高度なオブジェクト操作が必要な場合に、この応用的なチェーン構築は効果を発揮します。

まとめ


本記事では、Rubyでメソッドチェーンを活用したクラス設計の方法について、基礎から応用までを解説しました。メソッドチェーンを用いることで、コードの可読性や操作性が向上し、直感的で簡潔なAPIを提供するクラス設計が可能になります。

メソッドチェーンを実現するための基本的なクラス設計から、エラーハンドリングやファクトリメソッド、さらに条件付き処理や複数の操作を組み合わせた応用例までを紹介しました。これにより、柔軟かつ強力なクラス設計が可能になり、Rubyの特性を活かした開発が行えるようになります。

メソッドチェーンを駆使して、直感的で使いやすいクラス設計を実現し、より効率的なRubyプログラムの開発に役立ててください。

Ruby
クラス設計 Ruby メソッドチェーン

コメント

コメントする

目次
  1. メソッドチェーンとは？
    1. メソッドチェーンの構文例
    2. Rubyでの利用シーン
  2. メソッドチェーンの利点
    1. コードの簡潔性
    2. 可読性の向上
    3. 柔軟で一貫性のある設計
    4. フルエントインターフェースとしての利用
  3. 基本的なクラス設計方法
    1. 1. 初期設定のメソッド
    2. 2. 自身を返すメソッドの定義
    3. 3. チェーンの流れを意識したメソッド設計
    4. 4. インターフェースの一貫性を保つ
    5. 5. チェーン可能なメソッド設計の確認
  4. メソッドチェーンを活用したプロパティ設定
    1. プロパティ設定メソッドの設計
    2. プロパティ設定の例
    3. チェーン可能なプロパティ設定の利点
    4. その他のプロパティ設定メソッドの追加
  5. メソッドチェーンとエラーハンドリング
    1. エラー処理の基本設計
    2. 例外処理を利用したメソッドチェーンの安全性向上
    3. エラー情報の保持と確認
    4. エラーハンドリングのまとめ
  6. メソッドチェーンとファクトリメソッド
    1. ファクトリメソッドとは？
    2. ファクトリメソッドを用いたメソッドチェーンの実装
    3. 複数のファクトリメソッドの活用
    4. ファクトリメソッドとメソッドチェーンの利点
  7. 実装例：メソッドチェーン対応のユーザークラス
    1. ユーザークラスの定義
    2. メソッドチェーンを使ったユーザー設定の例
    3. 応用例：異なるプロパティの組み合わせ設定
    4. この実装の利点
  8. 応用例：複雑なメソッドチェーン構築
    1. 応用例：条件付きメソッドチェーン
    2. 複数の処理を組み合わせたメソッドチェーン
    3. 応用的なメソッドチェーン設計の利点
  9. まとめ