argra****@users*****
argra****@users*****
2012年 12月 28日 (金) 21:26:11 JST
Index: docs/perl/5.12.1/perlboot.pod
diff -u /dev/null docs/perl/5.12.1/perlboot.pod:1.1
--- /dev/null Fri Dec 28 21:26:11 2012
+++ docs/perl/5.12.1/perlboot.pod Fri Dec 28 21:26:11 2012
@@ -0,0 +1,1903 @@
+
+=encoding euc-jp
+
+=head1 NAME
+
+=begin original
+
+perlboot - Beginner's Object-Oriented Tutorial
+
+=end original
+
+perlboot - Perl オブジェクト指向導入編
+
+=head1 DESCRIPTION
+
+=begin original
+
+If you're not familiar with objects from other languages, some of the
+other Perl object documentation may be a little daunting, such as
+L<perlobj>, a basic reference in using objects, and L<perltoot>, which
+introduces readers to the peculiarities of Perl's object system in a
+tutorial way.
+
+=end original
+
+他の言語でオブジェクトに親しんでいたのでなければ、他の Perl オブジェクトの
+ドキュメントのいくつかは気力をくじかせるでしょう;
+オブジェクトを使うための基本的なリファレンス L<perlobj>、Perl の
+オブジェクトシステムの特性のチュートリアル的な紹介 L<perltoot> 等のように。
+
+=begin original
+
+So, let's take a different approach, presuming no prior object
+experience. It helps if you know about subroutines (L<perlsub>),
+references (L<perlref> et. seq.), and packages (L<perlmod>), so become
+familiar with those first if you haven't already.
+
+=end original
+
+そこで、別のアプローチをとって、オブジェクトの経験がないことを
+前提にしましょう。
+もし、サブルーチン(L<perlsub>)や、リファレンス(L<perlref>等)、
+パッケージ(L<perlmod>) を知っているのならそれが役に立ちますので、
+もしまだわからなければまずそちらを先に知っておくべきでしょう。
+
+=head2 If we could talk to the animals...
+
+(もし動物と会話できたら…)
+
+=begin original
+
+Let's let the animals talk for a moment:
+
+=end original
+
+動物さんたちにちょっとしゃべってもらいましょう。
+
+ 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;
+
+=begin original
+
+This results in:
+
+=end original
+
+これは次の結果を得ます:
+
+ a Cow goes moooo!
+ a Horse goes neigh!
+ a Sheep goes baaaah!
+
+=begin original
+
+Nothing spectacular here. Simple subroutines, albeit from separate
+packages, and called using the full package name. So let's create
+an entire pasture:
+
+=end original
+
+目新しいことはありません。
+別々のパッケージに分かれていて完全なパッケージ名を使って呼び出していますが、
+単なるサブルーチンです。
+では、牧場を作ってみましょう。
+
+ # Cow::speak, Horse::speak, Sheep::speak as before
+ @pasture = qw(Cow Cow Horse Sheep Sheep);
+ foreach $animal (@pasture) {
+ &{$animal."::speak"};
+ }
+
+=begin original
+
+This results in:
+
+=end original
+
+これは次の結果を得ます:
+
+ a Cow goes moooo!
+ a Cow goes moooo!
+ a Horse goes neigh!
+ a Sheep goes baaaah!
+ a Sheep goes baaaah!
+
+=begin original
+
+Wow. That symbolic coderef de-referencing there is pretty nasty.
+We're counting on C<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.
+
+=end original
+
+うわ。
+ここにあるシンボリック coderef のデリファレンスはかなり粗雑です。
+C<no strict refs> モードも考えてみると、大きなプログラムには全然向きません。
+なぜその様なものが必要とされるのでしょう?
+それはパッケージ名を、そのパッケージの呼び出そうとしているサブルーチンの
+名前から分離できないからです。
+
+=begin original
+
+Or is it?
+
+=end original
+
+ではどうしましょう?
+
+=head2 Introducing the method invocation arrow
+
+(メソッド呼び出しの矢印)
+
+=begin original
+
+For now, let's say that C<< Class->method >> invokes subroutine
+C<method> in package C<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:
+
+=end original
+
+いまのところ、C<< Class->method >> は C<Class> パッケージの C<method>
+サブルーチンを呼び出すとだけ言っておきましょう。
+(ここで "Class" は "カテゴリ" の意味です; "学級" ではありません。)
+完全に厳密ではありませんが、少しずつ進めていきましょう。
+これは次のように使います:
+
+ # Cow::speak, Horse::speak, Sheep::speak as before
+ Cow->speak;
+ Horse->speak;
+ Sheep->speak;
+
+=begin original
+
+And once again, this results in:
+
+=end original
+
+そしてこれは次の結果を得ます:
+
+ a Cow goes moooo!
+ a Horse goes neigh!
+ a Sheep goes baaaah!
+
+=begin original
+
+That's not fun yet. Same number of characters, all constant, no
+variables. But yet, the parts are separable now. Watch:
+
+=end original
+
+別におもしろくもありませんね。
+同じ文字数ですし全て定数で変数もありません。
+でも、今度はパッケージ名を分離できるのです。
+次を見てください:
+
+ $a = "Cow";
+ $a->speak; # invokes Cow->speak
+
+=begin original
+
+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 C<use strict refs> is enabled.
+
+=end original
+
+ああ!
+関数名からパッケージ名を分けれるので、パッケージ名に変数を
+使うことができるのです。
+そして今度は C<use strict refs> が有効であってもちゃんと機能するのです。
+
+=head2 Invoking a barnyard
+
+(裏庭の呼び出し)
+
+=begin original
+
+Let's take that new arrow invocation and put it back in the barnyard
+example:
+
+=end original
+
+新しい矢印呼び出しを使って、裏庭の例に戻ってみましょう:
+
+ 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;
+ }
+
+=begin original
+
+There! Now we have the animals all talking, and safely at that,
+without the use of symbolic coderefs.
+
+=end original
+
+みんなちゃんとしゃべってくれます!
+また今度はシンボリック coderef を使っていなくて安全です。
+
+=begin original
+
+But look at all that common code. Each of the C<speak> routines has a
+similar structure: a C<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 C<says> instead of C<goes>.
+
+=end original
+
+でも、コードをよく見てみると、各 C<speak> 関数はよく似た構造を持っています。
+C<print> 演算子と、2 語を除くと同一のテキストを含んでいるだけです。
+共通箇所を分解するのはよいことです; 例えば、後で全ての C<goes> を C<says> に
+変えることもできるようになります。
+
+=begin original
+
+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.
+
+=end original
+
+また、大騒ぎすることなくそれを行う方法も実際ありますが、メソッド呼び出しの
+矢印が何を行ってくれているのかについてここで少し
+知っておかなければなりません。
+
+=head2 The extra parameter of method invocation
+
+(メソッド呼び出しの追加パラメータ)
+
+=begin original
+
+The invocation of:
+
+=end original
+
+メソッド呼び出し:
+
+ Class->method(@args)
+
+=begin original
+
+attempts to invoke subroutine C<Class::method> as:
+
+=end original
+
+は、C<Class::Method> 関数を次のように呼び出そうとします:
+
+ Class::method("Class", @args);
+
+=begin original
+
+(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 C<Sheep> speaking subroutine as:
+
+=end original
+
+(もし関数を見つけることができなかったときには、「継承」が走査されます。
+これに関してはあとで説明します。)
+これは最初のパラメータとしてクラス名を得ることを意味します
+(もし引数がなければそれがただ一つのパラメータになります)。
+このことから C<Sheep> のおしゃべり関数を次のように書き改めることができます:
+
+ sub Sheep::speak {
+ my $class = shift;
+ print "a $class goes baaaah!\n";
+ }
+
+=begin original
+
+And the other two animals come out similarly:
+
+=end original
+
+また他の動物たちも同様になります:
+
+ sub Cow::speak {
+ my $class = shift;
+ print "a $class goes moooo!\n";
+ }
+ sub Horse::speak {
+ my $class = shift;
+ print "a $class goes neigh!\n";
+ }
+
+=begin original
+
+In each case, C<$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.
+
+=end original
+
+それぞれにおいて C<$class> にはその関数の特定の値を得ます。
+しかしもう一度考え直してみると、かなりよく似た構造になっています。
+さらに分離することはできないでしょうか?
+それは同じクラスの別のメソッドを呼ぶことで可能です。
+
+=head2 Calling a second method to simplify things
+
+(簡単に 2 つ目のメソッドを呼び出す)
+
+=begin original
+
+Let's call out from C<speak> to a helper method called C<sound>.
+This method provides the constant text for the sound itself.
+
+=end original
+
+C<speak> から補助メソッド C<sound> を呼び出してみましょう。
+このメソッドはその鳴き声として固定文字列を提供します。
+
+ { package Cow;
+ sub sound { "moooo" }
+ sub speak {
+ my $class = shift;
+ print "a $class goes ", $class->sound, "!\n";
+ }
+ }
+
+=begin original
+
+Now, when we call C<< Cow->speak >>, we get a C<$class> of C<Cow> in
+C<speak>. This in turn selects the C<< Cow->sound >> method, which
+returns C<moooo>. But how different would this be for the C<Horse>?
+
+=end original
+
+さて、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";
+ }
+ }
+
+=begin original
+
+Only the name of the package and the specific sound change. So can we
+somehow share the definition for C<speak> between the Cow and the
+Horse? Yes, with inheritance!
+
+=end original
+
+パッケージ名と鳴き声の指定だけが変わりました。
+ところで Cow と Horse で C<speak> の定義を共有する方法はないでしょうか?
+それが継承です!
+
+=head2 Inheriting the windpipes
+
+(気管を継承する)
+
+=begin original
+
+We'll define a common subroutine package called C<Animal>, with the
+definition for C<speak>:
+
+=end original
+
+共通の関数のパッケージとして C<Animal> を作ります;
+ここで C<speak> を定義します
+
+ { package Animal;
+ sub speak {
+ my $class = shift;
+ print "a $class goes ", $class->sound, "!\n";
+ }
+ }
+
+=begin original
+
+Then, for each animal, we say it "inherits" from C<Animal>, along
+with the animal-specific sound:
+
+=end original
+
+次に各動物たちに対して、それぞれの鳴き声の定義と一緒に、
+C<Animal> から「継承」します:
+
+ { package Cow;
+ @ISA = qw(Animal);
+ sub sound { "moooo" }
+ }
+
+=begin original
+
+Note the added C<@ISA> array (pronounced "is a"). We'll get to that in a minute.
+
+=end original
+
+ここで、C<@ISA> (「イズア」と発音します))配列が加えられていることに
+注意してください。
+少々これについて説明します。
+
+=begin original
+
+But what happens when we invoke C<< Cow->speak >> now?
+
+=end original
+
+ところで、ここで C<< Cow->speak >> を呼び出すとなにが起こるのでしょう?
+
+=begin original
+
+First, Perl constructs the argument list. In this case, it's just
+C<Cow>. Then Perl looks for C<Cow::speak>. But that's not there, so
+Perl checks for the inheritance array C<@Cow::ISA>. It's there,
+and contains the single name C<Animal>.
+
+=end original
+
+まず、Perl が引数リストを構築します。
+今回は単純に C<Cow> だけです。
+それから Perl は C<Cow::speak> を探します。
+しかしそれはありません; そのため Perl は継承配列 C<@Cow::ISA> を調べます。
+それは存在し、名前を一つ C<Animal> を格納しています。
+
+=begin original
+
+Perl next checks for C<speak> inside C<Animal> instead, as in
+C<Animal::speak>. And that's found, so Perl invokes that subroutine
+with the already frozen argument list.
+
+=end original
+
+Perl は次に C<Animal> の C<speak> を C<Animal::speak> の様に調べます。
+今度は見つかりました; そこで Perl はこの関数をさっき作っておいた引数リストで
+呼び出します。
+
+=begin original
+
+Inside the C<Animal::speak> subroutine, C<$class> becomes C<Cow> (the
+first argument). So when we get to the step of invoking
+C<< $class->sound >>, it'll be looking for C<< Cow->sound >>, which
+gets it on the first try without looking at C<@ISA>. Success!
+
+=end original
+
+C<Animal::speak> 関数においては、C<$class> は C<Cow> になります
+(これが一つめの引数です)。
+そのため C<< $class->sound >> の呼び出しにおいて C<< Cow->sound >> を
+得ます; 最初は C<@ISA> を探すことなく調べます。
+そしてこれは成功します。
+
+=head2 A few notes about @ISA
+
+(@ISA に関して追記)
+
+=begin original
+
+This magical C<@ISA> variable has declared that C<Cow> "is a" C<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.
+
+=end original
+
+この魔法の C<@ISA> 変数は、C<Cow> が C<Animal> の「一種である(is-a)」と
+宣言しています。
+これが単なる一つの値ではなく配列であることに注意してください;
+稀ではありますが、メソッドが見つからなかったときに探す親クラスを
+一つ以上もつこともあるためです。
+
+=begin original
+
+If C<Animal> also had an C<@ISA>, then we'd check there too. The
+search is recursive, depth-first, left-to-right in each C<@ISA> by
+default (see L<mro> for alternatives). Typically, each C<@ISA> has
+only one element (multiple elements means multiple inheritance and
+multiple headaches), so we get a nice tree of inheritance.
+
+=end original
+
+もし C<Animal> も C<@ISA> をもっていたらそれも同様に調べられます。
+デフォルトでは、検索は C<@ISA> の中を再帰的に、深さ優先、左から右に
+行われます(代替案については L<mro> を参照してください)。
+典型的に、各 C<@ISA> がただ１つのみ要素を持っています
+(複数の要素を持っていれば複数の継承、複数の難問を持っています);
+そのため良好な継承ツリーを得ます。
+
+=begin original
+
+When we turn on C<use strict>, we'll get complaints on C<@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.
+
+=end original
+
+C<use strict> を有効にしたとき、C<@ISA> は明示的なパッケージ名を
+持っていないため、そしてレキシカル変数 ("my") でもないため警告を受けます。
+この変数はレキシカル変数にはできません;
+(継承メカニズムが探索できるように、パッケージに属していなければなりません)
+これに対処する方法は 2 つあります。
+
+=begin original
+
+The easiest is to just spell the package name out:
+
+=end original
+
+一番簡単な方法はパッケージ名をつけて使うことです:
+
+ @Cow::ISA = qw(Animal);
+
+=begin original
+
+Or declare it as package global variable:
+
+=end original
+
+またはこれをパッケージグローバル変数として宣言します:
+
+ package Cow;
+ our @ISA = qw(Animal);
+
+=begin original
+
+Or allow it as an implicitly named package variable:
+
+=end original
+
+もしくは暗黙に名付けられたパッケージ変数を許可することです:
+
+ package Cow;
+ use vars qw(@ISA);
+ @ISA = qw(Animal);
+
+=begin original
+
+If the C<Animal> class comes from another (object-oriented) module, then
+just employ C<use base> to specify that C<Animal> should serve as the basis
+for the C<Cow> class:
+
+=end original
+
+C<Animal> クラスが他の (オブジェクト指向) モジュールから来ている場合、
+C<Animal> が C<Cow> クラスの規定となることを指定するために、単に
+C<use base> を使います:
+
+ package Cow;
+ use base qw(Animal);
+
+=begin original
+
+Now that's pretty darn simple!
+
+=end original
+
+これでかなり単純になりました!
+
+=head2 Overriding the methods
+
+(メソッドのオーバーライド)
+
+=begin original
+
+Let's add a mouse, which can barely be heard:
+
+=end original
+
+ねずみを追加してみましょう; その声は微かでしょう。
+
+ # 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;
+
+=begin original
+
+which results in:
+
+=end original
+
+これは次の結果になります:
+
+ a Mouse goes squeak!
+ [but you can barely hear it!]
+
+=begin original
+
+Here, C<Mouse> has its own speaking routine, so C<< Mouse->speak >>
+doesn't immediately invoke C<< Animal->speak >>. This is known as
+"overriding". In fact, we don't even need to say that a C<Mouse> is
+an C<Animal> at all, because all of the methods needed for C<speak> are
+completely defined for C<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 C<Mouse> is indeed an C<Animal>,
+so it is actually better to define C<Mouse> with C<Animal> as its base
+(that is, it is better to "derive C<Mouse> from C<Animal>").
+
+=end original
+
+ここでは C<Mouse> は C<< Animal->speak >> を呼ぶのではなく
+自分用のおしゃべりルーティン C<< Mouse->speak >> を持っています。
+これは、「オーバーライド」と呼ばれています。
+事実、C<Mouse> が C<Animal> の一種であるという必要はまったくありません。
+おしゃべり(C<speak>)に必要なメソッドは全て C<Mouse> に定義されています;
+これは「ダックタイピング」(duck typing) として知られています":
+「あひるのように歩いてあひるのように鳴くなら、あひると呼ぼう」
+(James Whitcomb)。
+しかし、C<Mouse> が確かに C<Animal> であると結論づけるためのより詳細な検査を
+出来ることはおそらく有益なので、実際には C<Animal> を基底として C<Mouse> を
+定義する方が良い(つまり、「C<Animal> から C<Mouse> を派生させる方が
+良い」)です。
+
+=begin original
+
+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 C<Mouse>
+should always act like an C<Animal>).
+
+=end original
+
+さらに、このような重複は頭痛の種となります (しかしコードの再利用は
+実際には継承の良い理由ではありません; よい設計プラクティスは基底クラスが
+使えるところではどこでも派生クラスが使えるべきと指示していて、
+コードの再利用が継承の唯一の基準だと効果がないかもしれません。
+単に C<Mouse> は常に C<Animal> のように動作するべきと言うことを
+覚えておいてください)。
+
+=begin original
+
+So, let's make C<Mouse> an C<Animal>!
+
+=end original
+
+それで、C<Mouse> を C<Animal> にしましょう!
+
+=begin original
+
+The obvious solution is to invoke C<Animal::speak> directly:
+
+=end original
+
+明らかな解決方法は 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";
+ }
+ }
+
+=begin original
+
+Note that we're using C<Animal::speak>. If we were to invoke
+C<< Animal->speak >> instead, the first parameter to C<Animal::speak>
+would automatically be C<"Animal"> rather than C<"Mouse">, so that
+the call to C<< $class->sound >> in C<Animal::speak> would become
+C<< Animal->sound >> rather than C<< Mouse->sound >>.
+
+=end original
+
+C<Animal::speak> を使っていることに注意してください。
+代わりに C<< Animal->speak >> を起動すると、C<Animal::speak> への最初の引数は
+C<"Mouse"> ではなく自動的に C<"Animal"> になるので、C<Animal::speak> での
+C<< $class->sound >> の呼び出しは C<< Mouse->sound >> ではなく
+C<< Animal->sound >> になります。
+
+=begin original
+
+Also, without the method arrow C<< -> >>, it becomes necessary to specify
+the first parameter to C<Animal::speak> ourselves, which is why C<$class>
+is explicitly passed: C<Animal::speak($class)>.
+
+=end original
+
+また、メソッド矢印 C<< -> >> なしだと、C<Animal::speak> への最初の引数を
+自分自身で指定する必要があるようになります; これが C<$class> が明示的に
+渡されている理由です: C<Animal::speak($class)>。
+
+=begin original
+
+However, invoking C<Animal::speak> directly is a mess: Firstly, it assumes
+that the C<speak> method is a member of the C<Animal> class; what if C<Animal>
+actually inherits C<speak> from its own base? Because we are no longer using
+C<< -> >> to access C<speak>, the special method look up mechanism wouldn't be
+used, so C<speak> wouldn't even be found!
+
+=end original
+
+しかし、直接 C<Animal::speak> を起動するのは大変です: 最初に、C<speak>
+メソッドは C<Animal> クラスのメンバであることを仮定しています;
+C<Animal> が実際には独自の基底クラスから C<speak> を継承していたら?
+もはや C<speak> にアクセスするのに C<< -> >> を使わないので、特別なメソッド
+検索機構が使われておらず、C<speak> は発見すらされていません!
+
+=begin original
+
+The second problem is more subtle: C<Animal> is now hardwired into the subroutine
+selection. Let's assume that C<Animal::speak> does exist. What happens when,
+at a later time, someone expands the class hierarchy by having C<Mouse>
+inherit from C<Mus> instead of C<Animal>. Unless the invocation of C<Animal::speak>
+is also changed to an invocation of C<Mus::speak>, centuries worth of taxonomical
+classification could be obliterated!
+
+=end original
+
+二つ目の問題はより微妙です: C<Animal> はサブルーチン選択に
+ハードコーディングされています。
+C<Animal::speak> が存在すると仮定してみましょう。
+後で起こることは、誰かが C<Mouse> を C<Animal> ではなく C<Mus> から
+継承することでクラス階層を拡張します。
+C<Animal::speak> の起動が C<Mus::speak> の起動も変更されない限り、
+分類学の世紀的な価値が破壊されます!
+
+=begin original
+
+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.
+
+=end original
+
+ここにあるものは脆弱で漏れやすい抽象化です; これは保守の悪夢の始まりです。
+必要としているものは出来るだけ仮定を少なくして正しいメソッドを探す能力です。
+
+=head2 Starting the search from a different place
+
+(異なる場所から探索を始める)
+
+=begin original
+
+A I<better> solution is to tell Perl where in the inheritance chain to begin searching
+for C<speak>. This can be achieved with a modified version of the method arrow C<< -> >>:
+
+=end original
+
+I<よりよい> 解決法は、継承チェーンのどこから C<speak> の検索を始めるのかを
+Perl に伝えることです。
+これはメソッド矢印 C<< -> >> の修正版で達成できます:
+
+ ClassName->FirstPlaceToLook::method
+
+=begin original
+
+So, the improved C<Mouse> class is:
+
+=end original
+
+それで、改良された C<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";
+ }
+ }
+
+=begin original
+
+Using this syntax, we start with C<Animal> to find C<speak>, and then
+use all of C<Animal>'s inheritance chain if it is not found immediately.
+As usual, the first parameter to C<speak> would be C<$class>, so we no
+longer need to pass C<$class> explicitly to C<speak>.
+
+=end original
+
+この構文を使うことで、C<speak> の探索を C<Animal> から開始することができ、
+それから直接見つからなくても C<Animal> の全ての継承連鎖を使う
+ことができます。
+いつも通り、C<speak> への一つめのパラメータは C<$class> になるため、
+もはや C<$class> を明示的に C<speak> に渡す必要はありません。
+
+=begin original
+
+But what about the second problem? We're still hardwiring C<Animal> into
+the method lookup.
+
+=end original
+
+しかし、二つ目の問題はどうでしょう?
+まだメソッド検索に C<Animal> をハードコーディングしています。
+
+=head2 The SUPER way of doing things
+
+(SUPER 解答)
+
+=begin original
+
+If C<Animal> is replaced with the special placeholder C<SUPER> in that
+invocation, then the contents of C<Mouse>'s C<@ISA> are used for the
+search, beginning with C<$ISA[0]>. So, all of the problems can be fixed
+as follows:
+
+=end original
+
+この起動で C<Animal> が特別なプレースホルダ C<SUPER> で置き換えられると、
+C<Mouse> の C<@ISA> の内容が使われ、C<$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";
+ }
+ }
+
+=begin original
+
+In general, C<SUPER::speak> means look in the current package's C<@ISA>
+for a class that implements C<speak>, and invoke the first one found.
+The placeholder is called C<SUPER>, because many other languages refer
+to base classes as "I<super>classes", and Perl likes to be eclectic.
+
+=end original
+
+一般的に、C<SUPER::speak> は現在のパッケージの C<@ISA> から C<speak> を
+実装するクラスを探し、最初に見つかったものを呼び出します。
+プレースホルダは C<SUPER> と呼ばれます; その他の言語では基底クラスを
+"I<super>classes"(スーパークラス)として参照し、Perl は折衷主義だからです。
+
+=begin original
+
+Note that a call such as
+
+=end original
+
+以下のように呼び出すと
+
+ $class->SUPER::method;
+
+=begin original
+
+does I<not> look in the C<@ISA> of C<$class> unless C<$class> happens to
+be the current package.
+
+=end original
+
+C<$class> がたまたま現在のパッケージでない限り、C<$class> の C<@ISA> を
+I<見ない> ことに注意してください。
+
+=head2 Let's review...
+
+=begin original
+
+So far, we've seen the method arrow syntax:
+
+=end original
+
+これまでに見てきたものは、メソッド矢印構文:
+
+ Class->method(@args);
+
+=begin original
+
+or the equivalent:
+
+=end original
+
+その等価な文:
+
+ $a = "Class";
+ $a->method(@args);
+
+=begin original
+
+which constructs an argument list of:
+
+=end original
+
+構築される引数リスト:
+
+ ("Class", @args)
+
+=begin original
+
+and attempts to invoke:
+
+=end original
+
+呼び出され方:
+
+ Class::method("Class", @args);
+
+=begin original
+
+However, if C<Class::method> is not found, then C<@Class::ISA> is examined
+(recursively) to locate a class (a package) that does indeed contain C<method>,
+and that subroutine is invoked instead.
+
+=end original
+
+しかし、C<Class:method> が見つからなければ C<@Class::ISA> が(再帰的に)
+実際 C<method> を含んでいるクラス(パッケージ)を探すために使われます。
+
+=begin original
+
+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.
+
+=end original
+
+この簡単な構文を使うことでクラスメソッド、(複数の)継承、オーバーライド、
+そして拡張を行えるようになりました。
+これまでに見てきたもので共通処理を抽出し、(しかし、これは決して継承のよい
+理由ではありません!)、様々な実装に再利用する良好な方法を提供できます。
+
+=begin original
+
+Now, what about data?
+
+=end original
+
+それで、データについては?
+
+=head2 A horse is a horse, of course of course, or is it?
+
+(馬は馬、もちろん -- ですか？)
+
+=begin original
+
+Let's start with the code for the C<Animal> class
+and the C<Horse> class:
+
+=end original
+
+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" }
+ }
+
+=begin original
+
+This lets us invoke C<< Horse->speak >> to ripple upward to
+C<Animal::speak>, calling back to C<Horse::sound> to get the specific
+sound, and the output of:
+
+=end original
+
+C<< Horse->speak >> を呼び出すことで C<Animal::speak> に渡り、そこから
+C<Horse::sound> に鳴き声を作りに戻ります; 結果は次のようになります:
+
+ a Horse goes neigh!
+
+=begin original
+
+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.
+
+=end original
+
+しかしこのすべての Horse オブジェクトは完全に同一です。
+サブルーチンを追加しても、全ての馬が自動的にそれを共有します。
+同じ馬を作るが目的ならすばらしいことですが、
+個々の馬を識別したい時にはどうすれば良いのでしょうか?
+例えば最初の馬に名前を付けたい時にはどうすれば良いのでしょう。
+もちろん、それぞれの馬の名前を分離して維持する方法があります。
+
+=begin original
+
+That is to say, we want particular instances of C<Horse> to have
+different names.
+
+=end original
+
+これは言わば、特定の C<Horse> のインスタンスに別の名前を付けたいです。
+
+=begin original
+
+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.
+
+=end original
+
+Perl では任意のリファレンスなら「インスタンス」になることができます;
+そこでまず単純なリファレンスとして、馬の名前を保持するスカラリファレンス
+を使ってみましょう。
+
+ my $name = "Mr. Ed";
+ my $horse = \$name;
+
+=begin original
+
+So, now C<$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 C<Horse> by using the special operator C<bless>:
+
+=end original
+
+これで C<$talking> はインスタンス指向のデータ(名前)のリファレンスに
+なりました。
+最後のステップは特別な演算子 C<bless> を使ってこのリファレンスを実際の
+C<Horse> のインスタンスにすることです。
+
+ bless $horse, Horse;
+
+=begin original
+
+This operator stores information about the package named C<Horse> into
+the thing pointed at by the reference. At this point, we say
+C<$horse> is an instance of C<Horse>. That is, it's a specific
+horse. The reference is otherwise unchanged, and can still be used
+with traditional dereferencing operators.
+
+=end original
+
+これはパッケージ名 C<Horse> に関する情報をリファレンスに指されているものに
+格納する操作を行います。
+これにより、C<$horse> が C<Horse> のインスタンスになったといいます。
+これで、個々の馬を識別できます。
+リファレンスはそれ以外に変化はありませんし、伝統的なデリファレンス操作を
+使うこともできます。
+
+=head2 Invoking an instance method
+
+(インスタンスメソッドの呼び出し)
+
+=begin original
+
+The method arrow can be used on instances, as well as classes (the names
+of packages). So, let's get the sound that C<$horse> makes:
+
+=end original
+
+メソッド矢印はクラス(パッケージ名)の時と同じように、インスタンスに対しても
+使うことができます。
+では、C<$horse> の作り出す音を取り出してみましょう:
+
+ my $noise = $horse->sound("some", "unnecessary", "args");
+
+=begin original
+
+To invoke C<sound>, Perl first notes that C<$horse> is a blessed
+reference (and thus an instance). It then constructs an argument
+list, as per usual.
+
+=end original
+
+C<sound> を呼び出すために、Perl は始めに C<$horse> が bless された
+リファレンス(つまりインスタンス)であることを確認します。
+それからいつも通り引数リストを構成します。
+
+=begin original
+
+Now for the fun part: Perl takes the class in which the instance was
+blessed, in this case C<Horse>, and uses that class to locate the
+subroutine. In this case, C<Horse::sound> is found directly (without
+using inheritance). In the end, it is as though our initial line were
+written as follows:
+
+=end original
+
+さて、ここがおもしろいところです: Perl はインスタンスが bless されている
+クラス、今回は C<Horse> を取り出し、サブルーチンの場所を特定するためにその
+クラスを使います。
+今回は、C<Horse::sound> が直接に (継承を使うことなしに) 見つかります。
+結局、最初の行は以下のように書いたかのようになります:
+
+ my $noise = Horse::sound($horse, "some", "unnecessary", "args");
+
+=begin original
+
+Note that the first parameter here is still the instance, not the name
+of the class as before. We'll get C<neigh> as the return value, and
+that'll end up as the C<$noise> variable above.
+
+=end original
+
+この最初のパラメータは、先ほどのようなクラス名ではなく、インスタンスの
+ままである点に注意してください。
+この結果 C<neigh> を復帰値として受け取り、これが C<$noise> 変数に
+代入されます。
+
+=begin original
+
+If Horse::sound had not been found, we'd be wandering up the C<@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).
+
+=end original
+
+もし Horse::sound が見つからなかったときには、スーパークラスの中でメソッドが
+見つかるかどうか C<@Horse::ISA> 配列をたどります。
+クラスメソッドとインスタンスメソッドとの違いは、その最初の引数が
+インスタンス(bless されたリファレンス)なのかクラス名(文字列)なのかという
+点だけです。
+
+=head2 Accessing the instance data
+
+(インスタンスのデータへのアクセス)
+
+=begin original
+
+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:
+
+=end original
+
+最初の引数としてインスタンスを得ることができるので、
+インスタンス固有のデータにアクセスすることができます。
+今回は、名前にアクセスする方法を追加してみましょう:
+
+ { package Horse;
+ @ISA = qw(Animal);
+ sub sound { "neigh" }
+ sub name {
+ my $self = shift;
+ $$self;
+ }
+ }
+
+=begin original
+
+Inside C<Horse::name>, the C<@_> array contains:
+
+=end original
+
+C<Horse::name> の内側では、C<@_> 配列の中身は:
+
+ ($horse, "some", "unnecessary", "args")
+
+=begin original
+
+so the C<shift> stores C<$horse> into C<$self>. Then, C<$self> gets
+de-referenced with C<$$self> as normal, yielding C<"Mr. Ed">.
+
+=end original
+
+なので C<shift> は C<$horse> を C<$self> に保管します。
+それから C<$self> は通常通り C<$$self> でデリファレンスされ、C<"Mr. Ed"> と
+なります。
+
+=begin original
+
+It's traditional to C<shift> the first parameter into a variable named
+C<$self> for instance methods and into a variable named C<$class> for
+class methods.
+
+=end original
+
+インスタンスメソッドでは C<$self> という名前の変数に、クラスメソッドでは
+C<$class> という名前の変数に最初の引数を C<shift> するのは慣習です。
+
+=begin original
+
+Then, the following line:
+
+=end original
+
+それから、以下の行は:
+
+ print $horse->name, " says ", $horse->sound, "\n";
+
+=begin original
+
+outputs:
+
+=end original
+
+以下を出力します:
+
+ Mr. Ed says neigh.
+
+=head2 How to build a horse
+
+(馬の作り方)
+
+=begin original
+
+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:
+
+=end original
+
+もちろん、すべての馬を手で作っていては時々失敗することもあるでしょう。
+また馬の「内臓」が外から見えてしまうのはオブジェクト指向
+プログラミングの約束事を一つ破っています。
+もしあなたが獣医であればそれもよいでしょうが、自分の馬を持ちたいだけであれば
+そうではありません。
+なので 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;
+ }
+ }
+
+=begin original
+
+Now with the new C<named> method, we can build a horse as follows:
+
+=end original
+
+以下のように、この新しく作った C<named> メソッドで馬を作ることができます:
+
+ my $horse = Horse->named("Mr. Ed");
+
+=begin original
+
+Notice we're back to a class method, so the two arguments to
+C<Horse::named> are C<Horse> and C<Mr. Ed>. The C<bless> operator
+not only blesses C<\$name>, it also returns that reference.
+
+=end original
+
+ここで私たちはクラスメソッドに戻っていることに注意してください;
+また C<Horse::named> の2つの引数は C<Horse> および C<Mr. Ed> になります。
+C<bless> 演算子は C<\$name> を bless するだけでなく、そのリファレンスを
+返します。
+
+=begin original
+
+This C<Horse::named> method is called a "constructor".
+
+=end original
+
+この C<Horse::named> メソッドは「コンストラクタ」と呼ばれます。
+
+=begin original
+
+We've called the constructor C<named> here, so that it quickly denotes
+the constructor's argument as the name for this particular C<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 C<new>, with various ways of interpreting the arguments to
+C<new>. Either style is fine, as long as you document your particular
+way of giving birth to an object. (And you I<were> going to do that,
+right?)
+
+=end original
+
+ここではコンストラクタを C<named> としたので、このコンストラクタの引数が
+特定の C<Horse> の名前ということを示しています。
+(家系や誕生日を記録するといった)違った方法でオブジェクトに「命を吹き込む」
+別のコンストラクタにはまた違った名前をつけることができます。
+しかし、もっと制限の課せられていた言語から Perl へと来たほとんどの人々は
+C<new> という一つのコンストラクタに、様々な引数の処理方法を加えて使います。
+どちらの方法でも、オブジェクトを作り出すあなたの特定のやり方をあなたが
+ドキュメント化している限りは問題ありません。
+(そしてそれを行って I<きている>、そうですよね?)
+
+=head2 Inheriting the constructor
+
+(コンストラクタの継承)
+
+=begin original
+
+But was there anything specific to C<Horse> in that method? No. Therefore,
+it's also the same recipe for building anything else that inherited from
+C<Animal>, so let's put C<name> and C<named> there:
+
+=end original
+
+でもこのメソッドに C<Horse> 特有のことってありますか?
+答えは No です。
+従って、C<Animal> から継承して何かを構築するのと同じレシピを使うことが
+できます;
+ここに C<name> と C<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" }
+ }
+
+=begin original
+
+Ahh, but what happens if we invoke C<speak> on an instance?
+
+=end original
+
+あぁ、でもインスタンスに対して C<speak> を呼び出したらどうなるのでしょう?
+
+ my $horse = Horse->named("Mr. Ed");
+ $horse->speak;
+
+=begin original
+
+We get a debugging value:
+
+=end original
+
+これはデバッグ情報になります:
+
+ a Horse=SCALAR(0xaca42ac) goes neigh!
+
+=begin original
+
+Why? Because the C<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.
+
+=end original
+
+なぜこうなってしまうのでしょう?
+それは、この C<Animal::speak> ルーチンはその最初の引数には
+インスタンスではなくクラス名が来ると思っているからです。
+インスタンスが渡されるとブレスされたスカラリファレンスを文字列として
+使うことになってしまい、それが先ほど見たものになってしまうのです。
+
+=head2 Making a method work with either classes or instances
+
+(メソッドをクラスでもインスタンスでも動作できるようにする)
+
+=begin original
+
+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
+C<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 C<name> method first to notice the change:
+
+=end original
+
+今必要なことは、クラスに対して呼ばれたのかそれともインスタンスに対して
+呼ばれたのかを区別する方法です。
+一番率直な方法は C<ref> 演算子を使うことです。
+これは bless されたリファレンスに対して使うと文字列(クラス名)を返し、
+(クラス名のような)文字列に対して使うと空文字列を返します。
+ではまず変わったことがわかるように C<name> メソッドを変更してみましょう。
+
+ sub name {
+ my $either = shift;
+ ref $either ? $$either : "Any $either";
+ }
+
+=begin original
+
+Here, the C<?:> 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 C<$either> to show that this is intended:
+
+=end original
+
+ここで C<?:> 演算子はでリファレンスするか派生された文字列かを簡単に
+選択するために使っています。
+さてこれでこのメソッドをインスタンスでもクラスでも使えるようにできました。
+最初のパラメータを保持する変数の名前を使う意図に合わせて C<$either> に
+変更しています:
+
+ my $horse = Horse->named("Mr. Ed");
+ print Horse->name, "\n"; # prints "Any Horse\n"
+ print $horse->name, "\n"; # prints "Mr Ed.\n"
+
+=begin original
+
+and now we'll fix C<speak> to use this:
+
+=end original
+
+そして C<speak> もこれを使うように直してみましょう:
+
+ sub speak {
+ my $either = shift;
+ print $either->name, " goes ", $either->sound, "\n";
+ }
+
+=begin original
+
+And since C<sound> already worked with either a class or an instance,
+we're done!
+
+=end original
+
+そして C<sound> は既にクラスでもインスタンスでも動作するように
+なっているので、これで完了です!
+
+=head2 Adding parameters to a method
+
+(メソッドにパラメータを追加する)
+
+=begin original
+
+Let's train our animals to eat:
+
+=end original
+
+次は私たちの動物に食べることをしつけてみましょう:
+
+ { 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" }
+ }
+
+=begin original
+
+And now try it out:
+
+=end original
+
+そして試してみます:
+
+ my $horse = Horse->named("Mr. Ed");
+ $horse->eat("hay");
+ Sheep->eat("grass");
+
+=begin original
+
+which prints:
+
+=end original
+
+これは次のように出力します:
+
+ Mr. Ed eats hay.
+ Any Sheep eats grass.
+
+=begin original
+
+An instance method with parameters gets invoked with the instance,
+and then the list of parameters. So that first invocation is like:
+
+=end original
+
+パラメータを持ったインスタンスメソッドは、そのインスタンスとパラメータの
+リストとともに呼び出されます。
+そのため最初の呼び出しは次のようになります:
+
+ Animal::eat($horse, "hay");
+
+=head2 More interesting instances
+
+(もっと面白いインスタンス)
+
+=begin original
+
+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.
+
+=end original
+
+インスタンスにもっとデータがほしくなったらどうすればよいでしょう?
+たいていの面白いインスタンスはそれぞれがリファレンスや他の
+オブジェクトだったりする多くの要素で構成されています。
+これらを格納する一番簡単な方法はハッシュを使うことです。
+ハッシュのキーはオブジェクトの部品(「インスタンス変数」若しくは
+「メンバ変数」と呼ばれます)の名前として提供され、それに対応する値は、まぁ、
+その値です。
+
+=begin original
+
+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.
+
+=end original
+
+でも馬をハッシュにするにはどうしたらよいでしょう?
+オブジェクトはブレスされた任意のリファレンスであるということを
+思い出してください。
+リファレンスを参照している箇所を適切に修正すれば、bless された
+スカラリファレンスと同じように簡単に、それを bless された
+ハッシュリファレンスで作ることができます。
+
+=begin original
+
+Let's make a sheep that has a name and a color:
+
+=end original
+
+では羊を名前と色を持つようにしてみましょう:
+
+ my $bad = bless { Name => "Evil", Color => "black" }, Sheep;
+
+=begin original
+
+so C<< $bad->{Name} >> has C<Evil>, and C<< $bad->{Color} >> has
+C<black>. But we want to make C<< $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.
+
+=end original
+
+これで C<< $bad->{Name} >> は C<Evil> になり、C<< $bad->{Color} >> は
+C<black> になります。
+でも C<< $bad->name >> でその名前にアクセスできるようにしたいですが、それは
+スカラリファレンスを前提にしているので台無しにされています。
+でも心配しないでください、これはとっても簡単に直ります。
+
+=begin original
+
+One solution is to override C<Animal::name> and C<Animal::named> by
+defining them anew in C<Sheep>, but then any methods added later to
+C<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 C<Animal>:
+
+=end original
+
+一つの解法は C<Sheep> で新しく定義することで C<Animal::name> と
+C<Animal::named> をオーバーライドすることですが、後から C<Animal> に
+追加されたメソッドではやはり混乱することになり、それらに全てについても
+オーバーライドする必要があります。
+従って、基底クラスのデータ配置と異なるデータ配置を定義するのは決してよい
+方法ではありません。
+実際、全ての場合で bless されたハッシュを使うのが良い考えです。
+また、これは低レベルの作業を行うコンストラクトが重要な理由です。
+それでは、C<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;
+ }
+
+=begin original
+
+Of course, we still need to override C<named> in order to handle
+constructing a C<Sheep> with a certain color:
+
+=end original
+
+もちろん、特定の色の C<Sheep> を構築するためにはまだ C<named> を
+オーバーライドする必要があります:
+
+ ## in Sheep
+ sub named {
+ my ($class, $name) = @_;
+ my $self = $class->SUPER::named(@_);
+ $$self{Color} = $class->default_color;
+ $self
+ }
+
+=begin original
+
+(Note that C<@_> contains the parameters to C<named>.)
+
+=end original
+
+(C<@_> は C<named> への引数を含んでいることに注意してください。)
+
+=begin original
+
+What's this C<default_color>? Well, if C<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:
+
+=end original
+
+この C<default_color> って何でしょう?
+C<named> が名前だけで呼ばれても色を設定する必要があります; そこでクラス毎に
+デフォルトの色を持てるようにしています。
+羊には白を定義しておきましょう:
+
+ ## in Sheep
+ sub default_color { "white" }
+
+=begin original
+
+Now:
+
+=end original
+
+それでこれは:
+
+ my $sheep = Sheep->named("Bad");
+ print $sheep->{Color}, "\n";
+
+=begin original
+
+outputs:
+
+=end original
+
+以下を出力します:
+
+ white
+
+=begin original
+
+Now, there's nothing particularly specific to C<Sheep> when it comes
+to color, so let's remove C<Sheep::named> and implement C<Animal::named>
+to handle color instead:
+
+=end original
+
+これで、色に関しては C<Sheep> に特有なことは何もなくなったので、
+C<Sheep::named> を削除して代わりに色を扱うために C<Animal::named> を
+実装しましょう:
+
+ ## in Animal
+ sub named {
+ my ($class, $name) = @_;
+ my $self = { Name => $name, Color => $class->default_color };
+ bless $self, $class;
+ }
+
+=begin original
+
+And then to keep from having to define C<default_color> for each additional
+class, we'll define a method that serves as the "default default" directly
+in C<Animal>:
+
+=end original
+
+そして追加したそれぞれのクラスで C<default_color> を定義する必要が
+ないように、「デフォルトのデフォルト」を提供するメソッドを C<Animal> で直接
+定義しておきます:
+
+ ## in Animal
+ sub default_color { "brown" }
+
+=begin original
+
+Of course, because C<name> and C<named> were the only methods that
+referenced the "structure" of the object, the rest of the methods can
+remain the same, so C<speak> still works as before.
+
+=end original
+
+もちろん、C<name> と C<named> だけがオブジェクトの「構造」を
+参照していたので、残りのメソッドはそのままにしておくことができます;
+C<speak> は前のままでそのまま動作します。
+
+=head2 A horse of a different color
+
+(違った色の馬)
+
+=begin original
+
+But having all our horses be brown would be boring. So let's add a
+method or two to get and set the color.
+
+=end original
+
+でも私たちの馬の全部が全部茶色では飽きてしまいます。
+なので色を取得/設定するためのメソッドを一つか二つ作ってみましょう。
+
+ ## in Animal
+ sub color {
+ $_[0]->{Color}
+ }
+ sub set_color {
+ $_[0]->{Color} = $_[1];
+ }
+
+=begin original
+
+Note the alternate way of accessing the arguments: C<$_[0]> is used
+in-place, rather than with a C<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:
+
+=end original
+
+引数にアクセスするための別の方法に関する補足:
+C<$_[0]> は C<shift> をせずにすぐにに使うことができます。
+(これは頻繁に呼び出される箇所で時間を節約することができます。)
+さてこれで Mr. Ed の色を変えることができます:
+
+ my $horse = Horse->named("Mr. Ed");
+ $horse->set_color("black-and-white");
+ print $horse->name, " is colored ", $horse->color, "\n";
+
+=begin original
+
+which results in:
+
+=end original
+
+これは次の結果になります:
+
+ Mr. Ed is colored black-and-white
+
+=head2 Summary
+
+(まとめ)
+
+=begin original
+
+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 C<UNIVERSAL> class, and so on.
+That's for the rest of the Perl documentation to cover. Hopefully, this
+gets you started, though.
+
+=end original
+
+さて、これまでにクラスメソッド、コンストラクタ、インスタンスメソッド、
+インスタンスデータ、そしてアクセッサをも見てきました。
+しかしこれらは Perl の提供しているもののまだ始まりにすぎません。
+まだゲッター(getter)でありセッター(setter)でもあるアクセッサやデストラクタ、
+間接オブジェクト表記、オーバーロード、"isa" および "can" によるテスト、
+C<UNIVERSAL> クラス、等々についてはまだ話し始めてもいません。
+これらは他の Perl ドキュメントでカバーされています。
+願わくば、これがあなたの一歩となりますように。
+
+=head1 SEE ALSO
+
+=begin original
+
+For more information, see L<perlobj> (for all the gritty details about
+Perl objects, now that you've seen the basics), L<perltoot> (the
+tutorial for those who already know objects), L<perltooc> (dealing
+with class data), L<perlbot> (for some more tricks), and books such as
+Damian Conway's excellent I<Object Oriented Perl>.
+
+=end original
+
+もっと詳しい情報は、
+L<perlobj> (ここで基礎を見た、Perl オブジェクトに関するすべての強固な詳細)、
+L<perltoot> (オブジェクトを知っている人のためのチュートリアル)、
+L<perltooc> (クラスデータの取り扱い)、
+L<perlbot> (もっとトリッキーなこととか)、
+そして Damian Conway の優秀な I<Object Oriented Perl> 等の書籍を
+参照してください。
+
+=begin original
+
+Some modules which might prove interesting are Class::Accessor,
+Class::Class, Class::Contract, Class::Data::Inheritable,
+Class::MethodMaker and Tie::SecureHash
+
+=end original
+
+おもしろさを垣間見れるモジュールとして、Class::Accessor, Class::Class,
+Class::Contract, Class::Data::Inheritable, Class::MethodMaker,
+Tie::SecureHash。
+
+=head1 COPYRIGHT
+
+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 I<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 I<Linux Magazine> and used with permission.
+
+=begin meta
+
+Transrate: 山科 氷魚 (YAMASHINA Hio) <hio****@hio*****>
+Update: Kentaro Shirakata <argra****@ub32*****> (5.10.0-)
+Status: completed
+
+=end meta
+