5.10.1
Other versions:
5.14.1
5.12.1
5.10.0

名前

perlboot - Beginner's Object-Oriented Tutorial

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

説明

If you're not familiar with objects from other languages, some of the other Perl object documentation may be a little daunting, such as perlobj, a basic reference in using objects, and perltoot, which introduces readers to the peculiarities of Perl's object system in a tutorial way.

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

So, let's take a different approach, presuming no prior object experience. It helps if you know about subroutines (perlsub), references (perlref et. seq.), and packages (perlmod), so become familiar with those first if you haven't already.

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

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

Let's let the animals talk for a moment:

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

    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;

This results in:

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

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

Nothing spectacular here. Simple subroutines, albeit from separate packages, and called using the full package name. So let's create an entire pasture:

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

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

This results in:

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

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

Wow. That symbolic coderef de-referencing there is pretty nasty. We're counting on no strict refs mode, certainly not recommended for larger programs. And why was that necessary? Because the name of the package seems to be inseparable from the name of the subroutine we want to invoke within that package.

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

Or is it?

ではどうしましょう?

メソッド呼び出しの矢印

For now, let's say that Class->method invokes subroutine method in package Class. (Here, "Class" is used in its "category" meaning, not its "scholastic" meaning.) That's not completely accurate, but we'll do this one step at a time. Now let's use it like so:

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

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

And once again, this results in:

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

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

That's not fun yet. Same number of characters, all constant, no variables. But yet, the parts are separable now. Watch:

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

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

Ahh! Now that the package name has been parted from the subroutine name, we can use a variable package name. And this time, we've got something that works even when use strict refs is enabled.

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

裏庭の呼び出し

Let's take that new arrow invocation and put it back in the barnyard example:

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

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

There! Now we have the animals all talking, and safely at that, without the use of symbolic coderefs.

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

But look at all that common code. Each of the speak routines has a similar structure: a print operator and a string that contains common text, except for two of the words. It'd be nice if we could factor out the commonality, in case we decide later to change it all to says instead of goes.

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

And we actually have a way of doing that without much fuss, but we have to hear a bit more about what the method invocation arrow is actually doing for us.

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

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

The invocation of:

メソッド呼び出し:

    Class->method(@args)

attempts to invoke subroutine Class::method as:

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

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

(If the subroutine can't be found, "inheritance" kicks in, but we'll get to that later.) This means that we get the class name as the first parameter (the only parameter, if no arguments are given). So we can rewrite the Sheep speaking subroutine as:

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

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

And the other two animals come out similarly:

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

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

In each case, $class will get the value appropriate for that subroutine. But once again, we have a lot of similar structure. Can we factor that out even further? Yes, by calling another method in the same class.

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

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

Let's call out from speak to a helper method called sound. This method provides the constant text for the sound itself.

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

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

Now, when we call Cow->speak, we get a $class of Cow in speak. This in turn selects the Cow->sound method, which returns moooo. But how different would this be for the Horse?

さて、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";
      }
    }

Only the name of the package and the specific sound change. So can we somehow share the definition for speak between the Cow and the Horse? Yes, with inheritance!

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

気管を継承する

We'll define a common subroutine package called Animal, with the definition for speak:

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

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

Then, for each animal, we say it "inherits" from Animal, along with the animal-specific sound:

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

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

Note the added @ISA array (pronounced "is a"). We'll get to that in a minute.

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

But what happens when we invoke Cow->speak now?

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

First, Perl constructs the argument list. In this case, it's just Cow. Then Perl looks for Cow::speak. But that's not there, so Perl checks for the inheritance array @Cow::ISA. It's there, and contains the single name Animal.

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

Perl next checks for speak inside Animal instead, as in Animal::speak. And that's found, so Perl invokes that subroutine with the already frozen argument list.

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

Inside the Animal::speak subroutine, $class becomes Cow (the first argument). So when we get to the step of invoking $class->sound, it'll be looking for Cow->sound, which gets it on the first try without looking at @ISA. Success!

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

@ISA に関して追記

This magical @ISA variable has declared that Cow "is a" Animal. Note that it's an array, not a simple single value, because on rare occasions, it makes sense to have more than one parent class searched for the missing methods.

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

If Animal also had an @ISA, then we'd check there too. The search is recursive, depth-first, left-to-right in each @ISA by default (see mro for alternatives). Typically, each @ISA has only one element (multiple elements means multiple inheritance and multiple headaches), so we get a nice tree of inheritance.

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

When we turn on use strict, we'll get complaints on @ISA, since it's not a variable containing an explicit package name, nor is it a lexical ("my") variable. We can't make it a lexical variable though (it has to belong to the package to be found by the inheritance mechanism), so there's a couple of straightforward ways to handle that.

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

The easiest is to just spell the package name out:

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

    @Cow::ISA = qw(Animal);

Or declare it as package global variable:

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

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

Or allow it as an implicitly named package variable:

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

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

If the Animal class comes from another (object-oriented) module, then just employ use base to specify that Animal should serve as the basis for the Cow class:

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

    package Cow;
    use base qw(Animal);

Now that's pretty darn simple!

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

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

Let's add a mouse, which can barely be heard:

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

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

which results in:

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

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

Here, Mouse has its own speaking routine, so Mouse->speak doesn't immediately invoke Animal->speak. This is known as "overriding". In fact, we don't even need to say that a Mouse is an Animal at all, because all of the methods needed for speak are completely defined for Mouse; this is known as "duck typing": "If it walks like a duck and quacks like a duck, I would call it a duck" (James Whitcomb). However, it would probably be beneficial to allow a closer examination to conclude that a Mouse is indeed an Animal, so it is actually better to define Mouse with Animal as its base (that is, it is better to "derive Mouse from Animal").

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

Moreover, this duplication of code could become a maintenance headache (though code-reuse is not actually a good reason for inheritance; good design practices dictate that a derived class should be usable wherever its base class is usable, which might not be the outcome if code-reuse is the sole criterion for inheritance. Just remember that a Mouse should always act like an Animal).

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

So, let's make Mouse an Animal!

それで、MouseAnimal にしましょう!

The obvious solution is to invoke Animal::speak directly:

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

Note that we're using Animal::speak. If we were to invoke Animal->speak instead, the first parameter to Animal::speak would automatically be "Animal" rather than "Mouse", so that the call to $class->sound in Animal::speak would become Animal->sound rather than Mouse->sound.

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

Also, without the method arrow ->, it becomes necessary to specify the first parameter to Animal::speak ourselves, which is why $class is explicitly passed: Animal::speak($class).

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

However, invoking Animal::speak directly is a mess: Firstly, it assumes that the speak method is a member of the Animal class; what if Animal actually inherits speak from its own base? Because we are no longer using -> to access speak, the special method look up mechanism wouldn't be used, so speak wouldn't even be found!

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

The second problem is more subtle: Animal is now hardwired into the subroutine selection. Let's assume that Animal::speak does exist. What happens when, at a later time, someone expands the class hierarchy by having Mouse inherit from Mus instead of Animal. Unless the invocation of Animal::speak is also changed to an invocation of Mus::speak, centuries worth of taxonomical classification could be obliterated!

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

What we have here is a fragile or leaky abstraction; it is the beginning of a maintenance nightmare. What we need is the ability to search for the right method wih as few assumptions as possible.

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

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

A better solution is to tell Perl where in the inheritance chain to begin searching for speak. This can be achieved with a modified version of the method arrow ->:

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

    ClassName->FirstPlaceToLook::method

So, the improved Mouse class is:

それで、改良された 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";
      }
    }

Using this syntax, we start with Animal to find speak, and then use all of Animal's inheritance chain if it is not found immediately. As usual, the first parameter to speak would be $class, so we no longer need to pass $class explicitly to speak.

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

But what about the second problem? We're still hardwiring Animal into the method lookup.

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

SUPER 解答

If Animal is replaced with the special placeholder SUPER in that invocation, then the contents of Mouse's @ISA are used for the search, beginning with $ISA[0]. So, all of the problems can be fixed as follows:

この起動で 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";
      }
    }

In general, SUPER::speak means look in the current package's @ISA for a class that implements speak, and invoke the first one found. The placeholder is called SUPER, because many other languages refer to base classes as "superclasses", and Perl likes to be eclectic.

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

Note that a call such as

以下のように呼び出すと

    $class->SUPER::method;

does not look in the @ISA of $class unless $class happens to be the current package.

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

Let's review...

So far, we've seen the method arrow syntax:

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

  Class->method(@args);

or the equivalent:

その等価な文:

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

which constructs an argument list of:

構築される引数リスト:

  ("Class", @args)

and attempts to invoke:

呼び出され方:

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

However, if Class::method is not found, then @Class::ISA is examined (recursively) to locate a class (a package) that does indeed contain method, and that subroutine is invoked instead.

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

Using this simple syntax, we have class methods, (multiple) inheritance, overriding, and extending. Using just what we've seen so far, we've been able to factor out common code (though that's never a good reason for inheritance!), and provide a nice way to reuse implementations with variations.

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

Now, what about data?

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

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

Let's start with the code for the Animal class and the Horse class:

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

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

This lets us invoke Horse->speak to ripple upward to Animal::speak, calling back to Horse::sound to get the specific sound, and the output of:

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

  a Horse goes neigh!

But all of our Horse objects would have to be absolutely identical. If we add a subroutine, all horses automatically share it. That's great for making horses the same, but how do we capture the distinctions of an individual horse? For example, suppose we want to give our first horse a name. There's got to be a way to keep its name separate from the other horses.

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

That is to say, we want particular instances of Horse to have different names.

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

In Perl, any reference can be an "instance", so let's start with the simplest reference that can hold a horse's name: a scalar reference.

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

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

So, now $horse is a reference to what will be the instance-specific data (the name). The final step is to turn this reference into a real instance of a Horse by using the special operator bless:

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

  bless $horse, Horse;

This operator stores information about the package named Horse into the thing pointed at by the reference. At this point, we say $horse is an instance of Horse. That is, it's a specific horse. The reference is otherwise unchanged, and can still be used with traditional dereferencing operators.

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

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

The method arrow can be used on instances, as well as classes (the names of packages). So, let's get the sound that $horse makes:

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

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

To invoke sound, Perl first notes that $horse is a blessed reference (and thus an instance). It then constructs an argument list, as per usual.

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

Now for the fun part: Perl takes the class in which the instance was blessed, in this case Horse, and uses that class to locate the subroutine. In this case, Horse::sound is found directly (without using inheritance). In the end, it is as though our initial line were written as follows:

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

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

Note that the first parameter here is still the instance, not the name of the class as before. We'll get neigh as the return value, and that'll end up as the $noise variable above.

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

If Horse::sound had not been found, we'd be wandering up the @Horse::ISA array, trying to find the method in one of the superclasses. The only difference between a class method and an instance method is whether the first parameter is an instance (a blessed reference) or a class name (a string).

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

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

Because we get the instance as the first parameter, we can now access the instance-specific data. In this case, let's add a way to get at the name:

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

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

Inside Horse::name, the @_ array contains:

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

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

so the shift stores $horse into $self. Then, $self gets de-referenced with $$self as normal, yielding "Mr. Ed".

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

It's traditional to shift the first parameter into a variable named $self for instance methods and into a variable named $class for class methods.

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

Then, the following line:

それから、以下の行は:

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

outputs:

以下を出力します:

  Mr. Ed says neigh.

馬の作り方

Of course, if we constructed all of our horses by hand, we'd most likely make mistakes from time to time. We're also violating one of the properties of object-oriented programming, in that the "inside guts" of a Horse are visible. That's good if you're a veterinarian, but not if you just like to own horses. So, let's have the Horse class handle the details inside a class method:

もちろん、すべての馬を手で作っていては時々失敗することもあるでしょう。 また馬の「内臓」が外から見えてしまうのはオブジェクト指向 プログラミングの約束事を一つ破っています。 もしあなたが獣医であればそれもよいでしょうが、自分の馬を持ちたいだけであれば そうではありません。 なので 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;
    }
  }

Now with the new named method, we can build a horse as follows:

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

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

Notice we're back to a class method, so the two arguments to Horse::named are Horse and Mr. Ed. The bless operator not only blesses \$name, it also returns that reference.

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

This Horse::named method is called a "constructor".

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

We've called the constructor named here, so that it quickly denotes the constructor's argument as the name for this particular Horse. You can use different constructors with different names for different ways of "giving birth" to the object (like maybe recording its pedigree or date of birth). However, you'll find that most people coming to Perl from more limited languages use a single constructor named new, with various ways of interpreting the arguments to new. Either style is fine, as long as you document your particular way of giving birth to an object. (And you were going to do that, right?)

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

コンストラクタの継承

But was there anything specific to Horse in that method? No. Therefore, it's also the same recipe for building anything else that inherited from Animal, so let's put name and named there:

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

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

Ahh, but what happens if we invoke speak on an instance?

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

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

We get a debugging value:

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

  a Horse=SCALAR(0xaca42ac) goes neigh!

Why? Because the Animal::speak routine is expecting a classname as its first parameter, not an instance. When the instance is passed in, we'll end up using a blessed scalar reference as a string, and that shows up as we saw it just now.

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

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

All we need is for a method to detect if it is being called on a class or called on an instance. The most straightforward way is with the ref operator. This returns a string (the classname) when used on a blessed reference, and an empty string when used on a string (like a classname). Let's modify the name method first to notice the change:

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

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

Here, the ?: operator comes in handy to select either the dereference or a derived string. Now we can use this with either an instance or a class. Note that I've changed the first parameter holder to $either to show that this is intended:

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

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

and now we'll fix speak to use this:

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

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

And since sound already worked with either a class or an instance, we're done!

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

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

Let's train our animals to eat:

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

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

And now try it out:

そして試してみます:

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

which prints:

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

  Mr. Ed eats hay.
  Any Sheep eats grass.

An instance method with parameters gets invoked with the instance, and then the list of parameters. So that first invocation is like:

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

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

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

What if an instance needs more data? Most interesting instances are made of many items, each of which can in turn be a reference or even another object. The easiest way to store these is often in a hash. The keys of the hash serve as the names of parts of the object (often called "instance variables" or "member variables"), and the corresponding values are, well, the values.

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

But how do we turn the horse into a hash? Recall that an object was any blessed reference. We can just as easily make it a blessed hash reference as a blessed scalar reference, as long as everything that looks at the reference is changed accordingly.

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

Let's make a sheep that has a name and a color:

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

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

so $bad->{Name} has Evil, and $bad->{Color} has black. But we want to make $bad->name access the name, and that's now messed up because it's expecting a scalar reference. Not to worry, because that's pretty easy to fix up.

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

One solution is to override Animal::name and Animal::named by defining them anew in Sheep, but then any methods added later to Animal might still mess up, and we'd have to override all of those too. Therefore, it's never a good idea to define the data layout in a way that's different from the data layout of the base classes. In fact, it's a good idea to use blessed hash references in all cases. Also, this is why it's important to have constructors do the low-level work. So, let's redefine Animal:

一つの解法は Sheep で新しく定義することで Animal::nameAnimal::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;
  }

Of course, we still need to override named in order to handle constructing a Sheep with a certain color:

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

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

(Note that @_ contains the parameters to named.)

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

What's this default_color? Well, if named has only the name, we still need to set a color, so we'll have a class-specific default color. For a sheep, we might define it as white:

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

  ## in Sheep
  sub default_color { "white" }

Now:

それでこれは:

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

outputs:

以下を出力します:

  white

Now, there's nothing particularly specific to Sheep when it comes to color, so let's remove Sheep::named and implement Animal::named to handle color instead:

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

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

And then to keep from having to define default_color for each additional class, we'll define a method that serves as the "default default" directly in Animal:

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

  ## in Animal
  sub default_color { "brown" }

Of course, because name and named were the only methods that referenced the "structure" of the object, the rest of the methods can remain the same, so speak still works as before.

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

違った色の馬

But having all our horses be brown would be boring. So let's add a method or two to get and set the color.

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

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

Note the alternate way of accessing the arguments: $_[0] is used in-place, rather than with a shift. (This saves us a bit of time for something that may be invoked frequently.) And now we can fix that color for Mr. Ed:

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

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

which results in:

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

  Mr. Ed is colored black-and-white

まとめ

So, now we have class methods, constructors, instance methods, instance data, and even accessors. But that's still just the beginning of what Perl has to offer. We haven't even begun to talk about accessors that double as getters and setters, destructors, indirect object notation, overloading, "isa" and "can" tests, the UNIVERSAL class, and so on. That's for the rest of the Perl documentation to cover. Hopefully, this gets you started, though.

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

SEE ALSO

For more information, see perlobj (for all the gritty details about Perl objects, now that you've seen the basics), perltoot (the tutorial for those who already know objects), perltooc (dealing with class data), perlbot (for some more tricks), and books such as Damian Conway's excellent Object Oriented Perl.

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

Some modules which might prove interesting are Class::Accessor, Class::Class, Class::Contract, Class::Data::Inheritable, Class::MethodMaker and Tie::SecureHash

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

コピーライト

Copyright (c) 1999, 2000 by Randal L. Schwartz and Stonehenge Consulting Services, Inc.

Copyright (c) 2009 by Michael F. Witten.

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.