Provided by: manpages-zh_1.5-1_all bug

NAME

       perlboot - 初学者的面向对象教程

DESCRIPTION述
       如果你对其他语言中的对象并不熟悉的话,
       那么其他有关perl对象的文件可能使你感到恐惧, 比如 perlobj ,
       这是基础性的参考文件, 和 perltoot, 这是介绍perl对象的特性的教程.

       所以, 让我们走另一条路,假定你没有任何关于对象的概念. 你需要了解子程序
       (perlsub), 引用 (perlref et. seq.), 和 包(或模块) (perlmod),
       如果还不清楚的话,先把他们搞清楚.

       If we could talk to the animals...Introducing the method invocation arrow号

       现在,我们说 "Class->method" 是调用了包(或模块)"Class"中的 "method"
       方法。(Here, "Class" is used in its "category" meaning, not its
       "scholastic" meaning.) 不是很准确,不过我们会一步一步的来做.
       现在,可以这样做:

           # 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" 预编译指令时也可以正常工作了.

       Invoking a barnyard棚

       现在让我们把箭头用到牲口棚的例子中,范例:

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

       现在我们所有的动物都能说话了, 而且不用使用代码引用.

       不过注意到那些相同的代码. 每个 "speak" 子程序的结构是相同的: 一个
       "print" 操作符和一个基本相同的字符串,只有两个词不同.
       如果我们可以析出相同的部分就更好了,如果将来要把 "goes" 替换为 "says"
       时就简单得多了

       实际上这并不困难, 不过在这之前我们应该对箭头符号了解的更多一些.

       The extra parameter of method invocation数

       语句:

           Class->method(@args)

       这样调用函数 "Class::method":

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

       (如果子程序找不到,"继承,inheritance" 开始起作用,这在后面会讲到).
       这意味着我们得到的第一个参数是类名(如果没有给出其他参数,它就是调用时的唯一参数).所以我们可以象这样重写
       "Sheep" speaking 子程序:

           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  都会得到与子程序相关的正确的值. 但是,还是有很多相似的结构.
       可以再简单些吗? 是的. 可以通过在一个类中调用其它的方法来实现.

       Calling a second method to simplify things作

       我们在 "speak" 中调用 "sound". 这个方法提供声音的内容.

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

       现在, 当我们调用 "Cow->speak" 时, 我们在 "speak" 中得到 "Cow" 的类
       $class. 他会选择 "Cow->sound" 方法, 然后返回 "moooo". 那如果是 "Horse"
       呢?

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

       仅仅包名和声音有变化. 因此我们可以在Cow和Horse中共用 "speak" 吗?
       是的,通过继承实现!

       Inheriting the windpipes管

       我们创建一个公共函数包,命名为 "Animal",在其中定义 "speak":

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

       然后,在每个动物那里 "继承,inherits" "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". 找到了,
       然后调用该子程序, 参数在一开始就被固定了.

       在子程序 "Animal::speak" 中, $class 是 "Cow" (第一个参数). 在我们调用
       "$class->sound" 时, 首先寻找 "Cow->sound" , 找到了, 因此不用查看 @ISA.
       成功!

      @ISAOverriding the methods载

       让我们添上一只老鼠, 它的声音差不多听不到:

           # 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" 有它自己的speak 函数, 所以 "Mouse->speak"
       不会调用"Animal->speak". 这叫做重载 "overriding". 实际上,
       我们甚至不用说"Mouse" 是 "Animal", 因为 "speak" 所用到的所有方法在
       "Mouse" 中都有定义.

       但是有些代码与 "Animal->speak" 的相同 , 这在程序维护时是个问题.
       我们能不能让 "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";
             }
           }

       注意我们必须使用 $class (几乎肯定是"Mouse") 作为 "Animal::speak"
       的第一个参数, 因为我们没有用箭头符号. 那为什么不用呢? 嗯,
       如果我们在那儿调用 "Animal->speak", 则第一个参数是 "Animal" 而不是
       "Mouse" , 这样当调用 "sound" 时, 就找不到正确的函数了.

       虽然如此,直接调用 "Animal::speak" 确实不怎么好. 万一 "Animal::speak"
       不存在, 而是继承自 @Animal::ISA 中的某个类呢? 因为没有使用箭头符号,
       我们只有一次机会去调用正确的函数.

       还要注意到,现在类名 "Animal" 直接在子程序中使用.
       如果维护代码的人没有注意到这一点, 改变了 <Mouse> 的 @ISA,没有注意到
       "speak" 用到了 "Animal" 那就会出问题. 因此, 这可能不是一个好方法.

       Starting the search from a different place找

       较好的解决办法是让Perl从继承链的上一级开始寻找:

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

       这就对了. 使用这一语法, 我们从 "Animal" 寻找 "speak", 在找不到时寻找
       "Animal" 的继承链.且第一个参数是 $class, 所以 "speak" 和"Mouse::sound"
       都会被正确地调用.

       但这还不是最好的方法.我们还必须调整 @ISA 的元素顺序. 更糟糕的是, 如果
       "Mouse" 有多个父类在 @ISA, 我们还要知道哪个类定义了 "speak".
       那么,有没有更好的办法呢?

       The SUPER way of doing thingsSUPERWhere we're at so far...A horse is a horse, of course of course -- or is it?
      ?

       我们从 "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!

       但是我们所有的马都是相同的. 如果我增加一个子程序, 所有的马都会共享它.
       这在创建相同的马时确实不错, 但是我们如何能够区分不同的马呢? 比如,
       假设我想给我的第一匹马起个名字.
       应该有办法使得它的名字和别的马的名字不同.

       这可以通过创建一个 "实例,instance" 来实现. 实例是由类创建的. 在Perl中,
       任何引用都可以是实例, 就让我们从最简单的引用开始吧,一个标量引用:

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

       现在 $talking 是指向实例特有数据( $name
       )的引用。把这个引用变成真正的实例的是一个特殊的操作符,叫做 "bless":

         bless $talking, Horse;

       这个操作符把包名 "Horse" 中的所有信息存放到引用所指向的东西中.
       这时,我们说 $talking 是 "Horse" 的一个实例 . 也就是说,
       它是一匹独特的马. 引用并没有改变, 还可以用于间接引用操作符.

       Invoking an instance method法

       箭头符号可以用于实例. 那么, 听听 $talking 的声音吧:

         my $noise = $talking->sound;

       要调用 "sound", Perl 首先注意到 $talking 是一个 blessed 引用
       (因此是一个实例). 它会构造一个参数列表, 现在只有 $talking.
       (在后面我们会看到参数们在实例变量之后, 与使用类时相似.)

       然后,是真正有意思的部分: Perl 查找实例所属的类, 这里是 "Horse",
       在其中寻找对应的方法. 这里, "Horse::sound" 直接可以找到(不用使用继承),
       最后这样调用:

         Horse::sound($talking)

       注意这里的第一个参数还是实例本身, 而不像前面我们学到的是类名.
       最后返回值是 "neigh", 它被赋值给 $noise 变量.

       如果找不到 Horse::sound, 会在 @Horse::ISA 列表中查找.
       类方法与实例方法的唯一区别是调用时的第一个参数是实例(一个blessed引用)还是一个类名(一个字符串).

       Accessing the instance data据

       因为我们得到的第一个参数是实例,我们可以访问实例特有的数据.
       我们可以取得马的名字:

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

       现在,我们调用名字:

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

       在 "Horse::name" 中, @_ 数组仅含有 $talking, shift 将 $talking 赋给了
       $self. (传统上我们在处理实例方法时总是把第一个元素赋给 $self,
       所以你也应该这么做, 除非你有不这样做的充分理由.) 然后, $self
       被标量化,成为 "Mr. Ed", 这就行了. 输出是:

         Mr. Ed says neigh.

       How to build a horse马

       当然啦,如果我们手工创建所有的马, 我们会出很多错误.
       不仅如此,我们还亵渎了面向对象编程的特性,因为在那种情况下马的"内脏"也可见了.
       如果你是兽医的话,这倒正好, 可是如果你仅仅是个爱马者呢? 所以,我们让
       Horse 类来创建一匹新马:

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

       现在,我们可以用 "named" 方法创建一匹马:

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

       注意到我们有回到了类方法, 所以传递给 "Horse::named" 的两个参数是
       "Horse" 和 "Mr. Ed". "bless" 操作符不仅将 $name 实例化, 且将指向 $name
       的引用作为返回值返回. 这样, 我们就创建了一匹马.

       这里,我们调用了构造器 "named", 它的参数就是特定的 "Horse" 的名字.
       你可以使用不同的构造器用不同的名字建立不同的对象(比如记录它的谱系或生日).
       但是, 你会发现多数使用Perl的人更喜欢把构造器命名为 "new",
       并使用不同的方法解释 "new" 的参数. 两种都挺好,只要你能创建对象就行.
       (你会自己创建一个,对吗?)

       Inheriting the constructor器

       但是那个方法中有没有什麽对于 "Horse" 来说比较特殊的东西呢? 没有. 因此,
       从 "Animal" 创建其它任何东西也可以使用相同的方法,我们来试试::

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

       好了, 但是以实例调用 "speak" 会产生什麽结果呢?

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

       我们得到的是:

         a Horse=SCALAR(0xaca42ac) goes neigh!

       为什麽?因为 "Animal::speak" 希望它的第一个参数是类名, 而不是实例.
       当实例被传入时,我们希望使用的是字符串而不是实例本身,显示的结果不是我们所希望的.

       Making a method work with either classes or instances
      例

       我们需要做的是让方法检测它是被实例调用的还是被类调用的.
       最直接的方法是使用 "ref" 操作符.
       它在参数是实例时返回字符串,在参数是类名时返回 "undef". 我们首先改写
       "name" 方法:

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

       在这儿, "?:" 操作符决定是选择间接引用(dereference)还是派生字符串.
       现在我们可以同时使用类或实例了. 注意我修改了第一个参数为 $either
       来表示期望的变化:

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

       我们可以改写 "speak" :

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

       而 "sound" 本来就可以工作. 那么现在就一切完成了!

       Adding parameters to a method数

       让我们训练动物们吃饭:

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

       试试吧:

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

       输出为:

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

       有参数的实例方法调用时首先得到实例的引用,然后得到参数的列表。因此第一个调用实际上是这样的:

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

       More interesting instances例

       如果实例需要更多的数据该怎么办呢? 更多的项目产生更有趣的实例,
       每个项目可以是一个引用或者甚至是一个对象.
       最简单的方法是把它们存放到哈希中. 哈希中的关键词叫做'实例变量"(instance
       variables)或者"成员变量"(member variables),相应的值也就是变量的值。

       但是我们怎么把马放到哈希中呢? 回忆到对象是被实例化(blessed)的引用.
       我们可以简单地创建一个祝福了的哈希引用,同时相关的的内容也作些修改就可以了.

       让我们创建一只有名字有颜色的绵羊:

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

       那么 "$bad->{Name}" 是 "Evil", "$bad->{Color}" 是 "black".
       但是我们想通过 "$bad->name" 存取绵羊的名字name,
       这有点的问题,因为现在它期望一个标量引用. 别担心,因为修正它很简单:

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

       "named" 当然还是创建标量的绵羊, 如下修正就好了:

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

       默认颜色 "default_color" 是什麽? 嗯, 如果 "named" 只有一个参数name,
       我们还是希望有个颜色, 所以我们设定一个类初始化颜色. 对绵羊来说,
       白色比较好:

         ## in Sheep
         sub default_color { "white" }

       为了避免为每个类定义颜色, 我们可以在 "Animal" 中定义一个
       "缺省的缺省,backstop" 的颜色:

         ## in Animal
         sub default_color { "brown" }

       现在, 因为只有 "name" 和 "named" 与对象的 "结构,structure" 相关,
       其余的部分可以保持不变, 所以 "speak" 工作正常.

       A horse of a different color马

       但是如果所有的马都是棕色的,也挺烦人的.
       所以我们可以写个方法来改变马的颜色.

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

       注意到存取参数的不同方法了吗: $_[0] 直接使用, 而没有用 "shift".
       (这在我们频繁存取时可以节省一些时间.) 现在我们可以把Mr. Ed的颜色变过来:

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

       结果是:

         Mr. Ed is colored black-and-white

       Summary结

       现在我们讲了类方法,构造器,实例方法,实例数据,甚至还有存取器(accessor).
       但是这些还仅仅是开始. 我们还没有讲到以两个函数 getters,setters
       形式出现的存取器,析构器(destructor),间接对象(indirect object
       notation),子类(subclasses that add instance data),per-class
       data,重载(overloading),"isa" 和 "can" 测试,公共类("UNIVERSAL"
       class),等等. 这有待其它文档去讲解了.
       无论如何,希望本文使你对对象有所了解.

SEE ALSO见
       更多信息可参见 perlobj (这里有更多的Perl对象的细节,而本文的是基础),
       perltoot (面向对象的中级教程),  perlbot  (更多的技巧),
       以及书籍,比如Damian Conway的不错的书叫做《面向对象的Perl (Object
       Oriented Perl)》。

       某些模块可能对你有用,它们是 Class::Accessor, Class::Class,
       Class::Contract, Class::Data::Inheritable, Class::MethodMaker 还有
       Tie::SecureHash

COPYRIGHT

       Copyright (c) 1999, 2000 by Randal L. Schwartz and Stonehenge
       Consulting Services, Inc.  Permission is hereby granted to distribute
       this document intact with the Perl distribution, and in accordance with
       the licenses of the Perl distribution; derived documents must include
       this copyright notice intact.

       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.

人
       redcandle <redcandle51@chinaren.com>

新
       2001129http://cmpp.linuxforum.net