Rubyのプログラミングにおいて、self
キーワードは、インスタンスやクラスのコンテキストを理解する上で非常に重要な役割を果たします。このキーワードは、メソッド内でのレシーバや、クラス定義時の参照先を明確にするために使用され、プログラムの動作を理解しやすくします。しかし、self
の正確な動作を理解しないと、意図しない挙動やエラーが発生する可能性があります。本記事では、Rubyにおけるself
の使い方や、インスタンスとクラスの違い、そして効果的にself
を活用するためのポイントについて詳しく解説していきます。
`self`キーワードの基本概念
Rubyにおけるself
は、「現在のオブジェクト」を指し示すキーワードです。self
を使うことで、その場においてメソッドの呼び出しや属性の参照が、どのオブジェクトに向けられているのかを明確にできます。self
は、コードの実行中に状況に応じて異なるオブジェクトを指すため、動的な言語であるRubyならではの柔軟な機能といえます。
現在のオブジェクトの参照
例えば、インスタンスメソッドの中でself
を使うと、そのメソッドを呼び出したインスタンスを参照します。一方、クラス定義の中でself
を使うと、そのクラス自体を指すことになります。このように、self
の役割は、使用する場面により変化しますが、いずれも「今この場所で操作しているオブジェクト」を示すという共通点があります。
`self`が必要となる場面
以下のような場面でself
を使用することが一般的です。
- クラスやインスタンスメソッド内での属性の明示的な参照や更新
- クラスメソッドを定義する際に、クラスを指す
self
を利用してメソッドを宣言 - メソッドチェーンの途中でオブジェクトの文脈を保つための参照
クラスコンテキストでの`self`
クラス定義内で使用されるself
は、そのクラス自体を指します。このため、クラスのコンテキストでself
を使うことで、クラスメソッドやクラス属性を定義したり参照したりすることが可能です。クラスのコンテキストでのself
の理解は、Rubyのオブジェクト指向プログラミングにおいて重要な基礎となります。
クラスメソッドの定義
クラスメソッドとは、特定のインスタンスではなく、クラス全体に対して呼び出すメソッドです。Rubyでは、クラス内でself
を使ってクラスメソッドを定義できます。以下のように、self
を利用してクラスメソッドを宣言します。
class MyClass
def self.class_method
puts "This is a class method"
end
end
MyClass.class_method # => "This is a class method"
上記の例では、self.class_method
とすることでMyClass
クラス自体にメソッドを定義しています。このように、self
を利用することで、クラスそのものに属するメソッドを簡潔に作成できます。
クラス変数と`self`
クラスのコンテキストでself
を使用することで、クラス変数にアクセスしたり更新したりできます。たとえば、クラスレベルで共通の設定やカウンタを保持する場合にself
を使うと便利です。
class MyClass
@count = 0
def self.increment_count
@count += 1
end
def self.count
@count
end
end
MyClass.increment_count
puts MyClass.count # => 1
このように、クラスのコンテキストでself
を使うことで、クラス全体で共通して使用される変数やメソッドを定義し、管理することができます。
インスタンスコンテキストでの`self`
インスタンスメソッド内で使用されるself
は、そのメソッドを呼び出したインスタンス自体を指します。これにより、インスタンスの属性にアクセスしたり、インスタンスメソッドを呼び出したりする際に、self
を利用して対象を明確にすることができます。
インスタンス変数と`self`
インスタンスメソッド内でインスタンス変数を操作する場合、通常は変数名だけでアクセスできますが、self
を使うとそのインスタンスが明示的に参照されていることが明らかになります。たとえば、次のようなコードでself
を使うと、インスタンス変数がどのオブジェクトに関連しているのかを把握しやすくなります。
class Person
def initialize(name)
@name = name
end
def display_name
puts "Name: #{self.name}"
end
def name
@name
end
end
person = Person.new("Alice")
person.display_name # => "Name: Alice"
ここでは、self.name
によってそのインスタンスのname
メソッドを呼び出しています。インスタンス変数(@name)はそのインスタンスに固有のデータを保持し、各インスタンスごとに独立した値を持つことができます。
インスタンスメソッドの呼び出し
インスタンスメソッド内で他のインスタンスメソッドを呼び出す際にも、self
を使用して明示的にメソッドを呼ぶことができます。たとえば、次の例ではself
を使って、同じインスタンスに属する別のメソッドを呼び出しています。
class Calculator
def add(a, b)
a + b
end
def multiply_and_add(a, b, c)
result = self.add(a, b) * c
puts "Result: #{result}"
end
end
calc = Calculator.new
calc.multiply_and_add(2, 3, 4) # => "Result: 20"
この例では、self.add(a, b)
によって同じインスタンス内のadd
メソッドが呼び出され、その結果が計算に使用されています。self
を使うことで、インスタンスメソッドが属するインスタンスを明確に参照し、理解しやすいコードを書くことが可能になります。
`self`を用いたメソッドの呼び出し
Rubyにおいて、self
を用いることで、同一インスタンス内に存在するメソッドを明示的に呼び出すことができます。これにより、プログラム内でメソッドを参照する対象を明確にし、意図した動作を実現できます。また、self
を使うことで、メソッドチェーンの一部として他のメソッドを呼び出す際にも役立ちます。
明示的なメソッド呼び出し
インスタンス内のメソッドを呼び出す場合、self
を使わずにメソッド名だけでも実行可能ですが、あえてself
を使うことでそのメソッドがインスタンス自身に属していることを明確に示すことができます。以下の例では、self
を使ってインスタンスメソッドを呼び出しています。
class Car
def initialize(make, model)
@make = make
@model = model
end
def display_info
puts "Make: #{self.make}, Model: #{self.model}"
end
def make
@make
end
def model
@model
end
end
car = Car.new("Toyota", "Corolla")
car.display_info # => "Make: Toyota, Model: Corolla"
ここでは、self.make
やself.model
とすることで、make
やmodel
メソッドが同じインスタンス内に存在することが明示されています。このようにself
を用いると、メソッドがどのコンテキストに属しているのかがわかりやすくなります。
セッターメソッドでの`self`の使用
セッターメソッド(属性の設定用メソッド)でself
を使うことも重要です。Rubyでは、インスタンス変数の値を設定するためにセッターメソッドを定義することが多いですが、セッターメソッドを呼び出す際にself
が必要になります。
class Person
attr_accessor :name
def set_name(new_name)
self.name = new_name
end
end
person = Person.new
person.set_name("Bob")
puts person.name # => "Bob"
この例では、self.name = new_name
とすることで、name=
メソッド(セッターメソッド)が正しく呼び出されています。self
を省略すると、単なるローカル変数の代入と解釈されてしまうため、セッターメソッドを呼び出す際にはself
が必要です。
メソッドチェーンでの`self`
self
を返すことで、メソッドチェーンを作成することもできます。メソッドチェーンを用いることで、複数のメソッドを連続して呼び出すことが可能です。
class Calculator
attr_accessor :value
def initialize
@value = 0
end
def add(n)
@value += n
self
end
def subtract(n)
@value -= n
self
end
def result
puts "Final result: #{@value}"
end
end
calc = Calculator.new
calc.add(10).subtract(5).result # => "Final result: 5"
この例では、add
とsubtract
メソッドがself
を返すようにしているため、メソッドチェーンとして複数のメソッドを連続して呼び出すことができます。
クラス変数とインスタンス変数の違い
Rubyでは、クラス変数とインスタンス変数はそれぞれ異なる目的で使用され、スコープや値の保持の仕方にも違いがあります。ここでは、両者の違いを理解しやすいコード例とともに解説します。
インスタンス変数
インスタンス変数(@variable_name
)は、インスタンスごとに独立して値を保持します。インスタンス変数は、そのインスタンスの属性として使用され、オブジェクト間で共有されることはありません。以下の例では、インスタンス変数@name
が各インスタンスで個別に保持されていることがわかります。
class User
def initialize(name)
@name = name
end
def display_name
puts "Name: #{@name}"
end
end
user1 = User.new("Alice")
user2 = User.new("Bob")
user1.display_name # => "Name: Alice"
user2.display_name # => "Name: Bob"
ここでは、user1
とuser2
のインスタンスそれぞれが異なる@name
の値を持っています。このように、インスタンス変数は個別のインスタンスに固有のデータを保持するために使用されます。
クラス変数
クラス変数(@@variable_name
)は、クラス全体で共有され、クラスのすべてのインスタンス間で値が共通になります。クラス変数を使うと、全インスタンスで共通して利用する設定やデータを保持することができます。以下の例では、クラス変数@@user_count
がすべてのインスタンスで共有されていることを示しています。
class User
@@user_count = 0
def initialize(name)
@name = name
@@user_count += 1
end
def self.user_count
@@user_count
end
end
user1 = User.new("Alice")
user2 = User.new("Bob")
puts User.user_count # => 2
ここでは、インスタンスが生成されるたびに@@user_count
がインクリメントされ、クラス全体で共有されていることがわかります。このように、クラス変数はすべてのインスタンス間で共通のデータを管理するために使われます。
クラスインスタンス変数
クラス変数と似ていますが、クラスインスタンス変数(@variable_name
)は、クラス自体に固有の値を保持し、通常はクラスメソッドの中で利用されます。クラスインスタンス変数はインスタンスではなくクラスのスコープ内で管理されるため、スコープが限られた共有データの管理に便利です。
class User
@user_count = 0
def self.increment_count
@user_count += 1
end
def self.user_count
@user_count
end
end
User.increment_count
puts User.user_count # => 1
この例のように、クラスインスタンス変数はクラスメソッド内でのみ使用され、通常のインスタンスからはアクセスされません。これにより、インスタンス変数とクラス変数の間の柔軟な使い分けが可能になります。
使い分けのポイント
- インスタンス変数:各インスタンスで固有のデータを管理したいときに使用。
- クラス変数:全インスタンス間で共有されるデータを管理したいときに使用。
- クラスインスタンス変数:クラス自体に固有の情報を管理したいときに使用。
クラス変数とインスタンス変数を適切に使い分けることで、データ管理の構造が明確になり、コードのメンテナンス性が向上します。
`self`を使ったシングルトンメソッドの定義
Rubyでは、特定のオブジェクトに対してのみ有効なメソッドを定義することができ、このようなメソッドを「シングルトンメソッド」と呼びます。シングルトンメソッドは、クラスそのものに対してメソッドを定義する場合や、インスタンスごとに異なるメソッドを定義したいときに利用されます。このセクションでは、self
を使ってクラスのシングルトンメソッドを定義する方法と、シングルトンメソッドの用途について解説します。
クラスメソッドとしてのシングルトンメソッド
クラス内でself
を使ってメソッドを定義することで、クラスのシングルトンメソッド、つまりクラスメソッドを作成することができます。これにより、インスタンス化せずにクラス名を通して直接メソッドを呼び出すことが可能になります。
class Greeting
def self.say_hello
puts "Hello from the Greeting class!"
end
end
Greeting.say_hello # => "Hello from the Greeting class!"
上記の例では、self.say_hello
としてクラスメソッドを定義しています。この方法で定義されたメソッドは、Greeting
クラス全体に関連付けられており、インスタンスを生成せずに直接呼び出すことができます。このように、クラスのユーティリティ関数や共通処理を定義する場合にシングルトンメソッドが役立ちます。
特定インスタンスのみに適用するシングルトンメソッド
Rubyでは、特定のインスタンスだけに固有のメソッドを追加することも可能です。これにより、特定のオブジェクトに対してのみ有効なメソッドを動的に追加できるため、柔軟なプログラミングが可能です。
greeting1 = Greeting.new
greeting2 = Greeting.new
def greeting1.say_hello
puts "Hello from this specific instance!"
end
greeting1.say_hello # => "Hello from this specific instance!"
greeting2.say_hello # エラー: undefined method `say_hello'
この例では、greeting1
にのみsay_hello
メソッドを定義しています。greeting2
にはsay_hello
メソッドが存在しないため、say_hello
を呼び出すとエラーになります。このように、シングルトンメソッドを使うと、特定のインスタンスに対して個別の動作を設定することができます。
クラスの特定用途におけるシングルトンメソッドの活用
シングルトンメソッドは、クラスを拡張したり、特定のコンテキストでのみ動作するメソッドを追加したりする際に便利です。たとえば、シングルトンメソッドを使って、モジュールやクラスの初期設定を動的に変更することも可能です。シングルトンメソッドの使用は、単一のオブジェクトに特化した処理を実装する場合に非常に役立ちます。
モジュールと`self`の関係
Rubyのモジュールは、クラスやオブジェクトにメソッドや定数をまとめて提供するための仕組みで、コードの再利用や名前空間の整理に活用されます。モジュール内でもself
を使うことで、そのモジュール自体に関連するメソッドを定義することができ、クラスメソッドと似た役割を持つ「モジュールメソッド」を作成できます。
モジュールメソッドの定義
モジュール内でself
を使ってメソッドを定義することで、そのモジュールに直接関連するメソッド(モジュールメソッド)を作成できます。これにより、モジュールをインクルードせずにモジュール名から直接メソッドを呼び出すことができます。
module MathOperations
def self.add(a, b)
a + b
end
def self.subtract(a, b)
a - b
end
end
puts MathOperations.add(5, 3) # => 8
puts MathOperations.subtract(5, 3) # => 2
上記の例では、self.add
およびself.subtract
としてモジュールメソッドを定義しています。このように定義されたメソッドは、MathOperations
モジュールに属し、モジュールを呼び出して直接利用できるため、コードがシンプルになります。
インクルードとエクステンドにおける`self`の使用
モジュールは、クラスにインクルード(include
)またはエクステンド(extend
)することで、そのメソッドをクラスのインスタンスメソッドまたはクラスメソッドとして使用することができます。
- include: モジュール内のメソッドがインスタンスメソッドとして追加される。
- extend: モジュール内のメソッドがクラスメソッドとして追加される。
以下に、include
とextend
を使用してモジュールのメソッドを利用する例を示します。
module Greeting
def greet
"Hello!"
end
end
class Person
include Greeting
end
class Robot
extend Greeting
end
person = Person.new
puts person.greet # => "Hello!" (インスタンスメソッドとして)
puts Robot.greet # => "Hello!" (クラスメソッドとして)
ここで、include
を使用した場合、greet
メソッドはPerson
インスタンスに対して利用可能になります。一方、extend
を使用した場合、greet
メソッドはRobot
クラスに対するクラスメソッドとなり、インスタンスからは直接呼び出すことはできません。
モジュールでのクラスメソッドの追加
モジュール内でself
を使ってクラスメソッドを追加する場合には、モジュールをextend
してクラスに組み込む方法もあります。以下の例は、self
を用いたモジュールメソッドがクラスのクラスメソッドとして機能する場合です。
module Helper
def self.class_method_example
"This is a module class method"
end
end
class Tool
extend Helper
end
puts Tool.class_method_example # => "This is a module class method"
この例では、Helper
モジュールのclass_method_example
をTool
クラスにクラスメソッドとして追加しています。self
を使ってモジュール内にメソッドを定義することで、モジュールを直接利用できるだけでなく、柔軟にクラスメソッドを追加することができます。
応用例:`self`を使ったDSL構築
Rubyでは、self
キーワードを利用して、簡易的なドメイン特化言語(DSL:Domain-Specific Language)を構築することが可能です。DSLは特定の用途に特化した文法や構文を提供し、特定の問題を解決しやすくするための小型の言語のようなものです。Rubyの柔軟な構文とself
の活用により、DSLを使った直感的なコード表現が可能になります。ここでは、self
を使ってDSLを構築する応用例を紹介します。
DSLの基本構造
DSLを構築する際、self
を使うことで、ユーザーがインスタンスを意識することなく、まるで特定の言語で命令を記述するようにコードを記述できるようになります。例えば、フォームの構造を定義するDSLを考えてみましょう。
class FormBuilder
attr_accessor :fields
def initialize
@fields = []
end
def self.build(&block)
builder = new
builder.instance_eval(&block)
builder
end
def text_field(name)
fields << { type: 'text', name: name }
end
def password_field(name)
fields << { type: 'password', name: name }
end
def submit(value)
fields << { type: 'submit', value: value }
end
end
この例では、FormBuilder
クラスのクラスメソッドbuild
内でself
を使うことで、インスタンスメソッドを簡潔に呼び出し、フォームの構造を定義できるようにしています。この仕組みを利用することで、以下のように直感的にフォームを構築できます。
form = FormBuilder.build do
text_field :username
password_field :password
submit "Log In"
end
puts form.fields.inspect
# => [{:type=>"text", :name=>:username}, {:type=>"password", :name=>:password}, {:type=>"submit", :value=>"Log In"}]
ここでは、FormBuilder.build
メソッドがself
を利用してインスタンスを構成することで、text_field
やpassword_field
といったメソッドが呼び出され、それらが順次フォームのフィールドとして追加されています。
instance_evalでコンテキストを変える
DSLの構築において、instance_eval
を使用することで、ブロック内のコンテキストを特定のインスタンスに変更できます。これにより、ユーザーはインスタンスの生成や初期化を意識せず、直接メソッドを呼び出すことが可能になります。
この仕組みを使うと、ブロック内でself
を参照することで、フォームフィールドを追加するFormBuilder
のインスタンスに直接アクセスできます。これにより、DSLを使った表現が直感的で簡潔になります。
DSL構築における`self`の役割
DSLを構築する上で、self
はブロックのコンテキストを変更したり、メソッド呼び出しを簡潔にしたりするために利用されます。このように、self
を活用することで、コードの可読性を高め、柔軟で拡張性のあるDSLの実装が可能となります。DSLを利用することで、コードを記述する際のユーザー体験が向上し、Rubyの特徴を生かした表現力豊かなコード構造を構築できるのです。
よくある誤解とトラブルシューティング
Rubyにおけるself
キーワードの使い方には多くの柔軟性がある一方で、その挙動に関する誤解や意図しないエラーが発生しがちです。ここでは、self
の使用でよくある誤解やトラブルと、その対処法について解説します。
セッターメソッドで`self`が省略される問題
Rubyでは、セッターメソッド(attr_writer
や=
メソッド)を使ってインスタンス変数に値を代入する際、self
を省略して単に変数名を記述すると、ローカル変数として解釈されることがあります。これにより、意図した変数に値が代入されないという問題が生じます。
class Person
attr_accessor :name
def set_name(name)
name = name # ローカル変数への代入となる
end
end
person = Person.new
person.set_name("Alice")
puts person.name # => nil(代入されていない)
この問題は、セッターメソッドを呼び出す際にself
を使うことで解決できます。
def set_name(name)
self.name = name # セッターメソッドが呼び出される
end
クラス変数とクラスインスタンス変数の混同
クラス変数(@@variable
)とクラスインスタンス変数(@variable
)は異なる役割を持ちますが、self
の使用場面によって意図しない結果を招くことがあります。クラス変数はすべてのインスタンスで共有されるため、個別の値を保持したい場合にはクラスインスタンス変数を利用する必要があります。
class Example
@@shared_var = "shared"
@unique_var = "unique"
def self.shared_var
@@shared_var
end
def self.unique_var
@unique_var
end
end
puts Example.shared_var # => "shared"
puts Example.unique_var # => "unique"
クラスインスタンス変数を用いると、各クラスで固有の値を管理することができ、予期せぬ共有によるバグを防げます。
特定のコンテキストでの`self`の解釈の違い
Rubyでは、インスタンスメソッドやクラスメソッド、あるいはブロック内でのself
の解釈が異なるため、意図せずに異なるオブジェクトを参照してしまう場合があります。たとえば、モジュールをインクルードしているクラスのインスタンスメソッド内でのself
と、モジュールメソッド内でのself
が異なることを理解しておく必要があります。
こうした誤解を避けるには、使用するコンテキストにおけるself
の指す対象を常に意識し、self
を必要に応じて明示的に記述することが重要です。
トラブルシューティングのポイント
self
の指す対象が異なることによりエラーが生じる場合は、デバッグの際にputs self
などを使ってself
の実際の参照先を確認する。self
の使い方に不安がある場合は、明示的に定義されたインスタンス変数やクラス変数を利用し、各コンテキストに適した変数スコープを理解しておくことが効果的です。
こうしたポイントを押さえておくことで、self
の誤解による問題を回避し、Rubyのオブジェクト指向の機能をより効果的に活用することができます。
演習問題で理解を深める
ここでは、self
とインスタンス・クラスの違いをより深く理解するための演習問題を用意しました。実際に手を動かしてコードを書き、self
の使い方やその挙動を確認してみましょう。解答例と解説も合わせて提示するので、学習の確認に役立ててください。
演習問題 1: クラスメソッドとインスタンスメソッド
次のコードにクラスメソッドとインスタンスメソッドを追加し、self
を使ってcount
の値が適切に増加するようにしてみましょう。
class Counter
@count = 0
# クラスメソッドincrement_countを追加
# インスタンスメソッドincrement_instance_countを追加
def self.count
@count
end
end
Counter.increment_count
Counter.increment_count
puts Counter.count # => 2
counter_instance = Counter.new
counter_instance.increment_instance_count
puts Counter.count # => 3
解答例
class Counter
@count = 0
def self.increment_count
@count += 1
end
def increment_instance_count
self.class.increment_count
end
def self.count
@count
end
end
このコードでは、クラスメソッドincrement_count
でクラスインスタンス変数@count
を操作しています。インスタンスメソッドincrement_instance_count
内でself.class.increment_count
を使い、インスタンスからもクラスインスタンス変数にアクセスできるようにしています。
演習問題 2: セッターメソッドの定義
以下のPerson
クラスに、セッターメソッドを使って@name
の値を設定する機能を追加しましょう。セッターメソッドの中でself
を正しく使い、ローカル変数ではなくインスタンス変数が設定されるようにしてください。
class Person
attr_reader :name
def initialize(name)
self.name = name # セッターメソッドを正しく設定
end
# セッターメソッドname=を定義
end
person = Person.new("Alice")
puts person.name # => "Alice"
解答例
class Person
attr_reader :name
def initialize(name)
self.name = name
end
def name=(name)
@name = name
end
end
この例では、セッターメソッドname=
を定義し、その中でインスタンス変数@name
に値を代入しています。initialize
メソッド内でself.name = name
とすることで、セッターメソッドを正しく呼び出し、ローカル変数への誤った代入を防いでいます。
演習問題 3: シングルトンメソッド
次のコードで、特定のインスタンスだけに特別なメソッドspecial_message
を追加してください。このメソッドは、追加したインスタンスにだけ適用されるシングルトンメソッドとして定義します。
class Animal
end
dog = Animal.new
cat = Animal.new
# dogにのみspecial_messageを定義
dog.special_message # => "This is a special message for this dog."
cat.special_message # エラーが発生することを確認
解答例
class Animal
end
dog = Animal.new
cat = Animal.new
def dog.special_message
"This is a special message for this dog."
end
puts dog.special_message # => "This is a special message for this dog."
# puts cat.special_message # エラーが発生します
この解答例では、dog
インスタンスにのみspecial_message
メソッドが追加されています。def dog.special_message
とすることで、特定のインスタンスに対してシングルトンメソッドを定義しています。cat
インスタンスではこのメソッドは定義されていないため、エラーが発生します。
演習問題 4: モジュールと`self`
次のMathOperations
モジュールに、クラスメソッドとして直接呼び出せる加算メソッドadd
と減算メソッドsubtract
を定義してください。モジュール内でself
を使い、MathOperations.add(5, 3)
のように直接呼び出せるようにします。
module MathOperations
# addメソッドを定義
# subtractメソッドを定義
end
puts MathOperations.add(5, 3) # => 8
puts MathOperations.subtract(5, 3) # => 2
解答例
module MathOperations
def self.add(a, b)
a + b
end
def self.subtract(a, b)
a - b
end
end
puts MathOperations.add(5, 3) # => 8
puts MathOperations.subtract(5, 3) # => 2
ここでは、モジュールメソッドとしてadd
とsubtract
を定義するため、def self.add
およびdef self.subtract
を使用しています。これにより、MathOperations
モジュールをインクルードせずに直接メソッドを呼び出すことができます。
これらの演習を通じて、self
の使い方や、クラスメソッド、インスタンスメソッド、シングルトンメソッド、モジュールメソッドの定義方法について理解が深まります。コードを実際に実行し、挙動を確認することで、self
の挙動をより直感的に把握できるでしょう。
まとめ
本記事では、Rubyにおけるself
キーワードの使い方と、インスタンスとクラスの違いについて詳しく解説しました。self
は、インスタンスメソッドやクラスメソッド内でのオブジェクトの参照を明示するだけでなく、クラス全体や特定のインスタンスに属するメソッドの定義に活用されます。クラス変数とインスタンス変数の違いや、シングルトンメソッドの定義、さらにモジュールでのself
の応用も紹介し、Rubyの柔軟で強力なオブジェクト指向の機能を実践的に理解できる内容を提供しました。
適切な場面でself
を活用することで、コードの可読性やメンテナンス性が向上し、Rubyプログラムの構造がよりわかりやすくなります。今回の演習問題を通じて、self
の役割や適切な使い方を確認し、Rubyのオブジェクト指向プログラミングの理解を深めていきましょう。
コメント