Perl 面向对象

Perl 中有两种不同地面向对象编程的实现：

  • 一是基于匿名哈希表的方式，每个对象实例的实质就是一个指向匿名哈希表的引用。在这个匿名哈希表中，存储来所有的实例属性。

  • 二是基于数组的方式，在定义一个类的时候，我们将为每一个实例属性创建一个数组，而每一个对象实例的实质就是一个指向这些数组中某一行索引的引用。在这些数组中，存储着所有的实例属性。

面向对象基础概念

面向对象有很多基础概念，这里我们接收三个：对象、类和方法。

  • 对象：对象是对类中数据项的引用。.

  • 类：类是个Perl包，其中含提供对象方法的类。

  • 方法：方法是个Perl子程序，类名是其第一个参数。

Perl 提供了 bless() 函数，bless 是用来构造对象的， 通过 bless 把一个引用和这个类名相关联，返回这个引用就构造出一个对象。

类的定义

一个类只是一个简单的包。

可以把一个包当作一个类用，并且把包里的函数当作类的方法来用。

Perl 的包提供了独立的命名空间，所以不同包的方法与变量名不会冲突。

Perl 类的文件后缀为 .pm。

接下来我们创建一个 Person 类：

  1. package Person;

类的代码范围到脚本文件的最后一行，或者到下一个 package 关键字前。

创建和使用对象

创建一个类的实例 (对象) 我们需要定义一个构造函数，大多数程序使用类名作为构造函数，Perl 中可以使用任何名字。

你可以使用多种 Perl 的变量作为 Perl 的对象。大多数情况下我们会使用引用数组或哈希。

接下来我们为 Person 类创建一个构造函数，使用了 Perl 的哈希引用。

在创建对象时，你需要提供一个构造函数，它是一个子程序，返回对象的引用。

实例如下：

  1. package Person;
  2. sub new
  3. {
  4.     my $class = shift;
  5.     my $self = {
  6.         _firstName => shift,
  7.         _lastName  => shift,
  8.         _ssn       => shift,
  9.     };
  10.     # 输出用户信息
  11.     print "名字：$self->{_firstName}\n";
  12.     print "姓氏：$self->{_lastName}\n";
  13.     print "编号：$self->{_ssn}\n";
  14.     bless $self, $class;
  15.     return $self;
  16. }

接下来我们创建一个对象：

  1. $object = new Person( "小明", "王", 23234345);

定义方法

Perl类的方法只但是是个Perl子程序而已，也即通常所说的成员函数。

Perl面向对象中Perl的方法定义不提供任何特别语法，但规定方法的第一个参数为对象或其被引用的包。

Perl 没有提供私有变量，但我们可以通过辅助的方式来管理对象数据。

接下来我们定义一个获取名字的方法：

  1. sub getFirstName {
  2.     return $self->{_firstName};
  3. }

同样也可以这么写：

  1. sub setFirstName {
  2.     my ( $self, $firstName ) = @_;
  3.     $self->{_firstName} = $firstName if defined($firstName);
  4.     return $self->{_firstName};
  5. }

接下来我们修改 Person.pm 文件的代码，如下所示：

  1. #!/usr/bin/perl 
  3. package Person;
  5. sub new
  6. {
  7.     my $class = shift;
  8.     my $self = {
  9.         _firstName => shift,
  10.         _lastName  => shift,
  11.         _ssn       => shift,
  12.     };
  13.     # 输出用户信息
  14.     print "名字：$self->{_firstName}\n";
  15.     print "姓氏：$self->{_lastName}\n";
  16.     print "编号：$self->{_ssn}\n";
  17.     bless $self, $class;
  18.     return $self;
  19. }
  20. sub setFirstName {
  21.     my ( $self, $firstName ) = @_;
  22.     $self->{_firstName} = $firstName if defined($firstName);
  23.     return $self->{_firstName};
  24. }
  26. sub getFirstName {
  27.     my( $self ) = @_;
  28.     return $self->{_firstName};
  29. }
  30. 1;

employee.pl 脚本代码如下：

  1. #!/usr/bin/perl
  3. use Person;
  5. $object = new Person( "小明", "王", 23234345);
  6. # 获取姓名
  7. $firstName = $object->getFirstName();
  9. print "设置前姓名为 : $firstName\n";
  11. # 使用辅助函数设置姓名
  12. $object->setFirstName( "小强" );
  14. # 通过辅助函数获取姓名
  15. $firstName = $object->getFirstName();
  16. print "设置后姓名为 : $firstName\n";

执行以上程序后，输出结果为：

  1. $ perl employee.pl
  2. 名字：小明
  3. 姓氏：王
  4. 编号：23234345
  5. 设置前姓名为 : 小明
  6. 设置后姓名为 : 小强

继承

Perl 里 类方法通过@ISA数组继承，这个数组里面包含其他包（类）的名字，变量的继承必须明确设定。

多继承就是这个@ISA数组包含多个类（包）名字。

通过@ISA只能继承方法，不能继承数据。

接下来我们创建一个 Employee 类继承 Person 类。

Employee.pm 文件代码如下所示：

  1. #!/usr/bin/perl
  3. package Employee;
  4. use Person;
  5. use strict;
  6. our @ISA = qw(Person);    # 从 Person 继承

现在 Employee 类包含了 Person 类的所有方法和属性，我们在 main.pl 文件中输入以下代码，并执行:

  1. #!/usr/bin/perl
  3. use Employee;
  5. $object = new Employee( "小明", "王", 23234345);
  6. # 获取姓名
  7. $firstName = $object->getFirstName();
  9. print "设置前姓名为 : $firstName\n";
  11. # 使用辅助函数设置姓名
  12. $object->setFirstName( "小强" );
  14. # 通过辅助函数获取姓名
  15. $firstName = $object->getFirstName();
  16. print "设置后姓名为 : $firstName\n";

执行以上程序后，输出结果为：

  1. $ perl main.pl
  2. 名字：小明
  3. 姓氏：王
  4. 编号：23234345
  5. 设置前姓名为 : 小明
  6. 设置后姓名为 : 小强

方法重写

上面实例中，Employee 类继承了 Person 类，但如果 Person 类的方法无法满足需求，就需要对其方法进行重写。

接下来我们在 Employee 类中添加一些新方法，并重写了 Person 类的方法：

  1. #!/usr/bin/perl
  3. package Employee;
  4. use Person;
  5. use strict;
  6. our @ISA = qw(Person);    # 从 Person 继承
  8. # 重写构造函数
  9. sub new {
  10.     my ($class) = @_;
  12.     # 调用父类的构造函数
  13.     my $self = $class->SUPER::new( $_[1], $_[2], $_[3] );
  14.     # 添加更多属性
  15.     $self->{_id}   = undef;
  16.     $self->{_title} = undef;
  17.     bless $self, $class;
  18.     return $self;
  19. }
  21. # 重写方法
  22. sub getFirstName {
  23.     my( $self ) = @_;
  24.     # 这是子类函数
  25.     print "这是子类函数\n";
  26.     return $self->{_firstName};
  27. }
  29. # 添加方法
  30. sub setLastName{
  31.     my ( $self, $lastName ) = @_;
  32.     $self->{_lastName} = $lastName if defined($lastName);
  33.     return $self->{_lastName};
  34. }
  36. sub getLastName {
  37.     my( $self ) = @_;
  38.     return $self->{_lastName};
  39. }
  41. 1;

我们在 main.pl 文件中输入以下代码，并执行:

  1. #!/usr/bin/perl
  3. use Employee;
  5. $object = new Employee( "小明", "王", 23234345);
  6. # 获取姓名，使用修改后的构造函数
  7. $firstName = $object->getFirstName();
  9. print "设置前姓名为 : $firstName\n";
  11. # 使用辅助函数设置姓名
  12. $object->setFirstName( "小强" );
  14. # 通过辅助函数获取姓名
  15. $firstName = $object->getFirstName();
  16. print "设置后姓名为 : $firstName\n";

执行以上程序后，输出结果为：

  1. $ perl main.pl
  2. 名字：小明
  3. 姓氏：王
  4. 编号：23234345
  5. 这是子类函数
  6. 设置前姓名为 : 小明
  7. 这是子类函数
  8. 设置后姓名为 : 小强

默认载入

如果在当前类、当前类所有的基类、还有 UNIVERSAL 类中都找不到请求的方法，这时会再次查找名为 AUTOLOAD() 的一个方法。如果找到了 AUTOLOAD，那么就会调用，同时设定全局变量 $AUTOLOAD 的值为缺失的方法的全限定名称。

如果还不行，那么 Perl 就宣告失败并出错。

如果你不想继承基类的 AUTOLOAD，很简单，只需要一句：

  1. sub AUTOLOAD;

析构函数及垃圾回收

当对象的最后一个引用释放时，对象会自动析构。

如果你想在析构的时候做些什么，那么你可以在类中定义一个名为"DESTROY"的方法。它将在适合的时机自动调用，并且按照你的意思执行额外的清理动作。

  1. package MyClass;
  2. ...
  3. sub DESTROY
  4. {
  5.     print "MyClass::DESTROY called\n";
  6. }

Perl 会把对象的引用作为唯一的参数传递给 DESTROY。注意这个引用是只读的，也就是说你不能通过访问$[0] 来修改它。（译者注：参见 perlsub）但是对象自身（比如 "${$[0]"或者 "@{$[0]}" 还有 "%{$[0]}" 等等）还是可写的。

如果你在析构器返回之前重新 bless 了对象引用，那么 Perl 会在析构器返回之后接着调用你重新 bless 的那个对象的 DESTROY 方法。这可以让你有机会调用基类或者你指定的其它类的析构器。需要说明的是，DESTROY 也可以手工调用，但是通常没有必要这么做。

在当前对象释放后，包含在当前对象中的其它对象会自动释放。

Perl 面向对象实例

我们可以通过以下实例来进一步理解Perl面向对象的应用：

  1. #!/usr/bin/perl
  3. # 下面是简单的类实现
  4. package MyClass;
  6. sub new
  7. {
  8.    print "MyClass::new called\n";
  9.    my $type = shift;            # 包名
  10.    my $self = {};               # 引用空哈希
  11.    return bless $self, $type;   
  12. }
  14. sub DESTROY
  15. {
  16.    print "MyClass::DESTROY called\n";
  17. }
  19. sub MyMethod
  20. {
  21.    print "MyClass::MyMethod called!\n";
  22. }
  25. # 继承实现
  26. package MySubClass;
  28. @ISA = qw( MyClass );
  30. sub new
  31. {
  32.    print "MySubClass::new called\n";
  33.    my $type = shift;            # 包名
  34.    my $self = MyClass->new;     # 引用空哈希
  35.    return bless $self, $type;  
  36. }
  38. sub DESTROY
  39. {
  40.    print "MySubClass::DESTROY called\n";
  41. }
  43. sub MyMethod
  44. {
  45.    my $self = shift;
  46.    $self->SUPER::MyMethod();
  47.    print "   MySubClass::MyMethod called!\n";
  48. }
  50. # 调用以上类的主程序
  51. package main;
  53. print "调用 MyClass 方法\n";
  55. $myObject = MyClass->new();
  56. $myObject->MyMethod();
  58. print "调用 MySubClass 方法\n";
  60. $myObject2 = MySubClass->new();
  61. $myObject2->MyMethod();
  63. print "创建一个作用域对象\n";
  64. {
  65.   my $myObject2 = MyClass->new();
  66. }
  67. # 自动调用析构函数
  69. print "创建对象\n";
  70. $myObject3 = MyClass->new();
  71. undef $myObject3;
  73. print "脚本执行结束...\n";
  74. # 自动执行析构函数

执行以上程序，输出结果为：

  1. 调用 MyClass 方法
  2. MyClass::new called
  3. MyClass::MyMethod called!
  4. 调用 MySubClass 方法
  5. MySubClass::new called
  6. MyClass::new called
  7. MyClass::MyMethod called!
  8.    MySubClass::MyMethod called!
  9. 创建一个作用域对象
  10. MyClass::new called
  11. MyClass::DESTROY called
  12. 创建对象
  13. MyClass::new called
  14. MyClass::DESTROY called
  15. 脚本执行结束...
  16. MyClass::DESTROY called
  17. MySubClass::DESTROY called