=head1 名前

perlboot - Perl オブジェクト指向導入編

=head1 説明

他の言語でオブジェクトに親しんでいたのでなければ, 
他の Perl オブジェクトのドキュメントのいくつかは気力をくじかせるでしょう. 
オブジェクトを使うための基本的なリファレンス L<perlobj>, 
Perl のオブジェクトシステムの特性のチュートリアル的な紹介 L<perltoot> 
等のように.

そこで, 別のアプローチをとってみましょう. 
オブジェクトの経験がないことを前提にしましょう. 
もし, サブルーティン(L<perlsub>)や, リファレンス(L<perlref>等), 
パッケージ(L<perlmod>) を知っているのならそれが役に立つでしょう. 
もしまだわからなければまずそちらを先に知っておくべきでしょう.

=head2 もし動物と会話できたら...

動物さんたちにちょっとしゃべってもらいましょう.

    sub Cow::speak {
      print "a Cow goes moooo!\n";
    }
    sub Horse::speak {
      print "a Horse goes neigh!\n";
    }
    sub Sheep::speak {
      print "a Sheep goes baaaah!\n"
    }

    Cow::speak;
    Horse::speak;
    Sheep::speak;

これは次の結果を得ます:

    a Cow goes moooo!
    a Horse goes neigh!
    a Sheep goes baaaah!

目新しいコトはありません. 別々のパッケージに分かれていて
完全なパッケージ名を使って呼び出していますが, 単なるサブルーティンです. 
では, 牧場を作ってみましょう.

    # Cow::speak, Horse::speak, Sheep::speak as before
    @pasture = qw(Cow Cow Horse Sheep Sheep);
    foreach $animal (@pasture) {
      &{$animal."::speak"};
    }

これは次の結果を得ます:

    a Cow goes moooo!
    a Cow goes moooo!
    a Horse goes neigh!
    a Sheep goes baaaah!
    a Sheep goes baaaah!

うわ. シンボリックcoderefのデリファレンスがあります. かなり粗雑です. 
C<no strict subs> モードも考えてみると, 大きなプログラムには全然向きません. 
なぜその様なものが必要とされるのでしょう？
それはパッケージ名を, そのパッケージの呼び出そうとしている
サブルーティンの名前から分離できないからです. 
("Cow::speek" というメソッド名が必要だから.)

ではどうしましょう?

=head2 メソッド呼び出しの矢印

いまのところ, C<< Class->method >> は C<Class> パッケージの C<method> 
サブルーティンを呼び出すとだけ言っておきましょう. 
(ここで "Class" は "カテゴリ" の意味です. "学級" ではありません.)
厳密には完全ではありませんが, 少しずつ進めていきましょう. 
これは次のように使います:

    # Cow::speak, Horse::speak, Sheep::speak as before
    Cow->speak;
    Horse->speak;
    Sheep->speak;

そしてこれは次の結果を得ます:

    a Cow goes moooo!
    a Horse goes neigh!
    a Sheep goes baaaah!

別におもしろくもありませんね.
同じ文字数ですし全て定数で変数もありません. 
でも, 今度はパッケージ名を分離できるのです. 次を見てください:

    $a = "Cow";
    $a->speak; # invokes Cow->speak

関数名からパッケージ名を分けれるので, 
パッケージ名に変数を使うことができるのです!
そして今度は C<use strict refs> が有効であってもちゃんと機能するのです.

=head2 裏庭の呼び出し

新しい矢印呼び出しを使ってみましょう. 
そして裏庭の例に戻してみましょう.

    sub Cow::speak {
      print "a Cow goes moooo!\n";
    }
    sub Horse::speak {
      print "a Horse goes neigh!\n";
    }
    sub Sheep::speak {
      print "a Sheep goes baaaah!\n"
    }

    @pasture = qw(Cow Cow Horse Sheep Sheep);
    foreach $animal (@pasture) {
      $animal->speak;
    }

みんなちゃんとしゃべってくれます!
また今度はシンボリックcoderefを使っていなくて安全です.

でも, コードをよく見てみると, 各 C<speak> 関数はよく似た構造を持っています. 
C<print> 演算子と, ２語を除くと同一のテキストを含んでいるだけです. 
共通箇所を分解するのはよいことです. 
例えば, 後で全ての C<goes> を C<says> に変えることもできるようになります.

また, 大騒ぎすることなくそれを行う方法も実際あります. 
しかし, メソッド呼び出しの矢印が何を行ってくれているのかについて
ここで少し知っておかなければなりません.

=head2 メソッド呼び出しの追加パラメータ

メソッド呼び出し:

    Class->method(@args)

は, C<Class::Method> 関数を次のように呼び出すそうとします:

    Class::method("Class", @args);

(もし関数を見つけることができなかったときには, "継承" が走査されます. 
これに関してはあとで説明します.) 
これは最初のパラメータとしてクラス名を得ることを意味します. 
(もし引数がなければそれがただ１つのパラメータになります.) 
このことから C<Sheep> のおしゃべり関数を次のように書き改めることができます.

    sub Sheep::speak {
      my $class = shift;
      print "a $class goes baaaah!\n";
    }

また他の動物たちも同様になります.

    sub Cow::speak {
      my $class = shift;
      print "a $class goes moooo!\n";
    }
    sub Horse::speak {
      my $class = shift;
      print "a $class goes neigh!\n";
    }

それぞれにおいて C<$class> にはその関数の特定の値を得ます. 
しかしもう一度考え直してみると, かなりよく似た構造になったいます. 
さらに分離することはできないでしょうか？ 
それは同じクラスの別のメソッドを呼ぶことで可能です.

=head2 簡単に２つ目のメソッドを呼び出す

C<speak> から補助メソッド C<sound> よ呼び出してみましょう. 
このメソッドはその鳴き声として固定文字列を提供します.

    { package Cow;
      sub sound { "moooo" }
      sub speak {
	my $class = shift;
	print "a $class goes ", $class->sound, "!\n"
      }
    }

さて, C<< Cow->speak >> を呼び出すと C<speak> では C<$class> として
C<Cow> を得ました. 
これをつかって C<moooo> を返す C<< Cow->sound >> メソッドを選択します. 
では C<Horse> の時はどこが変わるでしょう.

    { package Horse;
      sub sound { "neigh" }
      sub speak {
	my $class = shift;
	print "a $class goes ", $class->sound, "!\n"
      }
    }

パッケージ名と鳴き声の指定だけが変わりました. 
ところで Cow と Horse で C<speak> の定義を共有する方法はないでしょうか?
それが継承です!

=head2 気管を継承する

共通の関数のパッケージとして C<Animal> を作ります. 
ここで C<speak> を定義します.

    { package Animal;
      sub speak {
	my $class = shift;
	print "a $class goes ", $class->sound, "!\n"
      }
    }

次に各動物たちに対して, それぞれの鳴き声の定義と一緒に
 C<Animal> から "派生" するように言います.

    { package Cow;
      @ISA = qw(Animal);
      sub sound { "moooo" }
    }

ここで, C<@ISA> 配列が加えられていることに注意してください. 
少々これについて説明します.

とことでここで C<< Cow->speak >> を呼び出すとなにが起こるのでしょう？

まず, Perl が引数リストを構築します. 
今回は単純に C<Cow> だけです. 
それから Perl は C<Cow::speak> を探します. 
しかしそれはありません. 
そのため Perl は継承配列 C<@Cow::ISA> を調べます. 
それは存在し, 名前を１つ C<Animal> を格納しています.

Perl は次に C<Animal> の C<speak> を C<Animal::speak> の様に調べます. 
今度は見つかりました. 
そこで Perl はこの関数をさっき作っておいた引数リストで呼び出します.

C<Animal::speak> 関数においては, C<$class> は C<Cow> になります
(これが１つめの引数です). 
そのため C<< $class->sound >> の呼び出しにおいて C<< Cow->sound >> 
を得ます. 最初は C<@ISA> を探すことなく調べます. 
そしてこれは成功します.

=head2 @ISAに関して追記

この魔法の C<@ISA> 変数 ( "アイサ"ではなく"イズ-ア") は,
C<Cow> が C<Animal> の"一種である(is-a)" と宣言している. 
これが単なる１つの値ではなく配列であることに注意してください. 
稀ではありますが, メソッドが見つからなかったときに探す親クラスを
１つ以上もつこともあるためです.

もし C<Animal> も C<@ISA> をもっていたらそれも同様に調べられます. 
検索は C<@ISA> の中を再帰的に, 深さ優先, 左から右に行われます. 
典型的に, 各 C<@ISA> がただ１つのみ要素を持っています.
そのため良好な継承ツリーを得ます. 
(複数の要素を持っていれば複数の継承, 複数の難問を持っています.)

C<use strict> を有効にしたとき, C<@ISA> は明示的なパッケージ名を
持っていないため, そしてレキシカル変数 ("my") でもないため警告を受けます. 
この変数はレキシカル変数にはできません. 
(継承メカニズムが探索できるように, パッケージに属していなければなりません.)
これに対処する方法は２つあります.

一番簡単な方法はパッケージ名をつけて使うことです.

    @Cow::ISA = qw(Animal);

もしくは暗黙に名付けられたパッケージ変数を許可することです.

    package Cow;
    use vars qw(@ISA);
    @ISA = qw(Animal);

もしオブジェクト指向モジュールを通して外部からクラスに持ち込むのなら,

    package Cow;
    use Animal;
    use vars qw(@ISA);
    @ISA = qw(Animal);

これを次のように変更します.

    package Cow;
    use base qw(Animal);

ずいぶんコンパクトになります.

=head2 メソッドのオーバーライド

ねずみを追加してみましょう. その声は微かでしょう.

    # Animal package from before
    { package Mouse;
      @ISA = qw(Animal);
      sub sound { "squeak" }
      sub speak {
        my $class = shift;
	print "a $class goes ", $class->sound, "!\n";
	print "[but you can barely hear it!]\n";
      }
    }

    Mouse->speak;

これは次のようになります.

    a Mouse goes squeak!
    [but you can barely hear it!]

ここでは C<Mouse> は C<< Animal->speak >> を呼ぶのではなく
自分用のおしゃべりルーティン C<< Mouse->speak >> 
を持っています. これは, "オーバーライド" と呼ばれています. 
事実, C<Mouse> が C<Animal> の一種であるという必要はまったくありません. 
おしゃべり(C<speak>)に必要なメソッドは全て C<Mouse> に定義されています.

しかしそれでもいくらかのコードを C<< Animal->speak >> から写しています. 
これはまたメンテナンスの悩みを再現させています. 
この悩みを回避することはできないでしょうか？
C<Animal> が行っていることを C<Mouse> でも, 少々コメントを追加して
行う方法はないでしょうか？
もちろんあります!

まず C<Animal::speak> メソッドを直接呼び出してみましょう.

    # Animal package from before
    { package Mouse;
      @ISA = qw(Animal);
      sub sound { "squeak" }
      sub speak {
        my $class = shift;
        Animal::speak($class);
	print "[but you can barely hear it!]\n";
      }
    }

メソッド矢印をやめたために, C<Animal::speak> の１つめの引数として 
C<$class> パラメータ(おそらくは C<"Mouse"> という値 )を含めなければ
いけないことに注意してください. 
なぜやめてしまったのでしょう？
ええ, もしここで C<< Animal->speak >> と呼び出せば最初のパラメータは
C<"Mouse"> ではなく C<"Animal"> になってしまいます. 
そして C<sound> が呼び出されたときに正しくこのクラスに戻ってくることが
できなくなってしまうのです.

しかし C<Animal::speak> を直接呼び出すのはいまいちです. 
もし C<Animal::speak> が存在せず, C<@Animal::ISA> に
指定されるクラスから継承していたらどうなるのでしょう？
メソッド矢印をすでに使っていないために正しくサブルーティンを探し当てる
チャンスはこの方法しかなくなってしまっているのです.

C<Animal> クラス名が関数の中に書き込まれていることにも注意してください. 
もしだれかがコードを修正し, C<speal> のにある C<Animal> に気付かないまま
C<Mouse> の C<@ISA> を書き換えてしまったらまずいことになります. 
結局, これは適切な方法ではないのです.

=head2 異なる場所から探索を始める

より望ましい解法は Perl に継承ツリーのより高位から探索することを
Perl に伝えることです:

    # same Animal as before
    { package Mouse;
      # same @ISA, &sound as before
      sub speak {
        my $class = shift;
        $class->Animal::speak;
        print "[but you can barely hear it!]\n";
      }
    }

これはちゃんと動作します. 
この構文を使うことで, C<speak> の探索を C<Animal> から開始することができます. 
そして C<Animal> に直接見つからなくても C<Animal> の全ての継承連鎖を使う
ことができます. さらに, １つめのパラメータは C<$class> になるため
見つかった C<speak> メソッドでは１つめのエントリに C<Mouse> を得て, 
ついに C<Mouse::sound> に戻って動作する様になります.

しかしこれはまだ最良の解ではありません. 
C<@ISA> と同等の最初の探索パッケージを維持しなければなりません. 
さらに悪いことに C<Mouse> が C<@ISA> に複数のエントリを持っていたら
実際に C<speak> を定義しているのがどれなのかわかりません. 
もっと良い方法はないでしょうか？

=head2 SUPER 解答

呼び出し時の C<Animal> クラスを C<SUPER> クラスに変えることで
検索を自動的に全ての基底クラス群(C<@ISA> に記述されているクラス群)
に対して行うことができます.

    # same Animal as before
    { package Mouse;
      # same @ISA, &sound as before
      sub speak {
        my $class = shift;
        $class->SUPER::speak;
        print "[but you can barely hear it!]\n";
      }
    }

つまり, C<SUPER::speak> は現在のパッケージの C<@ISA> から C<speak> を探し, 
最初に見つかったものを呼び出します.
これは C<$class> の C<@ISA> はI<見ない>点に注意してください.

=head2 現在地点

これまでに見てきたものは, メソッド矢印構文:

  Class->method(@args);

その等価な文:

  $a = "Class";
  $a->method(@args);

構築される引数リスト:

  ("Class", @args)

呼び出され方

  Class::method("Class", @Args);

しかし, C<Class:method> が見つからなければ C<@Class::ISA> が(再帰的に)
実際 C<method> を含んでいるパッケージを探すために使われます.

この簡単な構文を使うことでクラスメソッド, (複数の)継承, オーバーライド, 
そして拡張を行えるようになりました. 
これまでに見てきたもの丈で共通処理を抽出し, 様々な実装に再利用する
良好な方法を提供することができます. 
これはオブジェクトが提供するものの核心です. 
とはいえオブジェクトはこれ以外にもまだ説明していませんが
インスタンスデータも提供します.

=head2 馬は馬, もちろん -- ですか？

C<Animal> クラスと C<Horse> クラスを書いてみましょう.

  { package Animal;
    sub speak {
      my $class = shift;
      print "a $class goes ", $class->sound, "!\n"
    }
  }
  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
  }

C<< Horse->speak >> を呼び出すことで C<Animal::speak> に渡り, 
そこから C<Horse::sound> に鳴き声を作りに戻ります. 
結果は次のようになります:

  a Horse goes neigh!

しかしこのすべての Horse オブジェクトは完全に同一です. 
サブルーティンを追加しても, 全ての馬が自動的にそれを共有します. 
同じ馬を作るが目的ならすばらしいことですが, 
個々の馬を識別したい時にはどうすれば良いのでしょうか？
例えば最初の馬に名前を付けたい時にはどうすれば良いのでしょう. 
もちろん, それぞれの馬の名前を分離して維持する方法があります.

"インスタンス"と呼ばれる新しい区別を使うことでそれを行うことができます. 
"インスタンス” は一般的にクラスに生成されます. 
Perl では任意のリファレンスならインスタンスになることができます. 
そこでまず単純なリファレンスとして, 馬の名前を保持するスカラーリファレンス
を使ってみましょう.

  my $name = "Mr. Ed";
  my $talking = \$name;

これで C<$talking> はインスタンス指向のデータ(名前)のリファレンスになりました. 
これを実際のインスタンスにする最後のステップは C<bless> と呼ばれる
特別な操作です.

  bless $talking, Horse;

これはパッケージ名 C<Horse> に関する情報を
リファレンスに指されているものに格納する操作を行います. 
これにより, C<$talking> が C<Horse> のインスタンスになったといいます. 
これで, 個々の馬を識別できます. 
リファレンスはそれ以外に変化はありませんし, 
伝統的なデリファレンス操作を使うこともできます.

=head2 インスタンスメソッドの呼び出し

メソッド矢印はパッケージ(クラス)名の時と同じように,
インスタンスに対しても使うことができます. 
では, C<$talking> の作り出す音を取り出してみましょう:

  my $noise = $talking->sound;

C<sound> を呼び出すために, Perl は始めに C<$talking> が
ブレスされたリファレンス(つまりインスタンス)であることを
確認します. それから引数リストを構成します, 
今回は C<($talking)> だけです. (後ほど, クラスの時と
同様にインスタンス変数に続けて引数を置くのも説明します.)

さて, ここがおもしろいところです: 
Perl はインスタンスがブレスされているクラス, 
今回は C<Horse> を取り出し, メソッド呼び出しを
行うための関数の場所を特定するためにそれを使います.
今回は, C<Horse::sound> が直接に(継承を使うことなしに)
みつかり, 最終的に次の関数呼び出しとなります:

  Horse::sound($talking)

この最初のパラメータは, 先ほどのようなクラス名ではなく
インスタンスのままである点に注意してください. 
この結果 C<neigh> を復帰値として受け取り, 
これが C<$noise> 変数に代入されます.

もし Horse::sound が見つからなかったときには, 
クラスメソッドの時と同じように, スーパークラスの
中でメソッドが見つかるかどうか C<@Horse::ISA> 
リストをたどります. クラスメソッドと
インスタンスメソッドとの違いは
その最初の引数がインスタンス(ブレスされたリファレンス)
なのかクラス名(文字列)なのかという点だけです.

=head2 インスタンスのデータへのアクセス

最初の引数としてインスタンスを得ることが
できるので, インスタンス固有のデータにアクセスする
ことができます. 今回は, 名前にアクセスする方法を
追加してみましょう:

  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
    sub name {
      my $self = shift;
      $$self;
    }
  }

これでその名前を呼ぶことができます:

  print $talking->name, " says ", $talking->sound, "\n";

C<Horse::name> の内側では, C<@_> 配列には
C<shift> で C<$self> に代入される C<$talking> のみが
含まれています. (インスタンスメソッドにおいて, 
その最初のパラメータを C<$self> という名前の変数に
shift して代入するのはお約束です, なのでここでは
あまり理由を追い求めないでください.)
それから, C<$self> はスカラーリファレンスとして
デリファレンスされ, C<Mr. Ed> が取り出され,
それでおしまいです. 結果は次のようになります:

  Mr. Ed says neigh.

=head2 馬の作り方

もちろん, すべての馬を手で作っていては
時々失敗することもあるでしょう. また馬の"内臓"が
外から見えてしまうのはオブジェクト指向プログラミングの
約束事を1つ破っています. 
もしあなたが獣医であればそれもよいでしょうが, 
自分の馬を持ちたいだけであればそうではありません. 
なので Horse クラスに新しい馬を作ってもらいましょう:

  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
    sub name {
      my $self = shift;
      $$self;
    }
    sub named {
      my $class = shift;
      my $name = shift;
      bless \$name, $class;
    }
  }

この新しく作った C<named> メソッドで馬を作ることが
できます:

  my $talking = Horse->named("Mr. Ed");

ここで私たちはクラスメソッドに戻っていることに
注意してください, 
また C<Horse::named> の2つの引数は C<Horse> および
C<Mr. Ed> になります. 
C<bless> 演算子は C<$name> をブレスするだけでなく, 
C<$name> へのリファレンスを返します, それによって
これは適切な復帰値となります.
これが馬の作り方です.

ここではコンストラクタを C<named> としたので, 
このコンストラクタの引数が特定の C<Horse> の名前と
いうことを示しています. 
(家系や誕生日を記録するといった)違った方法で
オブジェクトに"命を吹き込む"別のコンストラクタには
また違った名前をつけることができます.
しかし, もっと制限の課せられていた言語から
Perl へと来たほとんどの人々は C<new> という
1つのコンストラクタに, 様々な引数の処理方法を
加えて使います. どちらの方法でもオブジェクトを
作り出すあなたの特定のやり方をあなたが
ドキュメント化している限りは問題ありません. 
(そしてそれを行ってI<きている>, そうですよね?)

=head2 コンストラクタの継承

でもこのメソッドに C<Horse> 特有のことってありますか?
答えは No です. 
従って, C<Animal> から継承して何かを構築するのと
同じレシピを使うことができます, やってみましょう:

  { package Animal;
    sub speak {
      my $class = shift;
      print "a $class goes ", $class->sound, "!\n"
    }
    sub name {
      my $self = shift;
      $$self;
    }
    sub named {
      my $class = shift;
      my $name = shift;
      bless \$name, $class;
    }
  }
  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
  }

あぁ, でもインスタンスに対して C<speak> を呼び出したら
どうなるのでしょう?

  my $talking = Horse->named("Mr. Ed");
  $talking->speak;

これはデバッグ情報になってしまいます:

  a Horse=SCALAR(0xaca42ac) goes neigh!

なぜこうなってしまうのでしょう? 
それは, この C<Animal::speak> ルーチンはその最初の
引数にはインスタンスではなくクラス名が来ると思っているからです. 
インスタンスが渡されるとブレスされたスカラーリファレンスを
文字列として使うことになってしまい, それが先ほどみたものに
なってしまうのです.

=head2 メソッドをクラスでもインスタンスでも動作できるようにする

今必要なことは, クラスに対して呼ばれたのか
それともインスタンスに対して呼ばれたのかを区別する方法です. 
一番率直な方法は C<ref> 演算子を使うことです. 
これはブラスされたリファレンスに対して使うと
文字列(クラス名)を返し, (クラス名のような)文字列に
対して使うと C<undef> を返します.
(訳注:C<ref>はC<undef>を返しません, 空文字列('')を返します.)
ではまず変わったことがわかるように C<name> メソッドを
変更してみましょう.

  sub name {
    my $either = shift;
    ref $either
      ? $$either # it's an instance, return name
      : "an unnamed $either"; # it's a class, return generic
  }

ここで C<?:> 演算子はでリファレンスするか派生された文字列かを
簡単に選択するために使っています. さてこれでこの
メソッドをインスタンスでもクラスでも使えるようにできました. 
最初のパラメータを保持する変数の名前を使う意図に合わせて
C<$either> に変更しています:

  my $talking = Horse->named("Mr. Ed");
  print Horse->name, "\n"; # prints "an unnamed Horse\n"
  print $talking->name, "\n"; # prints "Mr Ed.\n"

そして C<speak> もこれを使うように直してみましょう:

  sub speak {
    my $either = shift;
    print $either->name, " goes ", $either->sound, "\n";
  }

そして C<sound> は既にクラスでもインスタンスでも動作する
ようになっているので, これで完了です!

=head2 メソッドにパラメータを追加する

次は私たちの動物に食べることをしつけてみましょう:

  { package Animal;
    sub named {
      my $class = shift;
      my $name = shift;
      bless \$name, $class;
    }
    sub name {
      my $either = shift;
      ref $either
	? $$either # it's an instance, return name
	: "an unnamed $either"; # it's a class, return generic
    }
    sub speak {
      my $either = shift;
      print $either->name, " goes ", $either->sound, "\n";
    }
    sub eat {
      my $either = shift;
      my $food = shift;
      print $either->name, " eats $food.\n";
    }
  }
  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
  }
  { package Sheep;
    @ISA = qw(Animal);
    sub sound { "baaaah" }
  }

そして試してみます:

  my $talking = Horse->named("Mr. Ed");
  $talking->eat("hay");
  Sheep->eat("grass");

これは次のように出力します:

  Mr. Ed eats hay.
  an unnamed Sheep eats grass.

パラメータを持ったインスタンスメソッドは, 
そのインスタンスとパラメータのリストとともに
呼び出されます. そのため最初の呼び出しは次のようになります:

  Animal::eat($talking, "hay");

=head2 もっと面白いインスタンス

インスタンスにもっとデータがほしくなったら
どうすればよいでしょう? たいていの面白いインスタンスは
それぞれがリファレンスやほかのオブジェクトだったり
する多くの要素で構成されています. これらを格納する
一番簡単な方法はハッシュを使うことです. ハッシュのキーは
オブジェクトの部品("インスタンス変数"若しくは
"メンバ変数"と呼ばれます)の名前として提供され, 
それに対応する値は, まぁ, その値です.

でも馬をハッシュにするにはどうしたらよいでしょう?
オブジェクトはブレスされた任意のリファレンスである
ということを思い出してください. 
リファレンスを参照している箇所を適切に修正すれば, 
ブレスされたスカラーリファレンスと同じように簡単に
それをブレスされたハッシュリファレンスで作ることができます.

では羊を名前と色を持つようにしてみましょう:

  my $bad = bless { Name => "Evil", Color => "black" }, Sheep;

これで C<< $bad->{Name} >> は C<Evil> になり, 
C<< $bad->{Color} >> は C<black> になります. 
でも C<< $bad->name >> でその名前にアクセスできるようにしたい
ですが, それはスカラーリファレンスを前提にしているので
台無しにされています. でも心配しないでください, 
これはとっても簡単に直ります:

  ## in Animal
  sub name {
    my $either = shift;
    ref $either ?
      $either->{Name} :
      "an unnamed $either";
  }

そしてもちろん C<named> はスカラーの羊を作っているので
これも同じようになおしましょう.

  ## in Animal
  sub named {
    my $class = shift;
    my $name = shift;
    my $self = { Name => $name, Color => $class->default_color };
    bless $self, $class;
  }

この C<default_color> って何でしょう?
C<named> が名前だけで呼ばれても色を設定する必要があります, 
そこでクラス毎に初期値となる色を持てるようにしています. 
羊には白を定義しておきましょう:

  ## in Sheep
  sub default_color { "white" }

そして追加したそれぞれのクラスで色を定義する必要が
ないように, "デフォルトのデフォルト"を提供する
"安全ネット"メソッドを C<Animal> で直接定義しておきます:

  ## in Animal
  sub default_color { "brown" }

そして, C<name> と C<named> だけがオブジェクトの"構造"を
参照していたので, 残りのメソッドはそのままに
しておくことができます, C<speak> は前のままでそのまま
動作します.

=head2 違った色の馬

でも私たちの馬の全部が全部茶色では飽きてしまいます. 
なので色を取得/設定するためのメソッドを1つか2つ作ってみましょう.

  ## in Animal
  sub color {
    $_[0]->{Color}
  }
  sub set_color {
    $_[0]->{Color} = $_[1];
  }

引数にアクセスするための別の方法に関する補足: 
C<$_[0]> は C<shift> の代わりに in-place に
使うことができます. (これは頻繁に呼び出される箇所で
時間を節約することができます.) さてこれで
Mr. Ed の色を変えることができます:

  my $talking = Horse->named("Mr. Ed");
  $talking->set_color("black-and-white");
  print $talking->name, " is colored ", $talking->color, "\n";

これは次の結果になります:

  Mr. Ed is colored black-and-white

=head2 要約

さて, これまでにクラスメソッド, コンストラクタ, 
インスタンスメソッド, インスタンスデータ, そして
アクセッサをも見てきました. しかしこれらは Perl
の提供しているもののまだ始まりにすぎません. 
まだゲッター(getter)でありセッター(setter)でもある
アクセッサやデストラクタ, 間接オブジェクト表記, 
インスタンスデータを追加するサブクラス, クラス毎のデータ, 
オーバーロード, "isa" および "can" によるテスト, 
C<UNIVERSAL> クラス, 等々についてはまだ話し始めても
いません. これらは他の Perl ドキュメントでカバーされています.
願わくば, これがあなたの一歩となりますように.

=head1 関連項目

もっと詳しい情報は, 
L<perlobj> (ここで基礎を見た, Perl オブジェクトに関する
すべての強固な詳細),
L<perltoot> (オブジェクトを知っている人のためのチュートリアル),
L<perltooc> (クラスデータの取り扱い), 
L<perlbot> (もっとトリッキーなこととか),
そして Damian Conway の優秀な I<Object Oriented Perl> 
等の書籍.

おもしろさを垣間見れるモジュールとして, 
Class::Accessor, Class::Class, Class::Contract,
Class::Data::Inheritable, Class::MethodMaker そして Tie::SecureHash.

=head1 著作権

Copyright (c) 1999, 2000 by Randal L. Schwartz 及び
ストーンヘンジコンサルティングサービス. 
このドキュメントを完全に Perl 配布物で配布するために, そして
Perl 配布物のライセンスに従ってここに許可を与えます;
派生したドキュメントはこの著作権表記を完全に含まなけらば
なりません. 
(原文:
Copyright (c) 1999, 2000 by Randal L. Schwartz and Stonehenge
Consulting Services, Inc.  Permission is hereby granted to distribute
this document intact with the Perl distribution, and in accordance
with the licenses of the Perl distribution; derived documents must
include this copyright notice intact.
)

このテキストの一部はストーンヘンジコンサルティングサービス
によって講じ(teach)られた I<パッケージ, リファレンス, 
オブジェクト及びモジュール> コースで最初に作られた
Perl トレーニング資料から派生し, 許可を使っています.

このテキストの一部は I<Linux Magazine> で最初に作られた
資料から派生し, 許可を使っています.

=head1 和訳

 山科 氷魚 (YAMASHINA Hio) <hio@hio.jp>

原典: perl VERSION 5.8.8.
翻訳日: 2003-07-18 (perl-5.8.0).
(修正: 2007-08-07.)