Perl教学第十三篇Perl的面向对象编程-Perl-idc中文资讯站-客观公证的IDC产业权威媒体,关注域名、虚拟主机、服务器、网络、开源技术资讯，整合运营商资源，客观评价各地机房带宽线路质量、IDC企业名录等信息

Perl教学第十三篇Perl的面向对象编程

来源：linux宝库作者：linux宝库发布时间:2007-09-30 00:00:00

　　本章介绍怎样使用Perl的面向对象编程(OOP)特性及怎样构建对象，还包括继承、方法重载和数据封装等内容。

　　一、模块简介

　　模块(module)就是Perl包(pachage)。Perl中的对象基于对包中数据项的引用。（引用见第x章引用）。

　　详见http://www.nease.net/tppmsgs/msgs0.htm#28的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

喜欢本文，那就收藏到：

上一篇: Perl教学第十二篇Perl5中的引用(指针)

下一篇: Perl教学第十四篇Perl5的包和模块

相关推荐

相关资讯