欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

第十三章 Perl的面向?qū)ο缶幊?/p>

by flamephoenix

一、模塊簡介
二、Perl中的類
三、創(chuàng)建類
四、構(gòu)造函數(shù)
  • 實例變量

    • 五、方法
    六、方法的輸出
    七、方法的調(diào)用
    八、重載
    九、析構(gòu)函數(shù)
    十、繼承
    十一、方法的重載
    十二、Perl類和對象的一些注釋

        本章介紹如何使用Perl的面向?qū)ο缶幊?OOP)特性及如何構(gòu)建對象，還包括繼承、方法重載和數(shù)據(jù)封裝等內(nèi)容。
    一、模塊簡介
        模塊(module)就是Perl包(pachage)。Perl中的對象基于對包中數(shù)據(jù)項的引用。（引用見第x章引用）。
    詳見http://www.metronet.com的perlmod和perlobj。
        在用其它語言進行面向?qū)ο缶幊虝r，先聲明一個類然后創(chuàng)建該類的對象（實例），特定類所有對象的行為方式是相同的，由類方法確定，可以通過定義新類或從現(xiàn)存類繼承來創(chuàng)建類。已熟悉面向?qū)ο缶幊痰娜丝梢栽诖擞龅皆S多熟悉的術(shù)語。Perl一直是一個面向?qū)ο蟮恼Z言，在Perl5中，語法略有變動，更規(guī)范化了對象的使用。
        下面三個定義對理解對象、類和方法在Perl中如何工作至關(guān)重要。
        .類是一個Perl包，其中含提供對象方法的類。
        .方法是一個Perl子程序，類名是其第一個參數(shù)。
        .對象是對類中數(shù)據(jù)項的引用。
    二、Perl中的類
        再強調(diào)一下，一個Perl類是僅是一個包而已。當你看到Perl文檔中提到“類”時，把它看作“包”就行了。Perl5的語法可以創(chuàng)建類，如果你已熟悉C++，那么大部分語法你已經(jīng)掌握了。與Perl4不同的概念是用雙冒號(::)來標識基本類和繼承類（子類）。
        面向?qū)ο蟮囊粋�重要特性是繼承。Perl中的繼承特性與其它面向?qū)ο笳Z言不完全一樣，它只繼承方法，你必須用自己的機制來實現(xiàn)數(shù)據(jù)的繼承。
        因為每個類是一個包，所以它有自己的名字空間及自己的符號名關(guān)聯(lián)數(shù)組（詳見第x章關(guān)聯(lián)數(shù)組），每個類因而可以使用自己的獨立符號名集。與包的引用結(jié)合，可以用單引號(')操作符來定位類中的變量，類中成員的定位形式如：$class'$member。在Perl5中，可用雙冒號替代單引號來獲得引用，如：$class'$member與$class::$member相同。
    三、創(chuàng)建類。
        本節(jié)介紹創(chuàng)建一個新類的必要步驟。下面使用的例子是創(chuàng)建一個稱為Cocoa的簡單的類，其功能是輸出一個簡單的Java應用的源碼的必要部分。放心，這個例子不需要你有Java的知識，但也不會使你成為Java專家，其目的是講述創(chuàng)建類的概念。
        首先，創(chuàng)建一個名為Cocoa.pm的包文件(擴展名pm是包的缺省擴展名，意為Perl Module)。一個模塊就是一個包，一個包就是一個類。在做其它事之前，先加入“1;”這樣一行，當你增加其它行時，記住保留“1;”為最后一行。這是Perl包的必需條件，否則該包就不會被Perl處理。下面是該文件的基本結(jié)構(gòu)。
    package Cocoa;

    #
    # Put "require" statements in for all required,imported packages
    #

    #
    # Just add code here
    #

    1; # terminate the package with the required 1;
        接下來，我們往包里添加方法使之成為一個類。第一個需添加的方法是new()，它是創(chuàng)建對象時必須被調(diào)用的，new()方法是對象的構(gòu)造函數(shù)。
    四、構(gòu)造函數(shù)
        構(gòu)造函數(shù)是類的子程序，它返回與類名相關(guān)的一個引用。將類名與引用相結(jié)合稱為“祝�！币粋�對象，因為建立該結(jié)合的函數(shù)名為bless()，其語法為：
        bless YeReference [,classname]
        YeReference是對被“祝�！钡膶ο蟮囊茫琧lassname是可選項，指定對象獲取方法的包名，其缺省值為當前包名。
        創(chuàng)建一個構(gòu)建函數(shù)的方法為返回已與該類結(jié)合的內(nèi)部結(jié)構(gòu)的引用，如：
    sub new {
      my $this = {}; # Create an anonymous hash, and #self points to it.
      bless $this; # Connect the hash to the package Cocoa.
      return $this; # Return the reference to the hash.
    }

    1;
        {}創(chuàng)建一個對不含鍵/值對的哈希表（即關(guān)聯(lián)數(shù)組）的引用，返回值被賦給局域變量$this。函數(shù)bless()取出該引用，告訴對象它引用的是Cocoa，最后返回該引用。函數(shù)的返回值現(xiàn)在指向這個匿名哈希表。
        從new()函數(shù)返回后，$this引用被銷毀，但調(diào)用函數(shù)保存了對該哈希表的引用，因此該哈希表的引用數(shù)不會為零，從而使Perl在內(nèi)存中保存該哈希表。創(chuàng)建對象可如下調(diào)用：
        $cup = new Cocoa;
        下面語句為使用該包創(chuàng)建對象的例子：
    1 #!/usr/bin/perl
    2 push (@INC,'pwd');
    3 use Cocoa;
    4 $cup = new Cocoa;
        第一行指出Perl解釋器的位置，第二行中，將當前目錄加到路徑尋找列表@INC中供尋找包時使用。你也可以在不同的目錄中創(chuàng)建你的模塊并指出該絕對路徑。例如，如果在/home/test/scripts/創(chuàng)建包，第二行就應該如下：
        push (@INC , "/home/test/scripts");
        在第三行中，包含上包Cocoa.pm以獲取腳本中所需功能。use語句告訴Perl在@INC路徑尋找文件Cocoa.pm并包含到解析的源文件拷貝中。use語句是使用類必須的。第四行調(diào)用new函數(shù)創(chuàng)建對象，這是Perl的妙處，也是其易混淆之處，也是其強大之處。創(chuàng)建對象的方法有多種，可以這樣寫：
        $cup = cocoa->new();
        如果你是C程序員，可以用雙冒號強制使用Cocoa包中的new()函數(shù)，如：
        $cup = Cocoa::new();
        可以在構(gòu)造函數(shù)中加入更多的代碼，如在Cocoa.pm中，可以在每個對象創(chuàng)建時輸出一個簡單聲明，還可以用構(gòu)造函數(shù)初始化變量或設置數(shù)組或指針。
    注意：
    1、一定要在構(gòu)造函數(shù)中初始化變量；
    2、一定要用my函數(shù)在方法中創(chuàng)建變量；
    3、一定不要在方法中使用local，除非真的想把變量傳遞給其它子程序；
    4、一定不要在類模塊中使用全局變量。
        加上聲明的Cocoa構(gòu)造函數(shù)如下：
    sub new {
      my $this = {};
      print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk";
      print "\n ** Did this code even get pass the javac compiler? ";
      print "\n **/ \n";
      bless $this;
      return $this;
    }
        也可以簡單地調(diào)用包內(nèi)或包外的其它函數(shù)來做更多的初始化工作，如：
    sub new {
      my $this = {}
      bless $this;
      $this->doInitialization();
      return $this;
    }
        創(chuàng)建類時，應該允許它可被繼承，應該可以把類名作為第一個參數(shù)來調(diào)用new函數(shù)，那么new函數(shù)就象下面的語句：
    sub new {
      my $class = shift; # Get the request class name
      my $this = {};
      bless $this, $class # Use class name to bless() reference
      $this->doInitialization(); return $this;
    }
        此方法使用戶可以下列三種方式之一來進行調(diào)用：
  • Cocoa::new()
  • Cocoa->new()
  • new Cocoa
    •     可以多次bless一個引用對象，然而，新的將被bless的類必然把對象已被bless的引用去掉，對C和Pascal程序員來說，這就象把一個指針賦給分配的一塊內(nèi)存，再把同一指針賦給另一塊內(nèi)存而不釋放掉前一塊內(nèi)存�？傊粋�Perl對象每一時刻只能屬于一個類。
        對象和引用的真正區(qū)別是什么呢？Perl對象被bless以屬于某類，引用則不然，如果引用被bless，它將屬于一個類，也便成了對象。對象知道自己屬于哪個類，引用則不屬于任何類。

  • 實例變量


    •     作為構(gòu)造函數(shù)的new()函數(shù)的參數(shù)叫做實例變量。實例變量在創(chuàng)建對象的每個實例時用于初始化，例如可以用new()函數(shù)為對象的每個實例起個名字。
        可以用匿名哈希表或匿名數(shù)組來保存實例變量。
        用哈希表的代碼如下：
    sub new {
    my $type = shift;
    my %parm = @_;
    my $this = {};
    $this->{'Name'} = $parm{'Name'};
    $this->{'x'} = $parm{'x'};
    $this->{'y'} = $parm{'y'};
    bless $this, $type;
    }
        用數(shù)組保存的代碼如下：
    sub new {
    my $type = shift;
    my %parm = @_;
    my $this = [];
    $this->[0] = $parm{'Name'};
    $this->[1] = $parm{'x'};
    $this->[2] = $parm{'y'};
    bless $this, $type;
    }
        構(gòu)造對象時，可以如下傳遞參數(shù)：
        $mug = Cocoa::new( 'Name' => 'top','x' => 10,'y' => 20 );
        操作符=>與逗號操作服功能相同，但=>可讀性好。訪問方法如下：
        print "Name=$mug->{'Name'}\n";
        print "x=$mug->{'x'}\n";
        print "y=$mug->{'y'}\n";
    五、方法
        Perl類的方法只不過是一個Perl子程序而已，也即通常所說的成員函數(shù)。Perl的方法定義不提供任何特殊語法，但規(guī)定方法的第一個參數(shù)為對象或其被引用的包。Perl有兩種方法：靜態(tài)方法和虛方法。
        靜態(tài)方法第一個參數(shù)為類名，虛方法第一個參數(shù)為對象的引用。方法處理第一個參數(shù)的方式?jīng)Q定了它是靜態(tài)的還是虛的。靜態(tài)方法一般忽略掉第一個參數(shù)，因為它們已經(jīng)知道自己在哪個類了，構(gòu)造函數(shù)即靜態(tài)方法。虛方法通常首先把第一個參數(shù)shift到變量self或this中，然后將該值作普通的引用使用。如：
    1. sub nameLister {
    2.     my $this = shift;
    3.     my ($keys ,$value );
    4.     while (($key, $value) = each (%$this)) {
    5.         print "\t$key is $value.\n";
    6.     }
    7. }
    六、方法的輸出
        如果你現(xiàn)在想引用Cocoa.pm包，將會得到編譯錯誤說未找到方法，這是因為Cocoa.pm的方法還沒有輸出。輸出方法需要Exporter模塊，在包的開始部分加上下列兩行：
        require Exporter;
        @ISA = qw (Exporter);
        這兩行包含上Exporter.pm模塊，并把Exporter類名加入@ISA數(shù)組以供查找。接下來把你自己的類方法列在@EXPORT數(shù)組中就可以了。例如想輸出方法closeMain和declareMain，語句如下：
        @EXPORT = qw (declareMain , closeMain);
        Perl類的繼承是通過@ISA數(shù)組實現(xiàn)的。@ISA數(shù)組不需要在任何包中定義，然而，一旦它被定義，Perl就把它看作目錄名的特殊數(shù)組。它與@INC數(shù)組類似，@INC是包含文件的尋找路徑。@ISA數(shù)組含有類(包)名，當一個方法在當前包中未找到時就到@ISA中的包去尋找。@ISA中還含有當前類繼承的基類名。
        類中調(diào)用的所有方法必須屬于同一個類或@ISA數(shù)組定義的基類。如果一個方法在@ISA數(shù)組中未找到，Perl就到AUTOLOAD()子程序中尋找，這個可選的子程序在當前包中用sub定義。若使用AUTOLOAD子程序，必須用use Autoload;語句調(diào)用autoload.pm包。AUTOLOAD子程序嘗試從已安裝的Perl庫中裝載調(diào)用的方法。如果AUTOLOAD也失敗了，Perl再到UNIVERSAL類做最后一次嘗試，如果仍失敗，Perl就生成關(guān)于該無法解析函數(shù)的錯誤。
    七、方法的調(diào)用
        調(diào)用一個對象的方法有兩種方法，一是通過該對象的引用（虛方法），一是直接使用類名（靜態(tài)方法）。當然該方法必須已被輸出。現(xiàn)在給Cocoa類增加一些方法，代碼如下：
    package Cocoa;
    require Exporter;
    @ISA = qw(Exporter);
    @EXPORT = qw(setImports, declareMain, closeMain);
    #
    # This routine creates the references for imports in Java functions
    #
    sub setImports{
      my $class = shift @_;
      my @names = @_;
      foreach (@names) {
        print "import " . $_ . ";\n";
      }
    }
    #
    # This routine declares the main function in a Java script
    #
    sub declareMain{
      my $class = shift @_;
      my ( $name, $extends, $implements) = @_;
      print "\n public class $name";
      if ($extends) {
        print " extends " . $extends;
      }
      if ($implements) {
        print " implements " . $implements;
      }
      print " { \n";
    }
    #
    # This routine declares the main function in a Java script
    #
    sub closeMain{
      print "} \n";
    }
    #
    # This subroutine creates the header for the file.
    #
    sub new {
      my $this = {};
      print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk \n */ \n";
      bless $this;
      return $this;
    }

    1;
        現(xiàn)在，我們寫一個簡單的Perl腳本來使用該類的方法，下面是創(chuàng)建一個Java applet源代碼骨架的腳本代碼：
    #!/usr/bin/perl
    use Cocoa;
    $cup = new Cocoa;
    $cup->setImports( 'java.io.InputStream', 'java.net.*');
    $cup->declareMain( "Msg" , "java.applet.Applet", "Runnable");
    $cup->closeMain();
        這段腳本創(chuàng)建了一個叫做Msg的Java applet，它擴展(extend)了java.applet.Applet小應用程序并使之可運行(runnable)，其中最后三行也可以寫成如下：
    Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');
    Cocoa::declareMain($cup, "Msg" , "java.applet.Applet", "Runnable");
    Cocoa::closeMain($cup);
        其運行結(jié)果如下：
    /*
    ** Created by Cocoa.pm
    ** Use at own risk
    */
    import java.io.InputStream;
    import java.net.*;

    public class Msg extends java.applet.Applet implements Runnable {
    }
        注意：如果用->操作符調(diào)用方法（也叫間接調(diào)用），參數(shù)必須用括號括起來，如：$cup->setImports( 'java.io.InputStream', 'java.net.*');而雙冒號調(diào)用如：Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');也可去掉括號寫成：Cocoa::setImports $cup, 'java.io.InputStream', 'java.net.*' ;
    八、重載
        有時需要指定使用哪個類的方法，如兩個不同的類有同名方法的時候。假設類Espresso和Qava都定義了方法grind，可以用::操作符指定使用Qava的方法：
        $mess = Qava::grind("whole","lotta","bags");
        Qava::grind($mess, "whole","lotta","bags");
        可以根據(jù)程序的運行情況來選擇使用哪個類的方法，這可以通過使用符號引用去調(diào)用來實現(xiàn)：
        $method = $local ? "Qava::" : "Espresso::";
        $cup->{$method}grind(@args);
    九、析構(gòu)函數(shù)
        Perl跟蹤對象的鏈接數(shù)目，當某對象的最后一個應用釋放到內(nèi)存池時，該對象就自動銷毀。對象的析構(gòu)發(fā)生在代碼停止后，腳本將要結(jié)束時。對于全局變量而言，析構(gòu)發(fā)生在最后一行代碼運行之后。
        如果你想在對象被釋放之前獲取控制權(quán)，可以定義DESTROY()方法。DESTROY()在對象將釋放前被調(diào)用，使你可以做一些清理工作。DESTROY()函數(shù)不自動調(diào)用其它DESTROY()函數(shù)，Perl不做內(nèi)置的析構(gòu)工作。如果構(gòu)造函數(shù)從基類多次bless，DESTROY()可能需要調(diào)用其它類的DESTROY()函數(shù)。當一個對象被釋放時，其內(nèi)含的所有對象引用自動釋放、銷毀。
        一般來說，不需要定義DESTROY()函數(shù)，如果需要，其形式如下：
    sub DESTROY {
    #
    # Add code here.
    #
    }
        因為多種目的，Perl使用了簡單的、基于引用的垃圾回收系統(tǒng)。任何對象的引用數(shù)目必須大于零，否則該對象的內(nèi)存就被釋放。當程序退出時，Perl的一個徹底的查找并銷毀函數(shù)進行垃圾回收，進程中的一切被簡單地刪除。在UNIX類的系統(tǒng)中，這像是多余的，但在內(nèi)嵌式系統(tǒng)或多線程環(huán)境中這確實很必要。
    十、繼承
        類方法通過@ISA數(shù)組繼承，變量的繼承必須明確設定。下例創(chuàng)建兩個類Bean.pm和Coffee.pm，其中Coffee.pm繼承Bean.pm的一些功能。此例演示如何從基類（或稱超類）繼承實例變量，其方法為調(diào)用基類的構(gòu)造函數(shù)并把自己的實例變量加到新對象中。
        Bean.pm代碼如下：
    package Bean;
    require Exporter;
    @ISA = qw(Exporter);
    @EXPORT = qw(setBeanType);

    sub new {
      my $type = shift;
      my $this = {};
      $this->{'Bean'} = 'Colombian';
      bless $this, $type;
      return $this;
    }

    #
    # This subroutine sets the class name
    sub setBeanType{
      my ($class, $name) = @_;
      $class->{'Bean'} = $name;
      print "Set bean to $name \n";
    }
    1;
        此類中，用$this變量設置一個匿名哈希表，將'Bean'類型設為'Colombian'。方法setBeanType()用于改變'Bean'類型，它使用$class引用獲得對對象哈希表的訪問。
        Coffee.pm代碼如下：
    1  #
    2  # The Coffee.pm file to illustrate inheritance.
    3  #
    4  package Coffee;
    5  require Exporter;
    6  require Bean;
    7  @ISA = qw(Exporter, Bean);
    8  @EXPORT = qw(setImports, declareMain, closeMain);
    9  #
    10 # set item
    11 #
    12 sub setCoffeeType{
    13   my ($class,$name) = @_;
    14   $class->{'Coffee'} = $name;
    15   print "Set coffee type to $name \n";
    16   }
    17 #
    18 # constructor
    19 #
    20 sub new {
    21   my $type = shift;
    22   my $this = Bean->new(); ##### <- LOOK HERE!!! ####
    23   $this->{'Coffee'} = 'Instant'; # unless told otherwise
    24   bless $this, $type;
    25   return $this;
    26   }
    27 1;
        第6行的require Bean;語句包含了Bean.pm文件和所有相關(guān)函數(shù)，方法setCoffeeType()用于設置局域變量$class->{'Coffee'}的值。在構(gòu)造函數(shù)new()中，$this指向Bean.pm返回的匿名哈希表的指針，而不是在本地創(chuàng)建一個，下面兩個語句分別為創(chuàng)建不同的哈希表從而與Bean.pm構(gòu)造函數(shù)創(chuàng)建的哈希表無關(guān)的情況和繼承的情況：
        my $this = {}; #非繼承
        my $this = $theSuperClass->new(); #繼承
        下面代碼演示如何調(diào)用繼承的方法：
    1  #!/usr/bin/perl
    2  push (@INC,'pwd');
    3  use Coffee;
    4  $cup = new Coffee;
    5  print "\n -------------------- Initial values ------------ \n";
    6  print "Coffee: $cup->{'Coffee'} \n";
    7  print "Bean: $cup->{'Bean'} \n";
    8  print "\n -------------------- Change Bean Type ---------- \n";
    9  $cup->setBeanType('Mixed');
    10 print "Bean Type is now $cup->{'Bean'} \n";
    11 print "\n ------------------ Change Coffee Type ---------- \n";
    12 $cup->setCoffeeType('Instant');
    13 print "Type of coffee: $cup->{'Coffee'} \n";
        該代碼的結(jié)果輸出如下：
    -------------------- Initial values ------------
    Coffee: Instant
    Bean: Colombian
    -------------------- Change Bean Type ----------
    Set bean to Mixed
    Bean Type is now Mixed
    ------------------ Change Coffee Type ----------
    Set coffee type to Instant
    Type of coffee: Instant
        上述代碼中，先輸出對象創(chuàng)建時哈希表中索引為'Bean'和'Coffee'的值，然后調(diào)用各成員函數(shù)改變值后再輸出。
        方法可以有多個參數(shù)，現(xiàn)在向Coffee.pm模塊增加函數(shù)makeCup()，代碼如下：
    sub makeCup {
      my ($class, $cream, $sugar, $dope) = @_;
      print "\n================================== \n";
      print "Making a cup \n";
      print "Add cream \n" if ($cream);
      print "Add $sugar sugar cubes\n" if ($sugar);
      print "Making some really addictive coffee ;-) \n" if ($dope);
      print "================================== \n";
    }
        此函數(shù)可有三個參數(shù)，不同數(shù)目、值的參數(shù)產(chǎn)生不同的結(jié)果，例如：
    1  #!/usr/bin/perl
    2  push (@INC,'pwd');
    3  use Coffee;
    4  $cup = new Coffee;
    5  #
    6  # With no parameters
    7  #
    8  print "\n Calling with no parameters: \n";
    9  $cup->makeCup;
    10 #
    11 # With one parameter
    12 #
    13 print "\n Calling with one parameter: \n";
    14 $cup->makeCup('1');
    15 #
    16 # With two parameters
    17 #
    18 print "\n Calling with two parameters: \n";
    19 $cup->makeCup(1,'2');
    20 #
    21 # With all three parameters
    22 #
    23 print "\n Calling with three parameters: \n";
    24 $cup->makeCup('1',3,'1');
        其結(jié)果輸出如下：
    Calling with no parameters:
    ==================================
    Making a cup
    ==================================
    Calling with one parameter:
    ==================================
    Making a cup
    Add cream
    ==================================
    Calling with two parameters:
    ==================================
    Making a cup
    Add cream
    Add 2 sugar cubes
    ==================================
    Calling with three parameters:
    ==================================
    Making a cup
    Add cream
    Add 3 sugar cubes
    Making some really addictive coffee ;-)
    ==================================
        在此例中，函數(shù)makeCup()的參數(shù)既可為字符串也可為整數(shù)，處理結(jié)果相同，你也可以把這兩種類型的數(shù)據(jù)處理區(qū)分開。在對參數(shù)的處理中，可以設置缺省的值，也可以根據(jù)實際輸入?yún)?shù)值的個數(shù)給予不同處理。
    十一、子類方法的重載
        繼承的好處在于可以獲得基類輸出的方法的功能，而有時需要對基類的方法重載以獲得更具體或不同的功能。下面在Bean.pm類中加入方法printType()，代碼如下：
    sub printType {
      my $class = shift @_;
      print "The type of Bean is $class->{'Bean'} \n";
    }
        然后更新其@EXPORT數(shù)組來輸出：
        @EXPORT = qw ( setBeanType , printType );
        現(xiàn)在來調(diào)用函數(shù)printType()，有三種調(diào)用方法：
    $cup->Coffee::printType();
    $cup->printType();
    $cup->Bean::printType();
        輸出分別如下：
    The type of Bean is Mixed
    The type of Bean is Mixed
    The type of Bean is Mixed
        為什么都一樣呢？因為在子類中沒有定義函數(shù)printType()，所以實際均調(diào)用了基類中的方法。如果想使子類有其自己的printType()函數(shù)，必須在Coffee.pm類中加以定義：
    #
    # This routine prints the type of $class->{'Coffee'}
    #
    sub printType {
      my $class = shift @_;
      print "The type of Coffee is $class->{'Coffee'} \n";
    }
        然后更新其@EXPORT數(shù)組：
        @EXPORT = qw(setImports, declareMain, closeMain, printType);
        現(xiàn)在輸出結(jié)果變成了：
    The type of Coffee is Instant
    The type of Coffee is Instant
    The type of Bean is Mixed
        現(xiàn)在只有當給定了Bean::時才調(diào)用基類的方法，否則直接調(diào)用子類的方法。
        那么如果不知道基類名該如何調(diào)用基類方法呢？方法是使用偽類保留字SUPER::。在類方法內(nèi)使用語法如：$this->SUPER::function(...argument list...); ，它將從@ISA列表中尋找。剛才的語句用SUPER::替換Bean::可以寫為$cup->SUPER::printType(); ，其結(jié)果輸出相同，為：
    The type of Bean is Mixed
    十二、Perl類和對象的一些注釋
        OOP的最大好處就是代碼重用。OOP用數(shù)據(jù)封裝來隱藏一些復雜的代碼，Perl的包和模塊通過my函數(shù)提供數(shù)據(jù)封裝功能，但是Perl并不保證子類一定不會直接訪問基類的變量，這確實減少了數(shù)據(jù)封裝的好處，雖然這種動作是可以做到的，但卻是個很壞的編程風格。
    注意：
    1、一定要通過方法來訪問類變量。
    2、一定不要從模塊外部直接訪問類變量。
        當編寫包時，應該保證方法所需的條件已具備或通過參數(shù)傳遞給它。在包內(nèi)部，應保證對全局變量的訪問只用通過方法傳遞的引用來訪問。對于方法要使用的靜態(tài)或全局數(shù)據(jù)，應該在基類中用local()來定義，子類通過調(diào)用基類來獲取。有時，子類可能需要改變這種數(shù)據(jù)，這時，基類可能就不知道怎樣去尋找新的數(shù)據(jù)，因此，這時最好定義對該數(shù)據(jù)的引用，子類和基類都通過引用來改變該數(shù)據(jù)。
        最后，你將看到如下方式來使用對象和類：
        use coffee::Bean;
        這句語句的含義是“在@INC數(shù)組所有目錄的Coffee子目錄來尋找Bean.pm”。如果把Bean.pm移到./Coffee目錄，上面的例子將用這一use語句來工作。這樣的好處是有條理地組織類的代碼。再如，下面的語句：
        use Another::Sub::Menu;
        意味著如下子目錄樹：
        ./Another/Sub/Menu.pm

    上一章 下一章 目錄