第十三章 Perl的物件導向程式設計

 

 

    本章介紹如何使用Perl的物件導向程式設計(OOP)特性及如何構建物件，還包括繼承、方法過載和資料封裝等內容。
一、模組簡介
    模組(module)就是Perl包(pachage)。Perl中的物件基於對包中資料項的引用。（引用見第x章引用）。
詳見http://www.metronet.com/的perlmod和perlobj。
    在用其它語言進行物件導向程式設計時，先宣告一個類然後建立該類的物件（例項），特定類所有物件的行為方式是相同的，由類方法確定，可以通過定義新類或從現存類繼承來建立類。已熟悉物件導向程式設計的人可以在此遇到許多熟悉的術語。Perl一直是一個物件導向的語言，在Perl5中，語法略有變動，更規範化了物件的使用。
    下面三個定義對理解物件、類和方法在Perl中如何工作至關重要。
    .類是一個Perl包，其中含提供物件方法的類。
    .方法是一個Perl子程式，類名是其第一個引數。
    .物件是對類中資料項的引用。
二、Perl中的類
    再強調一下，一個Perl類是僅是一個包而已。當你看到Perl文件中提到“類”時，把它看作“包”就行了。Perl5的語法可以建立類，如果你已熟悉C++，那麼大部分語法你已經掌握了。與Perl4不同的概念是用雙冒號(::)來標識基本類和繼承類（子類）。
    物件導向的一個重要特性是繼承。Perl中的繼承特性與其它面嚮物件語言不完全一樣，它只繼承方法，你必須用自己的機制來實現資料的繼承。
    因為每個類是一個包，所以它有自己的名字空間及自己的符號名關聯陣列（詳見第x章關聯陣列），每個類因而可以使用自己的獨立符號名集。與包的引用結合，可以用單引號(')操作符來定位類中的變數，類中成員的定位形式如：$class'$member。在Perl5中，可用雙冒號替代單引號來獲得引用，如：$class'$member與$class::$member相同。
三、建立類。
    本節介紹建立一個新類的必要步驟。下面使用的例子是建立一個稱為Cocoa的簡單的類，其功能是輸出一個簡單的Java應用的原始碼的必要部分。放心，這個例子不需要你有Java的知識，但也不會使你成為Java專家，其目的是講述建立類的概念。
    首先，建立一個名為Cocoa.pm的包檔案(副檔名pm是包的預設副檔名，意為Perl Module)。一個模組就是一個包，一個包就是一個類。在做其它事之前，先加入“1;”這樣一行，當你增加其它行時，記住保留“1;”為最後一行。這是Perl包的必需條件，否則該包就不會被Perl處理。下面是該檔案的基本結構。

package Cocoa;

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

#
# Just add code here
#

1; # terminate the package with the required 1;

    接下來，我們往包裡新增方法使之成為一個類。第一個需新增的方法是new()，它是建立物件時必須被呼叫的，new()方法是物件的建構函式。
四、建構函式
    建構函式是類的子程式，它返回與類名相關的一個引用。將類名與引用相結合稱為“祝福”一個物件，因為建立該結合的函式名為bless()，其語法為：
    bless YeReference [,classname]
    YeReference是對被“祝福”的物件的引用，classname是可選項，指定物件獲取方法的包名，其預設值為當前包名。
    建立一個構建函式的方法為返回已與該類結合的內部結構的引用，如：

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;

    {}建立一個對不含鍵/值對的雜湊表（即關聯陣列）的引用，返回值被賦給局域變數$this。函式bless()取出該引用，告訴物件它引用的是Cocoa，最後返回該引用。函式的返回值現在指向這個匿名雜湊表。
    從new()函式返回後，$this引用被銷燬，但呼叫函式儲存了對該雜湊表的引用，因此該雜湊表的引用數不會為零，從而使Perl在記憶體中儲存該雜湊表。建立物件可如下呼叫：
    $cup = new Cocoa;
    下面語句為使用該包建立物件的例子：

1 #!/usr/bin/perl
2 push (@INC,'pwd');
3 use Cocoa;
4 $cup = new Cocoa;

    第一行指出Perl直譯器的位置，第二行中，將當前目錄加到路徑尋找列表@INC中供尋找包時使用。你也可以在不同的目錄中建立你的模組並指出該絕對路徑。例如，如果在/home/test/scripts/建立包，第二行就應該如下：
    push (@INC , "/home/test/scripts");
    在第三行中，包含上包Cocoa.pm以獲取指令碼中所需功能。use語句告訴Perl在@INC路徑尋找檔案Cocoa.pm幷包含到解析的原始檔拷貝中。use語句是使用類必須的。第四行呼叫new函式建立物件，這是Perl的妙處，也是其易混淆之處，也是其強大之處。建立物件的方法有多種，可以這樣寫：
    $cup = cocoa->new();
    如果你是C程式設計師，可以用雙冒號強制使用Cocoa包中的new()函式，如：
    $cup = Cocoa::new();
    可以在建構函式中加入更多的程式碼，如在Cocoa.pm中，可以在每個物件建立時輸出一個簡單宣告，還可以用建構函式初始化變數或設定陣列或指標。
注意：

1、一定要在建構函式中初始化變數；
2、一定要用my函式在方法中建立變數；
3、一定不要在方法中使用local，除非真的想把變數傳遞給其它子程式；
4、一定不要在類模組中使用全域性變數。

    加上宣告的Cocoa建構函式如下：

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

    也可以簡單地呼叫包內或包外的其它函式來做更多的初始化工作，如：

sub new {
  my $this = {}
  bless $this;
  $this->doInitialization();
  return $this;
}

    建立類時，應該允許它可被繼承，應該可以把類名作為第一個引數來呼叫new函式，那麼new函式就象下面的語句：

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

    此方法使使用者可以下列三種方式之一來進行呼叫：

• Cocoa::new()
• Cocoa->new()
• new Cocoa

    可以多次bless一個引用物件，然而，新的將被bless的類必然把物件已被bless的引用去掉，對C和Pascal程式設計師來說，這就象把一個指標賦給分配的一塊記憶體，再把同一指標賦給另一塊記憶體而不釋放掉前一塊記憶體。總之，一個Perl物件每一時刻只能屬於一個類。
    物件和引用的真正區別是什麼呢？Perl物件被bless以屬於某類，引用則不然，如果引用被bless，它將屬於一個類，也便成了物件。物件知道自己屬於哪個類，引用則不屬於任何類。

例項變數

    作為建構函式的new()函式的引數叫做例項變數。例項變數在建立物件的每個例項時用於初始化，例如可以用new()函式為物件的每個例項起個名字。
    可以用匿名雜湊表或匿名陣列來儲存例項變數。
    用雜湊表的程式碼如下：

sub new {

my $type = shift;
my %parm = @_;
my $this = {};
$this->{'Name'} = $parm{'Name'};
$this->{'x'} = $parm{'x'};
$this->{'y'} = $parm{'y'};
bless $this, $type;

}

    用陣列儲存的程式碼如下：

sub new {

my $type = shift;
my %parm = @_;
my $this = [];
$this->[0] = $parm{'Name'};
$this->[1] = $parm{'x'};
$this->[2] = $parm{'y'};
bless $this, $type;

}

    構造物件時，可以如下傳遞引數：
    $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子程式而已，也即通常所說的成員函式。Perl的方法定義不提供任何特殊語法，但規定方法的第一個引數為物件或其被引用的包。Perl有兩種方法：靜態方法和虛方法。
    靜態方法第一個引數為類名，虛方法第一個引數為物件的引用。方法處理第一個引數的方式決定了它是靜態的還是虛的。靜態方法一般忽略掉第一個引數，因為它們已經知道自己在哪個類了，建構函式即靜態方法。虛方法通常首先把第一個引數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. }

六、方法的輸出
    如果你現在想引用Cocoa.pm包，將會得到編譯錯誤說未找到方法，這是因為Cocoa.pm的方法還沒有輸出。輸出方法需要Exporter模組，在包的開始部分加上下列兩行：
    require Exporter;
    @ISA = qw (Exporter);
    這兩行包含上Exporter.pm模組，並把Exporter類名加入@ISA陣列以供查詢。接下來把你自己的類方法列在@EXPORT陣列中就可以了。例如想輸出方法closeMain和declareMain，語句如下：
    @EXPORT = qw (declareMain , closeMain);
    Perl類的繼承是通過@ISA陣列實現的。@ISA陣列不需要在任何包中定義，然而，一旦它被定義，Perl就把它看作目錄名的特殊陣列。它與@INC陣列類似，@INC是包含檔案的尋找路徑。@ISA陣列含有類(包)名，當一個方法在當前包中未找到時就到@ISA中的包去尋找。@ISA中還含有當前類繼承的基類名。
    類中呼叫的所有方法必須屬於同一個類或@ISA陣列定義的基類。如果一個方法在@ISA陣列中未找到，Perl就到AUTOLOAD()子程式中尋找，這個可選的子程式在當前包中用sub定義。若使用AUTOLOAD子程式，必須用use Autoload;語句呼叫autoload.pm包。AUTOLOAD子程式嘗試從已安裝的Perl庫中裝載呼叫的方法。如果AUTOLOAD也失敗了，Perl再到UNIVERSAL類做最後一次嘗試，如果仍失敗，Perl就生成關於該無法解析函式的錯誤。
七、方法的呼叫
    呼叫一個物件的方法有兩種方法，一是通過該物件的引用（虛方法），一是直接使用類名（靜態方法）。當然該方法必須已被輸出。現在給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;

    現在，我們寫一個簡單的Perl指令碼來使用該類的方法，下面是建立一個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();

    這段指令碼建立了一個叫做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);

    其執行結果如下：

/*
** Created by Cocoa.pm
** Use at own risk
*/
import java.io.InputStream;
import java.net.*;

public class Msg extends java.applet.Applet implements Runnable {
}

    注意：如果用->操作符呼叫方法（也叫間接呼叫），引數必須用括號括起來，如：$cup->setImports( 'java.io.InputStream', 'java.net.*');而雙冒號呼叫如：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");
    可以根據程式的執行情況來選擇使用哪個類的方法，這可以通過使用符號引用去呼叫來實現：
    $method = $local ? "Qava::" : "Espresso::";
    $cup->{$method}grind(@args);
九、解構函式
    Perl跟蹤物件的連結數目，當某物件的最後一個應用釋放到記憶體池時，該物件就自動銷燬。物件的析構發生在程式碼停止後，指令碼將要結束時。對於全域性變數而言，析構發生在最後一行程式碼執行之後。
    如果你想在物件被釋放之前獲取控制權，可以定義DESTROY()方法。DESTROY()在物件將釋放前被呼叫，使你可以做一些清理工作。DESTROY()函式不自動呼叫其它DESTROY()函式，Perl不做內建的析構工作。如果建構函式從基類多次bless，DESTROY()可能需要呼叫其它類的DESTROY()函式。當一個物件被釋放時，其內含的所有物件引用自動釋放、銷燬。
    一般來說，不需要定義DESTROY()函式，如果需要，其形式如下：

sub DESTROY {
#
# Add code here.
#
}

    因為多種目的，Perl使用了簡單的、基於引用的垃圾回收系統。任何物件的引用數目必須大於零，否則該物件的記憶體就被釋放。當程式退出時，Perl的一個徹底的查詢並銷燬函式進行垃圾回收，程式中的一切被簡單地刪除。在UNIX類的系統中，這像是多餘的，但在內嵌式系統或多執行緒環境中這確實很必要。
十、繼承
    類方法通過@ISA陣列繼承，變數的繼承必須明確設定。下例建立兩個類Bean.pm和Coffee.pm，其中Coffee.pm繼承Bean.pm的一些功能。此例演示如何從基類（或稱超類）繼承例項變數，其方法為呼叫基類的建構函式並把自己的例項變數加到新物件中。
    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檔案和所有相關函式，方法setCoffeeType()用於設定局域變數$class->{'Coffee'}的值。在建構函式new()中，$this指向Bean.pm返回的匿名雜湊表的指標，而不是在本地建立一個，下面兩個語句分別為建立不同的雜湊表從而與Bean.pm建構函式建立的雜湊表無關的情況和繼承的情況：
    my $this = {}; #非繼承
    my $this = $theSuperClass->new(); #繼承
    下面程式碼演示如何呼叫繼承的方法：

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

    該程式碼的結果輸出如下：

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

    上述程式碼中，先輸出物件建立時雜湊表中索引為'Bean'和'Coffee'的值，然後呼叫各成員函式改變值後再輸出。
    方法可以有多個引數，現在向Coffee.pm模組增加函式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";
}

    此函式可有三個引數，不同數目、值的引數產生不同的結果，例如：

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');

    其結果輸出如下：

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 ;-)
==================================

    在此例中，函式makeCup()的引數既可為字串也可為整數，處理結果相同，你也可以把這兩種型別的資料處理區分開。在對引數的處理中，可以設定預設的值，也可以根據實際輸入引數值的個數給予不同處理。
十一、子類方法的過載
    繼承的好處在於可以獲得基類輸出的方法的功能，而有時需要對基類的方法過載以獲得更具體或不同的功能。下面在Bean.pm類中加入方法printType()，程式碼如下：

sub printType {
  my $class = shift @_;
  print "The type of Bean is $class->{'Bean'} \n";
}

    然後更新其@EXPORT陣列來輸出：
    @EXPORT = qw ( setBeanType , printType );
    現在來呼叫函式printType()，有三種呼叫方法：

$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

    為什麼都一樣呢？因為在子類中沒有定義函式printType()，所以實際均呼叫了基類中的方法。如果想使子類有其自己的printType()函式，必須在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陣列：
    @EXPORT = qw(setImports, declareMain, closeMain, printType);
    現在輸出結果變成了：

The type of Coffee is Instant
The type of Coffee is Instant
The type of Bean is Mixed

    現在只有當給定了Bean::時才呼叫基類的方法，否則直接呼叫子類的方法。
    那麼如果不知道基類名該如何呼叫基類方法呢？方法是使用偽類保留字SUPER::。在類方法內使用語法如：$this->SUPER::function(...argument list...); ，它將從@ISA列表中尋找。剛才的語句用SUPER::替換Bean::可以寫為$cup->SUPER::printType(); ，其結果輸出相同，為：

The type of Bean is Mixed

十二、Perl類和物件的一些註釋
    OOP的最大好處就是程式碼重用。OOP用資料封裝來隱藏一些複雜的程式碼，Perl的包和模組通過my函式提供資料封裝功能，但是Perl並不保證子類一定不會直接訪問基類的變數，這確實減少了資料封裝的好處，雖然這種動作是可以做到的，但卻是個很壞的程式設計風格。
注意：

1、一定要通過方法來訪問類變數。
2、一定不要從模組外部直接訪問類變數。

    當編寫包時，應該保證方法所需的條件已具備或通過引數傳遞給它。在包內部，應保證對全域性變數的訪問只用通過方法傳遞的引用來訪問。對於方法要使用的靜態或全域性資料，應該在基類中用local()來定義，子類通過呼叫基類來獲取。有時，子類可能需要改變這種資料，這時，基類可能就不知道怎樣去尋找新的資料，因此，這時最好定義對該資料的引用，子類和基類都通過引用來改變該資料。
    最後，你將看到如下方式來使用物件和類：
    use coffee::Bean;
    這句語句的含義是“在@INC陣列所有目錄的Coffee子目錄來尋找Bean.pm”。如果把Bean.pm移到./Coffee目錄，上面的例子將用這一use語句來工作。這樣的好處是有條理地組織類的程式碼。再如，下面的語句：
    use Another::Sub::Menu;
    意味著如下子目錄樹：
    ./Another/Sub/Menu.pm

原文：http://www.phpchina.com/manual/perl/perl5-13.htm