第七章 对象（一）-Moose

每一个大型的程序都会有几个层面上的设计考量。在微观上 ，得着眼于所要解决问题的具体细节；在宏观上，还要设法让代码具有良好的组织结构。要做到这些就必须要依靠抽象和封装。

单独的函数在解决大型问题时还显得有不足（抽象和封装得还不够）。
也有技术可以实现将行为相似的函数组织成一个单元，如之前介绍过的高阶函数。还有一个流行的技术就是面向对象，或者叫面向对象编程。

Moose

Perl默认的面向对象系统非常灵巧，但是语法有点丑，它展示了面向对象系统的内部运行机理。你当然可以使用它来实现大型的工程，但是你得自己写代码来实现一些基础功能，而这些基础功能在其他编程语言中是内置就有的。

Moose是一个完整的面向对象系统，功能齐全而且易于使用。它不是Perl核心模块的一部分，所以需要从CPAN上下载、安装才能使用，但是值得一试！

类

Moose系统中，对象就是类的实例。类就是一个模板，一个描述了对象数据和对象行为的模板。一个类通常属于一个包。

package Cat
{
use Moose;
}

这样一个Cat类（Moose系统的类）就创建好了，非常简单。然后再创建一个Cat类的对象（实例）：

my $brad = Cat->new;
my $jack = Cat->new;

这里使用箭头来调用Cat中的方法。

方法

方法就是类里面的函数。函数归属于命名空间，相似的，方法就归属于一个类。

当你在Cat类上调用new()方法时，Cat就是调用者。下面例子中，new()方法会返回一个Cat类的实例对象：

my $choco = Cat->new;
#调用Cat类的new方法
$choco->sleep_on_keyboard;
#调用$choco的sleep_on_keyboard方法

方法的第一个参数是它的调用者。

package Cat
{
use Moose;
sub meow
{
my $self = shift;
print $self ;
}
}

Cat->meow ;

注意：****实例方法只能读写自己实例里的数据。不能使用类方法读写实例的数据，类方法是全局可见的。****

构造函数，就是一个用来创建实例的类方法。当你声明一个（Moose）类时，Moose提供了一个默认的构造函数new()。

属性

每一个对象都是唯一的。对象可以有自己的私有数据，通常会把这样的数据叫做属性。在类中定义属性：

package Cat
{
use Moose;
has 'name', is => 'ro', isa => 'Str';
}

Moose提供了has()方法用来声明一个属性。第一个参数name 是属性的名字；is => 'ro'声明这个属性是只读的，所以设置之后你不能更改这个属性值； isa => 'Str'表示这个属性的类型必须是字符串。

这个例子中，Moose还会帮你创建一个访问器--name()方法，用来读取这个属性值。

for my $name (qw( Tuxie Petunia Daisy ))
{
my $cat = Cat->new( name => $name );
say "Created a cat for ", $cat->name;
}

Moose文档上说用括号来分隔名字和特性：

has 'name' => ( is => 'ro', isa => 'Str' );

下面这个效果也是一样的：

has( 'name', 'is', 'ro', 'isa', 'Str' );

对于复杂的声明，下面的方式更好：

has 'name' => (
is => 'ro',
isa => 'Str',
# advanced Moose options; perldoc Moose
init_arg => undef,
lazy_build => 1,
);

对于简单声明，本书更倾向使用简单方式（不使用括号）。

属性类型并不是必须的，不指定的话可以是任何类型：

package Cat
{
use Moose;
has 'name', is => 'ro', isa => 'Str';
has 'age', is => 'ro';
}

my $invalid = Cat->new( name => 'bizarre',
age => 'purple' );

当然如果你指定了类型，Moose就会按你的意思去做类型验证。

如果你将属性设置为可读、可写时(is => 'rw')，Moose还会创建一个设置器，使用设置器可以改变这个属性值。

package Cat
{
use Moose;
has 'name', is => 'ro', isa => 'Str';
has 'age', is => 'ro', isa => 'Int';
has 'diet', is => 'rw';
}

my $fat = Cat->new( name => 'Fatty', age => 8,diet => 'Sea Treats' );

say $fat->name, ' eats ', $fat->diet;

$fat->diet( 'Low Sodium Kitty Lo Mein' );
say $fat->name, ' now eats ', $fat->diet;

如果属性仅为可读时，上面的例子会抛出异常：Cannot assign a value to a read-only accessor at...

对象内部的数据显示了对象的价值。类可以从宏观上描述数据和行为。但是不同的对象（类实例）具体表现不一样，因为它们的数据不一样。

封装

通过合理的设计屏蔽内部细节，提供对外的一致性，这就是封装的意义。

考虑一个问题：如何管理猫（Cat）的年龄，你是想在构造时直接传递一个参数作为年龄值，还是传递猫的生日来计算出年龄呢？

package Cat
{
use Moose;
has 'name', is => 'ro', isa => 'Str';
has 'diet', is => 'rw';
has 'birth_year', is => 'ro', isa => 'Int';
sub age
{
my $self = shift;
my $year = (localtime)[5] + 1900;
return $year - $self->birth_year;
}
}

很明显如果直接传递参数作为年龄的话，那么每年年龄都会变化；而根据生日来计算年龄就好的多，任何时候只需要调用age()就能得到年龄，至于内部发生了什么使用者无需注意。

还可以做个体验上的小小提升：在忘记传参的时候给予一个默认值。

package Cat
{
use Moose;
has 'name', is => 'ro', isa => 'Str';
has 'diet', is => 'rw', isa => 'Str';
has 'birth_year', is => 'ro', isa => 'Int', default => sub { (localtime)[5] + 1900 };
}

对属性使用了关键字default，这样就会在创建新对象（实例）时该属性的值就是后面的值。因为现在后面是个函数引用，那么构造时就会执行引用函数以返回值作为属性值。相对字符串和数字来说，使用函数引用的优势在于可以返回任何东西。
还可以通过传参设置属性值：

my $kitten = Cat->new( name => 'Hugo' );

多态

一个设计的很好的面向对象程序可以处理很多类型的数据。假设有个方法是用来显示对象内部信息的：

sub show_vital_stats
{
my $object = shift;
say 'My name is ', $object->name;
say 'I am ', $object->age;
say 'I eat ', $object->diet;
}

很明显，如果你传递进去的是一只猫（Cat），这个方法能正常工作；你传递的是一个人，它也能正常工作。任何具有name(), age(), and diet()方法的对象，它都能应付过来，这种特性我们称之为多态，意思就是一种接口适用于不同对象。

角色

角色就是行为和状态的集合，通俗点就是用来描述干啥的。前面我们介绍过类，类是对象的行为和状态的模板，你可以实例化一个类，但是不能实例化一个角色。角色是针对类这个层次的，它描述的是类特性。

比如，动物（类）和奶酪（类）都会有年龄属性（age），但是我们认为动物的角色是生物，而奶酪的角色是食品，它们的角色不一样。

package LivingBeing
{
use Moose::Role;
requires qw( name age diet );
}

Moose::Role提供的关键字requires 允许你列出该角色的需要具有的方法。换句话说要充当LivingBeing这个角色就必须具有name(), age(), and diet()方法。Cat类非常符合这个角色：

package Cat
{
use Moose;

has 'name', is => 'ro', isa => 'Str';
has 'diet', is => 'rw', isa => 'Str';
has 'birth_year',
is => 'ro',
isa => 'Int',
default => sub { (localtime)[5] + 1900 };

with 'LivingBeing';

sub age { ... }
}

with 这一行就是将LivingBeing角色添加到Cat这个类中。（with这一行必须要在属性声明的后面，这样才能标识自动生成的属性访问方法。）

现在所有的Cat实例都符合角色LivingBeing了，我们用DOES()方法来测试：

my $fluffy=Cat->new();
say 'Alive!' if $fluffy->DOES('LivingBeing');

#符合就返回真，否则返回假

为什么要设计出角色这个东西呢？是这样的，假设现在有10个类，但是10个类都具有一些共同的特征，将这些共同的特征提取出来供重复使用，这就是角色存在的意义。

结合上面的例子，我们可以把其中年龄那部分抽取出来：

package CalculateAge::From::BirthYear
{
use Moose::Role;

has 'birth_year',
is => 'ro',
isa => 'Int',
default => sub { (localtime)[5] + 1900 };

sub age
{
my $self = shift;
my $year = (localtime)[5] + 1900;
return $year - $self->birth_year;
}

}

这样，角色从Cat类中分离出来后，就能被其他的类使用了。现在Cat由2个角色组成：

package Cat
{
use Moose;
has 'name', is => 'ro', isa => 'Str';
has 'diet', is => 'rw';
with 'LivingBeing', 'CalculateAge::From::BirthYear';
}

注意到是CalculateAge::From::BirthYear中的age()方法满足了LivingBeing角色的要求。

角色和DOES()方法

要测试是否集成（符合）了一个角色，就是调用类或实例的的DOES()方法：

say 'This Cat is alive!'
if $kitten->DOES( 'LivingBeing' );

继承

Perl的面向对象系统支持继承特性。继承就是在2个类之间建立一种类似父子的关系。子类的行为和父类相同：它们具有相同数量、相同类型的属性，还有相同的方法。当然也可以手动修改让子类具有额外的数据和行为。从某种意义上来讲，父类可以认为是角色，子类继承了父类，相当于集成了某种角色。

LightSource类提供了2个属性（enabled和candle_power）和2个方法（light和extinguish）：

package LightSource {
use Moose;

has 'candle_power', is => 'ro',
isa => 'Int',
default => 1;

has 'enabled', is => 'ro',
isa => 'Bool',
default => 0,
writer => '_set_enabled';

sub light {
my $self = shift;
$self->_set_enabled( 1 );
}

sub extinguish {
my $self = shift;
$self->_set_enabled( 0 );
}
}

注意到enabled的writer选项创建了一个私有访问器来设置该值。

角色还是继承？
角色在构成时更安全，有更好的类型验证，代码更容易解耦，容易通过名字和行为做精细化的控制；继承则对于有其他语言编程经验的人来说更熟悉。
当一个类真的需要以另一个类为基础来扩展时使用继承；当一个类仅需要一些额外的行为时使用角色，特别是这些行为还有个有意义的名字时。

****继承和属性****
一个LightSource的子类可能是能点亮100次的、工业级强度的超级蜡烛：

package SuperCandle
{
use Moose;

extends 'LightSource';

has '+candle_power', default => 100;
}

关键字extends 用来表示要继承父类（不限是单个，可以是多个类）。如果只有这一行内容的话，那么SuperCandle对象就会和LightSource对象一样了--具有2个属性（candle_power 和 enabled）还有2个方法（ light和extinguish）。

在属性名字前面使用加号，表示在当前的类中会对这个属性做一些特别的事情，在这里是重写了默认值。所以任何SuperCandle对象的candle_power属性值默认就是100（能点亮100次呢）。

当你在SuperCandle对象上调用light()或extinguish()方法时，Perl会在SuperCandle 类里面去找对应的方法。如果在子类中没有找到对应的方法，Perl就会去父类（父类的父类，依次类推）中找。在这个例子中，会在LightSource类中找到对应的方法。

属性的继承也类似。

****方法调度顺序****
Perl使用深度优先的策略来进行方法的调度，对于单个父类的情况，就像上面说的一样，先在子类里面找，然后再父类里面找。对于多个父类的情，先在子类里面找，然后再第一个父类里面找，依次类推，直到找到对应的方法。
详见perldoc mro.

****继承和方法****
和属性类似，子类还可以重写方法。我们想象一类无法熄灭的蜡烛：

package Glowstick
{
use Moose;

extends 'LightSource';

sub extinguish {}
}

这样写的话，在Glowstick上调用extinguish()就不会做任何事，即使父类中这个方法有做什么，因为根据方法的调度顺序，先在子类中找到对应方法。我们可以更加明确地来表明意图：

package LightSource::Cranky
{
use Carp 'carp';
use Moose;

extends 'LightSource';

override light => sub
{
my $self = shift;

carp "Can't light a lit light source!" if $self->enabled;

super();
};

override extinguish => sub
{
my $self = shift;

carp "Can't extinguish unlit light source!" unless $self->enabled;

super();
};
}

super()指明去最近的父类调度当前的方法。现在我们的子类会在操作不当时产生一个警告。

欲了解更加细节的信息参见perldoc Moose::Manual::MethodModifiers。

****继承和isa()****
类（或对象）是否是或扩展自某个类使用isa()方法，若是真的返回真值，否则返回假值：

say 'Looks like a LightSource' if $sconce->isa( 'LightSource' );
say 'Hominidae do not glow' unless $chimpy->isa( 'LightSource' );

Moose与默认的Perl面向对象系统

Moose比默认的面向对象系统提供了更多、更高级的特性，虽然这些特性你都可以自己来写。Moose是一个完整的面向对象系统，很多重要的工程都使用了该系统。StrawberryPerl和ActivePerl都已经内置了Moose，事实表明Moose非常成功。

Moose还支持元编程--通过Moose自身来操作你的对象。如果你想知道一个类或对象有哪些属性和方法，可以这样做：

my $metaclass = Monkey::Pants->meta;

say 'Monkey::Pants instances have the attributes:';
say $_->name for $metaclass->get_all_attributes;
say 'Monkey::Pants instances support the methods:';
say $_->fully_qualified_name for $metaclass->get_all_methods;

你甚至可以查看哪些类继承了指定的类：

my $metaclass = Monkey->meta;

say 'Monkey is the superclass of:';
say $_ for $metaclass->subclasses;

想要更详细的了解Moose元编程的信息，参见perldoc Class::MOP。

Moose和它的MOP（meta-object protocol元对象协议）提供了更优雅的语法来使用类和对象：

use MooseX::Declare;

role LivingBeing { requires qw( name age diet ) }
role CalculateAge::From::BirthYear { 
has 'birth_year',
is => 'ro',
isa => 'Int',
default => sub { (localtime)[5] + 1900 };

method age
{
return (localtime)[5] + 1900 - $self->birth_year;
}
}

class Cat with LivingBeing with CalculateAge::From::BirthYear
{
has 'name', is => 'ro', isa => 'Str';
has 'diet', is => 'rw';
}

MooseX::Declare模块增加了class，role，和method关键字，这些关键字可以使代码更加简洁。

还有一个选择就是Moops模块，它的风格是这样的：

use Moops;

role LivingBeing {
requires qw( name age diet );
}

role CalculateAge::From::BirthYear :ro {
has 'birth_year',
isa => Int,
default => sub { (localtime)[5] + 1900 };

method age {
return (localtime)[5] + 1900 - $self->birth_year;
}
}

class Cat with LivingBeing with CalculateAge::From::BirthYear :ro {
has 'name', isa => Str;
has 'diet', is => 'rw';
}

Moose非常强大也非常大，还有个小型版的Moose叫Moo，它更快，资源占用更低。