NAME

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

DESCRIPTION

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

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

もし動物と会話できたら…

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

    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 のデリファレンスはかなり粗雑です。 no strict refs モードも考えてみると、大きなプログラムには全然向きません。なぜその様なものが必要とされるのでしょう? それはパッケージ名を、そのパッケージの呼び出そうとしているサブルーチンの名前から分離できないからです。

ではどうしましょう?

メソッド呼び出しの矢印

いまのところ、Class->method は Class パッケージの 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

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

裏庭の呼び出し

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

    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 を使っていなくて安全です。

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

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

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

メソッド呼び出し:

    Class->method(@args)

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

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

(もし関数を見つけることができなかったときには、「継承」が走査されます。これに関してはあとで説明します。) これは最初のパラメータとしてクラス名を得ることを意味します (もし引数がなければそれがただ一つのパラメータになります)。このことから 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";
    }

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

簡単に 2 つ目のメソッドを呼び出す

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

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

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

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

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

気管を継承する

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

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

次に各動物たちに対して、それぞれの鳴き声の定義と一緒に、 Animal から「継承」します:

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

ここで、@ISA (「イズア」と発音します))配列が加えられていることに注意してください。少々これについて説明します。

ところで、ここで Cow->speak を呼び出すとなにが起こるのでしょう?

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

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

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

@ISA に関して追記

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

もし Animal も @ISA をもっていたらそれも同様に調べられます。デフォルトでは、検索は @ISA の中を再帰的に、深さ優先、左から右に行われます(代替案については mro を参照してください)。典型的に、各 @ISA がただ１つのみ要素を持っています (複数の要素を持っていれば複数の継承、複数の難問を持っています); そのため良好な継承ツリーを得ます。

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

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

    @Cow::ISA = qw(Animal);

またはこれをパッケージグローバル変数として宣言します:

    package Cow;
    our @ISA = qw(Animal);

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

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

Animal クラスが他の (オブジェクト指向) モジュールから来ている場合、 Animal が Cow クラスの規定となることを指定するために、単に use base を使います:

    package Cow;
    use base qw(Animal);

これでかなり単純になりました!

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

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

    # 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!]

ここでは Mouse は Animal->speak を呼ぶのではなく自分用のおしゃべりルーティン Mouse->speak を持っています。これは、「オーバーライド」と呼ばれています。事実、Mouse が Animal の一種であるという必要はまったくありません。おしゃべり(speak)に必要なメソッドは全て Mouse に定義されています; これは「ダックタイピング」(duck typing) として知られています": 「あひるのように歩いてあひるのように鳴くなら、あひると呼ぼう」 (James Whitcomb)。しかし、Mouse が確かに Animal であると結論づけるためのより詳細な検査を出来ることはおそらく有益なので、実際には Animal を基底として Mouse を定義する方が良い(つまり、「Animal から Mouse を派生させる方が良い」)です。

さらに、このような重複は頭痛の種となります (しかしコードの再利用は実際には継承の良い理由ではありません; よい設計プラクティスは基底クラスが使えるところではどこでも派生クラスが使えるべきと指示していて、コードの再利用が継承の唯一の基準だと効果がないかもしれません。単に Mouse は常に Animal のように動作するべきと言うことを覚えておいてください)。

それで、Mouse を Animal にしましょう!

明らかな解決方法は 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";
      }
    }

Animal::speak を使っていることに注意してください。代わりに Animal->speak を起動すると、Animal::speak への最初の引数は "Mouse" ではなく自動的に "Animal" になるので、Animal::speak での $class->sound の呼び出しは Mouse->sound ではなく Animal->sound になります。

また、メソッド矢印 -> なしだと、Animal::speak への最初の引数を自分自身で指定する必要があるようになります; これが $class が明示的に渡されている理由です: Animal::speak($class)。

しかし、直接 Animal::speak を起動するのは大変です: 最初に、speak メソッドは Animal クラスのメンバであることを仮定しています; Animal が実際には独自の基底クラスから speak を継承していたら? もはや speak にアクセスするのに -> を使わないので、特別なメソッド検索機構が使われておらず、speak は発見すらされていません!

二つ目の問題はより微妙です: Animal はサブルーチン選択にハードコーディングされています。 Animal::speak が存在すると仮定してみましょう。後で起こることは、誰かが Mouse を Animal ではなく Mus から継承することでクラス階層を拡張します。 Animal::speak の起動が Mus::speak の起動も変更されない限り、分類学の世紀的な価値が破壊されます!

ここにあるものは脆弱で漏れやすい抽象化です; これは保守の悪夢の始まりです。必要としているものは出来るだけ仮定を少なくして正しいメソッドを探す能力です。

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

よりよい 解決法は、継承チェーンのどこから speak の検索を始めるのかを Perl に伝えることです。これはメソッド矢印 -> の修正版で達成できます:

    ClassName->FirstPlaceToLook::method

それで、改良された Mouse クラスは:

    # 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";
      }
    }

この構文を使うことで、speak の探索を Animal から開始することができ、それから直接見つからなくても Animal の全ての継承連鎖を使うことができます。いつも通り、speak への一つめのパラメータは $class になるため、もはや $class を明示的に speak に渡す必要はありません。

しかし、二つ目の問題はどうでしょう? まだメソッド検索に Animal をハードコーディングしています。

SUPER 解答

この起動で Animal が特別なプレースホルダ SUPER で置き換えられると、 Mouse の @ISA の内容が使われ、$ISA[0] から始められます。それで、以下のようにして全ての問題が修正できます:

    # 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";
      }
    }

一般的に、SUPER::speak は現在のパッケージの @ISA から speak を実装するクラスを探し、最初に見つかったものを呼び出します。プレースホルダは SUPER と呼ばれます; その他の言語では基底クラスを "superclasses"(スーパークラス)として参照し、Perl は折衷主義だからです。

以下のように呼び出すと

    $class->SUPER::method;

$class がたまたま現在のパッケージでない限り、$class の @ISA を 見ない ことに注意してください。

Let's review...

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

  Class->method(@args);

その等価な文:

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

構築される引数リスト:

  ("Class", @args)

呼び出され方:

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

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

この簡単な構文を使うことでクラスメソッド、(複数の)継承、オーバーライド、そして拡張を行えるようになりました。これまでに見てきたもので共通処理を抽出し、(しかし、これは決して継承のよい理由ではありません!)、様々な実装に再利用する良好な方法を提供できます。

それで、データについては?

馬は馬、もちろん -- ですか？

Animal クラスと Horse クラスを書いてみましょう。

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

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

  a Horse goes neigh!

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

これは言わば、特定の Horse のインスタンスに別の名前を付けたいです。

Perl では任意のリファレンスなら「インスタンス」になることができます; そこでまず単純なリファレンスとして、馬の名前を保持するスカラリファレンスを使ってみましょう。

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

これで $talking はインスタンス指向のデータ(名前)のリファレンスになりました。最後のステップは特別な演算子 bless を使ってこのリファレンスを実際の Horse のインスタンスにすることです。

  bless $horse, Horse;

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

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

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

  my $noise = $horse->sound("some", "unnecessary", "args");

sound を呼び出すために、Perl は始めに $horse が bless されたリファレンス(つまりインスタンス)であることを確認します。それからいつも通り引数リストを構成します。

さて、ここがおもしろいところです: Perl はインスタンスが bless されているクラス、今回は Horse を取り出し、サブルーチンの場所を特定するためにそのクラスを使います。今回は、Horse::sound が直接に (継承を使うことなしに) 見つかります。結局、最初の行は以下のように書いたかのようになります:

  my $noise = Horse::sound($horse, "some", "unnecessary", "args");

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

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

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

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

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

Horse::name の内側では、@_ 配列の中身は:

    ($horse, "some", "unnecessary", "args")

なので shift は $horse を $self に保管します。それから $self は通常通り $$self でデリファレンスされ、"Mr. Ed" となります。

インスタンスメソッドでは $self という名前の変数に、クラスメソッドでは $class という名前の変数に最初の引数を shift するのは慣習です。

それから、以下の行は:

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

以下を出力します:

  Mr. Ed says neigh.

馬の作り方

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

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

以下のように、この新しく作った named メソッドで馬を作ることができます:

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

ここで私たちはクラスメソッドに戻っていることに注意してください; また Horse::named の2つの引数は Horse および Mr. Ed になります。 bless 演算子は \$name を bless するだけでなく、そのリファレンスを返します。

この Horse::named メソッドは「コンストラクタ」と呼ばれます。

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

コンストラクタの継承

でもこのメソッドに Horse 特有のことってありますか? 答えは No です。従って、Animal から継承して何かを構築するのと同じレシピを使うことができます; ここに name と named を置いてみましょう:

  { 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" }
  }

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

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

これはデバッグ情報になります:

  a Horse=SCALAR(0xaca42ac) goes neigh!

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

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

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

  sub name {
    my $either = shift;
    ref $either ? $$either : "Any $either";
  }

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

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

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

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

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

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

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

  { package Animal;
    sub named {
      my $class = shift;
      my $name = shift;
      bless \$name, $class;
    }
    sub name {
      my $either = shift;
      ref $either ? $$either : "Any $either";
    }
    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 $horse = Horse->named("Mr. Ed");
  $horse->eat("hay");
  Sheep->eat("grass");

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

  Mr. Ed eats hay.
  Any Sheep eats grass.

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

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

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

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

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

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

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

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

一つの解法は Sheep で新しく定義することで Animal::name と Animal::named をオーバーライドすることですが、後から Animal に追加されたメソッドではやはり混乱することになり、それらに全てについてもオーバーライドする必要があります。従って、基底クラスのデータ配置と異なるデータ配置を定義するのは決してよい方法ではありません。実際、全ての場合で bless されたハッシュを使うのが良い考えです。また、これは低レベルの作業を行うコンストラクトが重要な理由です。それでは、Animal を再定義しましょう:

  ## in Animal
  sub name {
    my $either = shift;
    ref $either ? $either->{Name} : "Any $either";
  }
  sub named {
    my $class = shift;
    my $name = shift;
    my $self = { Name => $name };
    bless $self, $class;
  }

もちろん、特定の色の Sheep を構築するためにはまだ named をオーバーライドする必要があります:

  ## in Sheep
  sub named {
    my ($class, $name) = @_;
    my $self = $class->SUPER::named(@_);
    $$self{Color} = $class->default_color;
    $self
  }

(@_ は named への引数を含んでいることに注意してください。)

この default_color って何でしょう? named が名前だけで呼ばれても色を設定する必要があります; そこでクラス毎にデフォルトの色を持てるようにしています。羊には白を定義しておきましょう:

  ## in Sheep
  sub default_color { "white" }

それでこれは:

  my $sheep = Sheep->named("Bad");
  print $sheep->{Color}, "\n";

以下を出力します:

  white

これで、色に関しては Sheep に特有なことは何もなくなったので、 Sheep::named を削除して代わりに色を扱うために Animal::named を実装しましょう:

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

そして追加したそれぞれのクラスで default_color を定義する必要がないように、「デフォルトのデフォルト」を提供するメソッドを Animal で直接定義しておきます:

  ## in Animal
  sub default_color { "brown" }

もちろん、name と named だけがオブジェクトの「構造」を参照していたので、残りのメソッドはそのままにしておくことができます; speak は前のままでそのまま動作します。

違った色の馬

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

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

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

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

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

  Mr. Ed is colored black-and-white

まとめ

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

COPYRIGHT

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.

Portions of this text have been derived from Perl Training materials originally appearing in the Packages, References, Objects, and Modules course taught by instructors for Stonehenge Consulting Services, Inc. and used with permission.

Portions of this text have been derived from materials originally appearing in Linux Magazine and used with permission.

NAME

DESCRIPTION

もし動物と会話できたら…

メソッド呼び出しの矢印

裏庭の呼び出し

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

簡単に 2 つ目のメソッドを呼び出す

気管を継承する

@ISA に関して追記

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

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

SUPER 解答

Let's review...

馬は馬、もちろん -- ですか？

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

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

馬の作り方

コンストラクタの継承

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

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

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

違った色の馬

まとめ

SEE ALSO

COPYRIGHT