首页
登录 | 注册

Perl面向对象(2):对象

本系列:

  • Perl面向对象(1):从代码复用开始
  • Perl面向对象(2):对象
  • Perl面向对象(3):解构——对象销毁

第3篇依赖于第2篇,第2篇依赖于1篇。


已有的代码结构

现在有父类Animal,子类Horse,它们的代码分别如下:

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;

lib/Horse.pm中:

#!/usr/bin/env perl

use strict;
use warnings;

package Horse;
use parent qw(Animal);

sub sound { "neigh" }

1;

一个perl程序speak.pl文件:

#!/usr/bin/env perl

use strict;
use warnings;
use lib "lib";
use Horse;

Horse->speak();

执行上面的speak.pl,将输出:

a Horse goes neigh

上面使用Horse->speak()的方式调用speak()方法,它首先调用到父类Animal中的speak(因为Horse类中没有重写该方法),然后Animal中的speak又重新回调Horse类中的sound()。

这个speak是所有Horse都共享的,如果想要定义每个Horse对象都私有的数据呢?比如为每个Horse对象命名。这里Horse的名字就是Horse类的实例数据(在其它编程语言中常称之为成员变量),是每个对象独有的。

bless创建实例数据:对象

在Perl的面向对象编程中,一个对象表示的就是一个对内置类型的引用,比如标量引用、数组引用、hash引用。也就是说,所谓对象就是一个指向内置数据结构的引用,这个数据结构可以认为是每个对象私有的成员变量。

强烈建议使用hash引用的方式,不过此处先以标量引用的方式开始本文的介绍。

修改speak.pl文件:

#!/usr/bin/env perl

use strict;
use warnings;
use lib "lib";
use Horse;

my $name = "baima";
my $bm_horse = \$name;
bless $bm_horse,'Horse';

bless的语法为:

bless REFERENCE,CLASS;

它表示为CLASS类设置一个唯一标识符,并返回这个唯一标识符,这个唯一标识符是一个数据结构的引用,这个唯一标识符也被称为对象。也就是说,对象就是一个引用,所以我们常常会使用my $obj = bless REF,CLASS;来返回一个对象。另一方面,bless表示将一个数据结构和类进行关联,表示这个数据结构(也许是空的,也许是经过一定初始化的)已经附加在类上,当创建这个类的实例(对象)时,它将返回一个引用,对这个数据结构的引用,换句话说,这个对象就已经拥有了这个数据结构。

如下图所示:

Perl面向对象(2):对象

上面的Class是类,引用变量$obj_ref是这个类的唯一标识符,它指向一个数据结构,这个数据结构是这个类的属性。使用Horse进行具体化,Horse是类,$bm_horse是这个类的唯一标识符,这个引用指向值为"baima"的标量数据结构,所以$bm_horse是一个对象,"baima"就是它独有的属性。

也就是说,bless $bm_horse,'Horse';已经创建了一个名为$bm_horse的对象,而"baimai"这个属性是只属于这一个对象的数据。

调用实例方法

bless生成一个引用后,这个引用是类的实例,可以通过这个引用变量去调用类的方法。

#!/usr/bin/env perl

use strict;
use warnings;
use lib "lib";
use Horse;

my $name = "baima";
my $bm_horse = \$name;
bless $bm_horse,'Horse';

print $bm_horse->sound(),"\n";

上面通过对象去调用类方法,它首先搜索出sound()在何处(即类中还是父类中),然后将参数传递给sound()。传递的参数列表中,第一个参数是实例的名称,也就是$bm_horse,就像通过类名去调用类方法时,传递的第一个参数是类名一样。所以,下面两个是等价的:

$bm_horse->sound();
Horse::sound($bm_horse);

实际上,bless最初的目的就是通过一个引用来关联正确的类,以便perl能正确地找到所调用的方法,免去通过硬编码类名的麻烦。

再调用speak()试试:

$bm_horse->speak();

它将输出:

a Horse=SCALAR(0xc78610) goes neigh!

这是因为$bm_horse是一个指向标量数据结构的引用,speak()方法中将其赋值给$class$class也仍然是引用,而且speak()中并没有去解除这个引用,所以如此输出。至于解决方法,留待后文。

访问实例数据

因为实例的名称是每个对象的唯一标识符,而现在可以通过传递给方法的第一个参数获取实例的名称,借此名称,可以进一步地获取到该实例的其它数据。

现在,在lib/Horse.pm文件中添加一个name方法:

sub name {
    my $self = shift;
    $$self;
}

注意上面$$self,因为$self是对象名,而对象名总是一个引用变量,因此将其解除引用。

然后在speak.pl中调用这个方法:

#!/usr/bin/env perl

use strict;
use warnings;
use lib "lib";
use Horse;

my $name = "baima";
my $bm_horse = \$name;
bless $bm_horse,'Horse';

print $bm_horse->name()," says ",$bm_horse->sound(),"\n";

该print将输出:

baima says neigh

perl中几乎都使用$self作为类名或对象名的代名词,就像java中的"this"一样。实际上,你可以使用任何变量名称,但约定俗成地,大家都喜欢用self。

通过构造器构造对象

前面构造Horse对象是在独立的speak.pl文件中实现的,这样生成Horse对象的方式是手动的,是完全私有的,构造对象时的实例数据(即name属性)也是完全暴露的。当在多个文件中都这样构造Horse对象,迟早会出错。

于是,在类文件lib/Horse.pm中定义一个构造方法new(),每次要构造Horse对象的时候只需调用这个方法即可。

#!/usr/bin/env perl

use strict;
use warnings;

package Horse;
use parent qw(Animal);

sub new {
    my $class = shift;
    my $name = shift;
    belss \$name,$class;
}

sub name {
    my $self = shift;
    $$self;
}

sub sound { "neigh" }

1;

上面在Horse.pm中定义了一个new()方法,该方法里面包含了bless语句,且作为new()方法的最后一个语句,表示构造一个对象并返回这个对象的唯一标识符:引用变量表示的对象名。因此,这个new()方法被称之为构造方法:用于构造该类的实例。

方法名new()可以随意,例如hire(),named()等都可以,但面向对象编程语言中,基本上都使用new这个词语来表示创建新对象,所以,也建议采用约定俗成的new(),如果使用其它方法名作为构造方法,请做好注释。

现在,只要调用Horse中的这个new()方法,就表示在当前包中构建一个Horse的实例(bless的返回值):

my $bm_horse = Horse->new("baima");

注意,bless返回的是对象引用,所以赋值给变量$bm_horse,这时$bm_horse将代表这个对象,是这个对象的唯一标识符。

上面调用new()的过程中,首先找到类方法new(),然后传递参数列表('Horse',"baima"),new()方法中,bless将baima这个数据结构附加到Horse类中,并返回指向该数据结构的引用。以后,通过$bm_horse就能找到这个数据结构,因为这个数据结构是对象$bm_horse的实例数据。

继承构造方法

在上面lib/Horse.pm中的构造方法new()中是否有Horse所特有的个性内容?完全没有。无论是Horse、Cow还是Sheep的构造方法都是通用的,所以将共性的代码抽取到父类Animal中。

lib/Animal.pm中:

#!/usr/bin/env perl

use strict;
use warnings;

package Animal;

sub new {
    my $class = shift;
    my $name = shift;
    bless \$name,$class;
}

sub name {
    my $self = shift;
    $$self;
}

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

sub sound { die 'You have to define sound() in a subclass'; }

1;

lib/Horse.pm中:

#!/usr/bin/env perl

use strict;
use warnings;

package Horse;
use parent qw(Animal);

sub sound { "neigh" }

1;

如此一来,无论是Horse、Cow还是Sheep都继承父类Animal中的构造方法new()以及name()。注意,上面name()方法也抽取到了Animal类中,因为它也是共性的,不过本小节暂时用不到该方法,下一小节会修改该方法。

现在,在speak.pl文件中构建一个Horse对象:

my $bm_horse = Horse->new("baima");

然后通过这个对象调用speak方法:

$bm_horse->speak();

它将输出:

a Horse=SCALAR(0xc78610) goes neigh!

这个实验前文已经验证过了。之所以会如此,是因为传递给speak()的第一个参数是对象的引用变量,而speak()中并没有去解除这个引用。再次看看speak()的代码:

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

speak()中的$class期待的其实是一个类名,而不是对象名,因为类名是具体的字符串,而非引用变量。例如,使用Horse->speak()就不会出现上面的问题。

如何解决父类中的这种问题,使其能同时处理类名和对象名?

让方法能同时处理类和对象

为了让父类中的方法能同时处理类名和对象名,可以加入一个额外的方法对类名和对象名进行判断。如何判断是类名还是对象名?只需使用ref即可,如果ref能返回一个值,表示这是一个引用,说明这是对象,ref返回false,则说明这不是引用,也就是类名。

之前因为name()方法因为共性的原因被抽取到Animal.pm后并没有使用过,这里派上用场了。

lib/Animal.pm中:

#!/usr/bin/env perl

use strict;
use warnings;

package Animal;

sub new {
    my $class = shift;
    my $name = shift;
    bless \$name,$class;
}

sub name {
    my $self = shift;
    ref $self ? $$self : "an unamed Class $self";  # 修改此行
}

sub speak {
    my $class = shift;
    print $class->name()," goes ",$class->sound(),"!\n";  # 调用name()方法
}

sub sound { die 'You have to define sound() in a subclass'; }

1;

这样speak()就变得共性化,既能处理类名,也能处理对象名。

my $bm_horse = Horse->new("baima");
$bm_horse->speak();    # 传递对象名
Horse->speak();        # 传递类名

将输出如下结果:

baima goes neigh!
an unamed Class Horse goes neigh!

之所以加入新的方法,是因为在speak()中类名和对象名是相互独立的,也就是无法共性的,要么是类名,要么是对象名。为了让一段代码共性化,解决方法就是添加额外的代码将非共性内容化解掉,这些额外的代码可以直接加在speak()内部,也可以放进一个新定义的方法中,然后在speak()中调用这个方法。这是一种编程思想。

使用hash数据结构:添加额外的成员变量

经常地,perl使用hash作为对象的数据结果,这个数据结构中可以存储不同的数据、引用,甚至是对象,其中hash的key常作为实例数据(成员变量)。

再次说明,perl面向对象时最常用的对象数据结构是hash,但标量、数组也一样可以,至少很少用。

想要使用hash数据结构,只需将一个hash结构bless到类上即可。它表示这个hash数据结构附加在类上,bless返回一个引用,这个引用就是对象,所以这个对象指向这个数据结构,从而对象拥有这个数据结构。

例如,绑定一个空的hash结构:

bless {},$class;

上面的bless将一个匿名hash附加到类中。

对于父类Animal来说,由于已经有了name的属性,现在如果想要加上一个color属性,就可以将这两个成员属性放进一个hash结构中:

lib/Animal.pm中:

#!/usr/bin/env perl

use strict;
use warnings;

package Animal;

sub new {
    my $class = shift;
    my $name = shift;
    my $self = { 
        Name  => $name,
        Color => $class->default_color(),
    };
    bless $self,$class;
}

sub name {
    my $self = shift;
    ref $self 
        ? $self->{Name}      # 此处需要修改,因为$self不再是标量引用变量,而是hash引用变量
        : "an unamed Class $self";
}

sub default_color {
    die "You have to override default_color method in subclasses";
}

sub speak {
    my $class = shift;
    print $class->name()," goes ",$class->sound(),"!\n";
}

sub sound { die 'You have to define sound() in a subclass'; }

1;

上面将一个包含key:Name和Color的hash数据结构bless到类上,其中Name成员变量通过构造对象时传递参数赋值,Color则调用各类自己的默认颜色方法default_color(),各个子类必须重写该方法。这是显然的,我们可以为某一子类动物设置默认毛色,但不能为所有动物设置同一种默认毛色。

然后修改lib/Horse.pm和lib/Sheep.pm,重写default_color():

lib/Horse.pm中:

#!/usr/bin/env perl

use strict;
use warnings;

package Horse;
use parent qw(Animal);

sub sound { 'neigh' }

sub default_color {
    'black'
}

1;

lib/Sheep.pm中:

#!/usr/bin/env perl

use strict;
use warnings;
package Sheep;
use parent qw(Animal);

sub sound { 'baaaah' }

sub default_color {
    'white'
}

1;

然后,speak.pl中构造Horse对象和Sheep对象,并访问自己的成员属性:

my $bm_horse = Horse->new("baima");
my $by_sheep = Sheep->new("xiaoyang");

print $bm_horse->{Name},"\n";
print $bm_horse->{Color},"\n";
print $by_sheep->{Name},"\n";
print $by_sheep->{Color},"\n";

结果:

baima
black
xiaoyang
white

子类重写构造方法

从父类中继承构造方法时,创建的对象的数据结构是完全一致的。如果某个子类想要多添加一些固定的数据元素,可以让子类重写父类的构造方法。

但需要注意的是,重写方法时,一般都强烈建议只对父类方法进行扩展,而不应该否定父类方法,完全修改父类方法(抽象方法除外)。

例如,现在父类Animal中的构造方法如下:

sub new {
    my $class = shift;
    my $name = shift;
    my $self = { 
        Name  => $name,
        Color => $class->default_color(),
    };
    bless $self,$class;
}

想要为子类Horse添加一种固定的属性,马的类型是战马、比赛用的马还是普通的马。于是,在Horse类中:

package Horse;
use parent qw(Animal);

sub new {
    my $self = shift->SUPER::new(@_);
    $self->{Type} = "Racehorse";
    $self;
}

注意,上面Horse中的构造方法new()中并没有给bless语句。当调用Horse->new()构建对象的时候,首先调用父类的new(),父类的new会关联一个hash结构并返回这个hash结构,这个hash结构又赋值给$self,为此hash结构添加一种元素后,子类的new()返回$self,使得这个hash结构成为子类对象的数据结构。

为了后面的实验,本节所修改的Horse内容请删除。

设置和获取实例数据:setter & getter

上面设置Color的时候只能通过方法default_color()设置默认的毛色,但马有黑马、棕色马、条纹马等等,所以需要能手动设置各种颜色。此外,还要更及时获取到当前最新的成员变量值,比如获取某Horse对象的名称和颜色。这就是俗称的setter和getter方法的作用。

在此示例中,Name属性是直接通过构造方法传值设置的,在逻辑上它唯一标识这个对象(对我们而言,对perl而言是通过对象引用来唯一识别的),所以Name属性不应该允许重新设置。再者,因为设置和获取各对象的属性的代码是共性的,所以直接将这两类方法写到父类Animal中。

lib/Animal.pm中新加的代码片段:

sub set_color {
    my $self = shift;
    $self->{Color} = shift;
}

sub get_color {
    my $self = shift;
    $self->{Color};
}

sub get_name {
    shift->{Name};
}

现在可以为每个Horse或Sheep对象都设置对象自己的颜色,并且能获取颜色和名称:

my $bm_horse = Horse->new("baima");
my $by_sheep = Sheep->new("xiaoyang");

$bm_horse->set_color("white-and-black");
print $bm_horse->get_color(),"\n";
print $by_sheep->get_name(),"\n";

结果如下:

white-and-black
xiaoyang

注意上面get_name()中的一种简写方式:shift->{NAME},shift没有给参数,所以它的操作对象是@_,它等价于(shift @_)->{Name},也等价于:

my $self = shift;
$self->{Name};

关于setter返回值的问题

在为setter方法进行编码的时候,需要考虑它的返回值,一般来说有以下4种返回值类型:

  • (1).set成功后的值
  • (2).set之前的值
  • (3).返回对象自身
  • (4).返回成功/失败布尔值

这4种返回值各有优缺点,但无论如何都请注释好返回值的类型,并且设计好之后就别再修改

第(1)种是最通用、最常见也最简单的行为,传递什么参数给setter,就返回什么参数值,正如set_color()一样:

sub set_color {
    my $self = shift;
    $self->{Color} = shift;
}

一般来说,这种setter方法是放在空上下文(void context)中执行的,但在perl中也可以直接输出它:print set_color("COLOR")

第(2)种要返回设置之前的值,也很简单,只需使用一个临时变量存储一下原始值并返回该变量即可:

sub set_color {
    my $self = shift;
    my $temp = $self->{Color};
    $self->{Color} = shift;
    $temp;
}

这里有一点点小优化。因为是set,所以它可能是在空上下文中执行的,也就是说这时返回之前的值是多余的。可以通过wantarray来判断一下,wantarray函数用于检查执行上下文,如果在列表上下文中则返回true,标量上下文中则返回false,空上下文中则返回undef。

sub set_color {
    my $self = shift;
    if(defined wantarray){
        # 非空上下文,返回值有用
        my $temp = $self->{Color};
        $self->{Color} = shift;
        $temp;
    } else {
        # 空上下文,无需返回值
        $self->{Color} = shift;
    }
}

第(3)种返回对象自身:

sub set_color {
    my $self = shift;
    $self->{Color} = shift;
    $self;
}

一般来说不会用到这种情况。但有时候有奇效,例如可以形成对象链。例如,Person有4个成员变量:Name,Age,Height,Weight,它们的setter方法都返回对象自身,那么可以:

my $people = Person->set_name("abc")->set_age(23)->set_height(168)->set_weigth(60);

# 格式化一下:
my $people = 
    Person->set_name("abc")
          ->set_age(23)
          ->set_height(168)
          ->set_weigth(60);

第(4)种返回布尔值有时候非常有效,特别是对于经常更新出错的情况。如果是前3种返回值方式,会抛出异常,需要判断并使用die进行终止。

别暴露实例数据

在面向对象编程中,常使用一个术语don't look inside box来表示不要暴露对象的成员数据。

通过$obj_ref->{KEY}的方式可以在类的外部访问或设置的数据结构(成员变量),这是违反对象封装原则的,它将每个对象的内部属性都暴露出来了。对象就像是一个黑盒子,$obj_ref->{KEY}就像是将锁链撬开一样。

面向对象的目的之一是让Animal或Horse的维护者可以对它们的方法能独立地做出合理的修改,并且修改后那些已经导出的接口仍然能够正常工作。为什么直接访问hash结构违反了这个原则?当Animal的Color属性不再使用颜色的名称作为它的值时,而是使用RGB三原色的方式来存储颜色呢?

在此示例中,以一个虚构的模块Color::Conversions来修改颜色数据的格式,该模块有两个函数rgb_to_name()和name_to_rgb(),用于转换RGB和颜色的字符串名称,其中name_to_rgb()返回的是一个包含RGB三原色的数组引用。

可以修改set_color()和get_color()方法:

use Color::Conversions qw(rgb_to_name name_to_rgb);

sub set_color {
    my $self = shift;
    my $color_name = shift;
    $self->{Color} = name_to_rgb($color_name);
}

sub get_color {
    my $self = shift;
    rgb_to_name($self->{Color});
}

现在我们可以照旧使用setter和getter,但内部其实已经改变了,这些改变对使用者来说是透明的。此外,我们还可以添加额外的接口,使得我们可以直接设置RGB格式的颜色:

sub set_color_rgb {
    my $self = shift;
    $self->{Color} = [@_];
}

sub get_color_rgb {
    my $self = shift;
    @{ $self->{Color} };
}

如果我们在类的外面直接使用$bm_horse->{Color},将无法直接查看,因为它是一个RGB三原色元素列表的引用,而非直接显示出来的RGB元素值或颜色名称。

这正是面向对象编程所鼓励的行为,对于perl而言,只需将成员变量对应的值设置为一个引用即可。以关联hash数据结构的Animal类为例:

     Animal
       |--------------------------|
       |->  KEY1 => $ref_value1   |
       |->  KEY2 => $ref_value2   |
       |->  KEY2 => $ref_value2   |
       |--------------------------|

为了让数据通过引用的方式隐藏起来,且能通过getter方法查找出来,需要合理设计setter和getter方法。例如,让setter以普通的字符串为参数,但却将其存储到一个引用中,让getter以引用为参数,但却返回人眼可识别的内容。

简化setter和getter的书写

对于面向对象来说,这两个方法写的实在太频繁了。perl一切从简的原则,自然也要将其简化书写:

sub get_color { $_[0]->{Color} }
sub set_color { $_[0]->{Color} = $_[1] }

或者:

sub get_color { shift->{Color} }
sub set_color { pop->{Color} = pop }

合并getter和setter

如果不考虑默认传递的类名或对象名参数,getter方法通常是不含参数的,setter方法通常是包含参数的。通过这个特性,可以将getter和setter合并起来:

sub get_set_color {
    my $self = shift;
    if(@_) {
        # 有参数,说明是setter
        $self->{Color} = shift;
    } else {
        # 没有参数,说明是getter
        $self->{Color};
    }
}

或者简写的:

sub get_set_color { @_ > 1 ? pop->{Color} = pop : shift->{Color} }

使用时:

# 设置颜色
$bm_horse->get_set_color("blue");

# 获取颜色
print $bm_hore->get_set_color(),"\n";

限制方法类别:类方法和实例方法

在perl中所有的方法都是子程序,没有额外的功能来区分一个方法是类方法还是实例方法。对我们来说,如果传递的第一个参数为类名的是类方法,如果传递的第一个参数为对象引用名的方法是实例方法。

好在perl提供了ref函数,可以通过检查引用的方式来检查这是类方法还是实例方法。

use Carp qw(croak);

sub instance_method {
    ref(my $self = shift) or croak "this is a instance method";
    ...CODE...
}

sub class_method {
    ref(my $class = shift) and croak "this is a Class method";
    ...CODE...
}

这里使用croak替换了die,这样报错的时候可以直接告诉错误所在的行数。

私有方法(private method)

私有方法是指类中不应该被外界访问的方法,它可以在类自身其它地方调用,但不应该被对象或其它外界访问以免破坏数据。

例如,类Class1中的方法get_total()内部调用一个私有方法_get_nums(),通过该私有方法返回的数组来获取一个包含数值的数组。如果有一个子类Class2继承了Class1,且重写了_get_nums()使其返回一个数组引用而非数组,这时对象要调用的get_total()整段代码就废了。

package Class1;

sub new {
    my ($class,$args) = @_;
    return bless $args,$class;
}

sub get_total {
    my $self =  shift;
    my @nums = $self->_pri_sub;   # 期待该私有方法返回一个列表
    my $total = 0;
    foreach (@nums) {
        $total += $_;
    }
    return $total;
}

sub _pri_sub {
    my $self = shift;
    ...some codes...
    return @nums;      # 返回一个数组
}

1;

一般来说,这样的问题并不常发生,因为程序毕竟是程序员写的,遵循规范的情况下,大家都知道这是什么意思。但如果程序比较庞大,也许无意中就重写了一个私有方法。面向对象,一个最基本的规则就是保护数据不被泄漏、不被破坏。

但perl中所有的方法都是public(公共的),谁都能访问,并没有提供让方法私有化的功能。只是以一种呼吁式的规范,让大家约定俗成地使用下划线"_"作为方法名的前缀来表示这是一个私有方法(例如sub _name {})。但这只是一种无声的声明"这是私有方法,外界请别访问",perl并不限制我们从外界去访问下划线开头的方法。

要实现方法的真正私有化,可以将匿名子程序赋值给一个变量来实现,或者通过闭包的方式实现

sub get_total {
    my $self =  shift;
    my @nums = $self->$_pri_sub(ARGS);
    my $total = 0;
    foreach (@nums) {
        $total += $_;
    }
    return $total;
}

my $_pri_sub = sub {
    my $self = shift;
    ...some codes...
    return @nums;
}

需要注意的是,上面$self->$_pri_sub()中箭头的右边是一个变量,在其它面向对象语言中是无法将变量作为方法名的,但perl支持。

因为$_pri_sub是词法变量,构造的对象无法取得这样的数据。但通过一些高级技术,对象还是能够取得这个方法,要想完全私有化,通过闭包实现:

sub get_total {
    my $self =  shift;
    my $_pri_sub = sub {
        my $self = shift;
        ...some codes...
        return @nums;
    }
    my @nums = $self->$_pri_sub(ARGS);
    my $total = 0;
    foreach (@nums) {
        $total += $_;
    }
    return $total;
}

祖先类:UNIVERSAL

UNIVERSAL是一切类的祖先,所有的类都继承于它。它提供了3个方法:isa()、cat()和VERSION(),在v5.10.1和之后,还提供了另一个方法DOES()。

1.isa()用于判断某个给定的对象(或类)与某个类是否满足is a的关系,也就是"对象是否是某个类的实例,类1是否是类2的子类"

$object_or_class->isa(CLASS);

2.can()用于判断某个给定的对象(或类)是否能够使用某方法

$object_or_class->can($method_name);

需注意,can()方法检测结果为真的时候,其返回值是该方法的引用。也就是说,可以直接将can()赋值给一个方法的引用变量,避免多次书写。以下是等价的写法:

if(my $method = $obj->can($method_name)){
    $obj->$method;
}

if($obj->can($method_name)){
    $obj->$methdo_name;
}

3.VERSION()用于返回对象(或类)的版本号

设置了our $VERSION=...;之后,既可以通过继承自UNIVERSAL的VERSION()方法获取版本号,也可以通过对象获取VERSION变量值:

$obj->VERSION();
$obj->VERSION;

多重继承

Perl支持多重继承。假设Class3多重继承Class1和Class2:

package Class3;

# 1.
use base qw(Class1 Class2);
# 2.
use parent qw(Class1 Class2);
# 3.
use Class1;
use Class2;
our @ISA = qw(Class1 Class2);

但无论是哪种语言,都强烈建议不要使用多重继承。

假设Class1和Class2都直接继承自UNIVERSAL类,现在Class3多重继承Class1和Class2。

       UNIVERSAL
        |    |
    Class1  Class2
        |    |
        Class3

假设Class2有方法eat(),Class1没有,且Class3没有写eat(),那么Class3的实例调用eat()方法的时候,会调用到Class2的eat()吗?

默认情况下,Perl搜索方法的规则是从左搜索,深度优先。意味着use base qw(Class1 Class2)时,当Class3自身找不到eat()时,将先搜索左边的Class1,搜索完没发现eat(),将搜索Class1的父类UNIVERSAL。也就是说永远也不会去搜索Class2。

实际上,搜索父类时是搜索@ISA中的元素,所以是从左开始搜索。

但是可以使用CPAN上的C3或者mro模块,它们实现从左搜索,广度优先的搜索规则。也就是说,对于use base qw(Class1 Class2),当Class3自身找不到eat()时,将先找左边的Class1的eat(),找不到再找右边的Class2的eat(),还找不到的话最后找父类的eat()。


相关文章

  • More Effective C++
    More Effective C++ 35个改善编程与设计的有效方法 只有深入了解C++编译器如何解释代码, 才有可能用C++语言写出健壮的软件. C++的难学, 不仅在其广博的语法, 语法背后的语义, 语义背后的深层思维, 深层思维背后的 ...
  • ES 集群上,业务单点如何优化升级?
    摘要: 原创出处 https://www.bysocket.com 「公众号:泥瓦匠BYSocket 」欢迎关注和转载,保留摘要,谢谢! ES 基础 ES 集群 ES 集群上业务优化 一.ES 基础 ES 的安装下载,网上一大片,我这边不在 ...
  • 一. 前言 这里记录了我Blog的所有目录结构,有的项是随笔分类项,有的是具体文章,先把目录写好,以后不断往里面装内容,以后方便整理查阅.当然,主页导航栏可以快速索引到下面的具体项目内容.但是,目前有很多板块还没具体内容更新,待后续接触到相 ...
  • 《k8s 源码分析》- Custom Controller 之 Informer
    Custom Controller 之 Informer 概述 架构概览 reflector - List & Watch API Server Reflector 对象 ListAndWatch watchHandler - ad ...
  • 学了很多乱七杂八的东西,但是依然停留在前端,在工作中一直和后端交流,但是不太了解数据库是怎么回事,为了加强学习,准备学习一些关于数据库相关的东西. 说起数据库可能会有很多很多,SQLServer.Oracle.Sybase等等等,还有就是要 ...
  • 目录 引入 简单工厂 抽象工厂 Spring的bean工厂 模拟Spring工厂实现 模拟IOC 引入 假设有一个司机, 需要到某个城市, 于是我们给他一辆汽车 public class Demo { public static void ...

2019 cecdns.com webmaster#cecdns.com
12 q. 0.080 s.
京ICP备10005923号