Perl面向对象(1)：从代码复用开始

官方手册：http://perldoc.perl.org/perlobj.html

本系列：

* Perl面向对象(1)：从代码复用开始 <https://www.cnblogs.com/f-ck-need-u/p/9798757.html>

* Perl面向对象(2)：对象 <https://www.cnblogs.com/f-ck-need-u/p/9811119.html>

* Perl面向对象(3)：解构——对象销毁 <https://www.cnblogs.com/f-ck-need-u/p/9818016.html>
第3篇依赖于第2篇，第2篇依赖于1篇。

Perl面向对象的三个准则

* 类就是包

* 对象就是一个数据结构的引用，是知道自己属于哪个类的引用
* 可以是数据结构引用(如hash结构、数组结构)，也可以是子程序引用

* 方法就是子程序
最初代码

3种动物牛Cow、羊Sheep、马Horse发出的声音各不相同。在lib目录下创建三个各自的文件，分别定义它们的叫声子程序：

lib/Cow.pm中：
#!/usr/bin/env perl use strict; use warnings; package Cow; sub speak { print
"a Cow goes moooo!\n"; } 1;
lib/Sheep.pm中：
#!/usr/bin/env perl use strict; use warnings; package Sheep; sub speak { print
"a Sheep goes baaaah!\n"; } 1;
lib/Horse.pm中：
#!/usr/bin/env perl use strict; use warnings; package Horse; sub speak { print
"a Horse goes neigh!\n"; } 1;
然后定义一个文件speak.pl，使用这3个模块，分别调用这3个子程序：
#!/usr/bin/env perl use strict; use warnings; use lib "lib"; use Cow; use
Sheep; use Horse; Cow::speak(); Sheep::speak(); Horse::speak();
使用箭头的调用方法

上面使用包名的完全限定方式调用子程序(或访问其它属性)，这其实是有一定限制的，比如无法直接使用包名作为变量：
foreach my $who (qw(Cow Horse Sheep)){ $who::speak(); # 这是错的 eval
"$who"."::speak()"; # 这是正确的 }
上面通过eval的二次解析功能，先将变量$who替换，然后再调用对应的方法。

但这种写法无比丑陋。可以使用另外一种访问其它包中的子程序(或其它属性)：瘦箭头。
foreach my $who (qw(Cow Horse Sheep)){ $who->speak(); }

其实这是面向对象的调用方式。通过这种方式调用其它包的子程序，传递给子程序的第一个参数将总是对象名或类名。在Perl中，类就是包，所以，下面几个调用方式是等价的：
瘦箭头调用方式 完全限定包名调用方式 ---------------------------------------------------
Cow->speak(args) == Cow::speak('Cow',args) Sheep->speak(args) ==
Sheep::speak('Sheep',args) Horse->speak(args) == Horse::speak('Horse',args)
因此，当使用瘦箭头调用子程序的方式时，如果这个子程序需要处理参数，必须要考虑隐含的第一个参数。所以，修改lib/{Cow,Sheep,Horse}.pm
中的speak()子程序：

lib/Cow.pm中：
#!/usr/bin/env perl use strict; use warnings; package Cow; sub speak { my
$class = shift; # 将第一个参数保存起来 print "a $class goes moooo!\n"; # 插入第一个参数的变量 } 1;
lib/Sheep.pm中：
#!/usr/bin/env perl use strict; use warnings; package Sheep; sub speak { my
$class = shift; # 将第一个参数保存起来 print "a $class goes baaaah!\n"; # 插入第一个参数的变量 } 1;
lib/Horse.pm中：
#!/usr/bin/env perl use strict; use warnings; package Horse; sub speak { my
$class = shift; # 将第一个参数保存起来 print "a $class goes neigh!\n"; # 插入第一个参数的变量 } 1;
这样一来，将硬编码的Cow、Sheep和Horse使用共同的$class进行替换，增加了speak()的可移植性和共性，从而为面向对象的代码复用带来便捷性。

初步理解类和对象

所谓的类，就像是一个模板；所谓对象，就像是通过模板生成的具体的事物。类一般具有比较大的共性，对象一般是具体的，带有自己的特性。


类与对象的关系，例如人类和人，鸟类和麻雀，交通工具和自行车。其中人类、鸟类、交通工具类都是一种类型称呼，它们中的任何一种都具有像模板一样的共性。例如人类的共性是能说话、有感情、双脚走路、能思考等等，而根据这个人类模板生成一个人，这个具体的人是人类的实例，是一个人类对象，每一个具体的人都有自己的说话方式、感情模式、性格、走路方式、思考能力等等。


类与类的关系。有的类的范畴太大，模板太抽象，它们可以稍微细化一点，例如人类可以划分为男性人类和女性人类，交通工具类可以划分为烧油的、电动的、脚踏的。一个大类按照不同的种类划分，可以得到不同标准的小类。无论如何划分，小类总是根据大类的模板生成的，具有大类的共性，又具有自己的个性。

在面向对象中，小类和大类之间的关系称之为继承，小类称之为子类，大类称之为父类。


类具有属性，属性一般包括两类：像名词一样的属性，像动词一样的行为。例如，人类有父母(parent)，parent就是名词，人类能吃饭(eat)，eat这种行为就是动词。鸟类能飞(fly)，fly的行为就是动词，鸟类有翅膀(wing)，wing就是名词。对于面向对象来说，名词就是变量，动词行为就是方法(也就是子程序)。


当子类继承了父类之后，父类有的属性，子类可以直接拥有。因为子类一般具有自己的个性，所以子类可以定义自己的属性，甚至修改从父类那里继承来的属性。例如，人类中定义的eat属性是一种非常抽象的、共性非常强的动词行为，如果女性人类继承人类，那么女性人类的eat()可以直接使用人类中的eat，也可以定义自己的eat(比如淑女地吃)覆盖从人类那里继承来的eat(没有形容词的吃)，女性人类还可以定义人类中没有定义的跳舞(dance)行为，这是女性人类的特性。子类方法覆盖父类方法，称之为方法的重写(override)，子类定义父类中没有的方法，称为方法的扩展(extend)。

无论是对象与类还是子类与父类，它们的关系都可以用一种"is a"来描述，例如"自行车 is a 交通工具"(对象与类的关系)、"笔记本 is a
计算机"(子类与父类的关系)。

辅助子程序让代码更具共性

为了构造更通用的speak，将它们的不同点抽取出来：动物名称、叫声。

动物名称这里和类名(包名)相同，前面已经替换成了共同的$class
，动物的叫声是随动物种类不同而不同的，无法直接实现它们的共性。但可以定义一个辅助性的同名子程序sound()，用来返回各种动物的叫声：

lib/Cow.pm中：
#!/usr/bin/env perl use strict; use warnings; package Cow; sub sound {
"moooo"; } sub speak { my $class = shift; print "a $class goes
",$class->sound(),"!\n"; } 1;
lib/Sheep.pm中：
#!/usr/bin/env perl use strict; use warnings; package Sheep; sub sound {
"baaaah"; } sub speak { my $class = shift; print "a $class goes
",$class->sound(),"!\n"; } 1;
lib/Horse.pm中：
#!/usr/bin/env perl use strict; use warnings; package Horse; sub sound {
"neigh"; } sub speak { my $class = shift; print "a $class goes
",$class->sound(),"!\n"; } 1;
如此一来，lib/{Cow,Horse,Sheep}.pm中的所有speak()子程序都完全相同。

继承

显然，将这3个类中的共同部分抽取出来放进一个通用的模块中进行复用更好。

例如，放进lib/Animal.pm模块文件中：
#!/usr/bin/env perl use strict; use warnings; package Animal; sub speak { my
$class = shift; print "a $class goes ",$class->sound(),"!\n"; } sub sound { die
'You have to define sound() in a subclass'; } 1;

为了让Cow、Horse、Sheep直接使用Animal中的speak()子程序，需要让Cow、Horse、Sheep去继承Animal。其中Animal类称为父类(base
class/super class/parent class)，Cow、Horse、Sheep称为子类(subclass/child
class)。类在继承的同时会继承父类中的方法。在面向对象中，方法就是子程序。所以，子类Cow、Horse、Sheep可以直接使用父类Animal中的speak()方法。

于是修改lib/{Cow,Sheep,Horse}.pm文件。

lib/Cow.pm中：
#!/usr/bin/env perl use strict; use warnings; package Cow; use Animal; #
先装载Animal our @ISA=qw(Animal); # 继承Animal sub sound {"moooo"} 1;
lib/Horse.pm中：
#!/usr/bin/env perl use strict; use warnings; package Horse; use Animal; our
@ISA=qw(Animal); sub sound { "neigh" } 1;
lib/Sheep.pm中：
#!/usr/bin/env perl use strict; use warnings; package Sheep; use Animal; our
@ISA=qw(Animal); sub sound { "baaaah" } 1;
上面的三个模块文件中，完全没有定义speak()，只是使用our @ISA=qw(Animal);
的方式声明了各自的类继承Animal类。但在speak.pl中可以直接调用speak()方法：
#!/usr/bin/env perl use strict; use warnings; use lib "lib"; use Cow; use
Sheep; use Horse; foreach my $who (qw(Cow Horse Sheep)){ $who->speak(); }

上面父类Animal中，还定义了一个sound()，这是可选的，因为各个子类都定义了属于自己的sound()。但强烈建议在Animal中也定义好，因为在当前Animal类中的speak()方法中调用了该方法，且Animal所有子类都重写了sound()，它代表了一种共性。


换个角度，一般是从父类开始写程序的，sound()作为具有共性的方法，应该要先定义在父类中。那么子类中的sound()是重写父类sound()而来，所以父类的sound()可以非常抽象，甚至不提供任何功能，
仅仅充当一个占位符。


在此实例中，Animal中的sound()也确实没有提供任何和叫声有关的功能，仅仅只是做了一层检测，当调用到了父类的sound()时，将报错。这表示子类没有定义属于自己的sound()，也就是没有重写父类的sound()。对于这种
抽象的方法，每个子类都应该去重写，定义属于自己的特性。

关于@ISA

继承的方式有3种：

1.使用base模块：use base qw(Animal);
2.使用parent模块：use parent qw(Animal);
3.使用@ISA数组：
use Animal; our @ISA = qw(Animal);
它们之间并没有多大区别，但需要注意的是，@ISA只是声明继承的一种方式，算是比较古老的写法，parent模块是在perl
v5.10.1才引入的功能，大概是2000年左右，因此如果是此版本之前的perl，需要使用base模块，或者安装parent模块。

base和parent模块的本质还是@ISA。@ISA表示的是is a的关系，这是典型的对象与类、子类与父类的关系解释。

当调用一个方法时，如果在自己的类中找不到，将从@ISA
数组中定义的父类中寻找，能找到则直接调用，不能找到则报错。例如上面三个子类都没有定义speak()，当在speak.pl文件中调用这3个模块中的speak()时，perl将首先搜索各类(或包)中的speak，因为找不到，所以找父类Animal的speak()，能找到，所以成功调用。

重写父类方法


子类要实现自己独有的特性，除了定义父类中没有的属性之外，还可以重写从父类继承的方法。例如Cow、Horse、Sheep中的sound()就重写了父类Animal的sound()。


虽然理论上父类中的speak()可以重写，但很可能是没有必要重写甚至不应该重写的，因为重写可能会带来破坏，使得能使用父类的地方不能使用子类(参考"里氏替换原则")。

另外，强烈建议尽量扩展父类的行为，而不是修改父类的行为。

例如，新添加一个老鼠子类，它的speak()除了叫一声外，还多叫一声。lib/Mouse.pm文件内容如下：
#!/usr/bin/env perl use strict; use warnings; package Mouse; use Animal; our
@ISA =qw(Animal); sub sound { "jiji" } sub speak { my $class = shift; print "a
$class goes ", $class->sound(), "!\n"; print "jiji\n"; } 1;
现在，在speak.pl中调用Mouse的speak()。
use Mouse; Mouse->speak();

上面执行并没有问题。但问题出现了，如果Animal中的goes单词修改成了says，那么Mouse中的goes也得改成says。这种方式并不合理，所以，必须得保证子类的speak()和父类的speak()能保持以执行，而不能在子类种对任何共性的部分进行硬编码。

所以，将Mouse的speak()的第一个print，改为调用Animal中的speak()。
#!/usr/bin/env perl use strict; use warnings; package Mouse; use Animal; our
@ISA =qw(Animal); sub sound { "jiji" } sub speak { my $class = shift;
Animal::speak($class); print "jiji\n"; } 1;
上面通过完全限定的包名进行speak()的调用，注意传递了一个参数$class给speak()，因为父类Animal中的speak()要求一个参数。

但是问题又再次出现，假如Animal继承自Dot::Animal
，而Animal自身没有speak()，上面的写法就会出错。稍微好一点的写法是使用面向对象的调用方式：
sub speak { my $class = shift; $class->Animal::speak(); print "jiji\n"; }
虽然看上去很丑，但确实是可以正常工作的，它明确指定从Animal类中搜索。但Animal::是被硬编码到代码中的，像硬编码的行为能避免则避免。

访问父类方法(SUPER)

将上面的代码再改一改：
sub speak { my $class = shift; $class->SUPER::speak(); print "jiji\n"; }
这样就解决了硬编码的问题。SUPER::表示从@ISA父类列表中搜索。

• « 上一篇：linux安装svn，配置用户、用户组权限
• » 下一篇：Go基础系列：读取标准输入