Board logo

标题: [转载教程] Perl5 OOP学习笔记 [打印本页]
作者: find    时间: 2012-1-6 15:41     标题: Perl5 OOP学习笔记

在Perl排名持续下降的情况下学Perl，似乎是有点不明智。但是，工作需要，不得不学啊。再说，Perl现在在测试领域还是用得非常多的。Phython虽然也在测试领域开始活跃起来，不过我始终还是不太喜欢Phython的语法。

在学习了Perl的基本语法之后，学习Perl的OOP，略有心得。不知道Perl各个版本之间OOP是否有区别，但是我是学习的Perl5，所以在标题上将版本号也写出来了。因为了解到PHP4和PHP5的OOP部分就有不小的差别，所以有此担心。
　　学习Perl的OOP，最关键的两件事情就是package和bless。只要把这两个东西搞清楚也就学会大一半了。
Perl的package
　　感觉Perl的package和Java还真有点相似。Java的package是以CLASSPATH中的目录为根，按目录定义和搜索分级包名。Perl也类似，是以@INC数组中的目录为根，按目录搜索分级包名。不过有一点不同，Perl的package定义貌似不需要与目录结构对应。具体是什么样的规则我没有去研究，因为按目录结构定义package是个好习惯。
　　相较于Java，Perl的package还有一点很有意思。Java的每层package对应一个目录，而最后是一个class文件对应到类名。Perl却简化了，package直接就把目录和文件名都引用了进去。比如
　　Java中，name.jamesfancy.MyClass，对应的是/name/jamesfancy/MyClass.class，源代码中则分成两句来写
  1. package name.jamesfancy;

  2. class MyClass {....}

  3. package name.jamesfancy;

  4. class MyClass {....}
复制代码
Perl中，name::jamesfancy::MyClass，应对的是/name/jamesfancy/MyClass.pm，源代码中只有一句package就说明了
  1. package name::jamesfancy::MyClass;

  2. package name::jamesfancy::MyClass;
复制代码
至于package中的内容，也就是变量和子程序，至于区别，稍后再说。
bless函数
　　bless是用来把一个类绑定到引用类型变量的函数。很奇怪Perl为什么要用这个单词，不过没关系，我们可以把它想像得形象一点：就像游戏里牧师通过祝福技能为某人加上BUFF一样，bless把一个类绑定到某个引用类型的变量，从此这个变量就受到了祝福，拥有了这个类中的变量和子程序。
　　bless的用法通常是：bless($引用变量, 类名);
　　引用变量貌似可以是任何引用类型的变量，我尝试过Scalar，Array和Hash的引用，都能成功。在bless之外，这个引用变量就可以被称之为对象了，当然它仍然是个引用，是对象的引用。
　　有一点还需要注意，虽然这个对象拥有了类的变量和子程序，但我们应该把它拥有的类的变量和子程序都看成是静态的，换句话说，就是类的成员。在这一点上，子程序的处理会比较特殊一点，但至少类的变量，也就是包变量，是不属于对象的。因此，所有对象的数据都保存在对象引用的原始数据中。既然大家都习惯对象数据以键值对的方式保存，所以通常情况下，bless的引用变量，都是Hash的引用了。
　　很抽象么？举个例子。如果对OOP的成员函数还不够了解，那就只看下面示例中每个类的test函数中第一句以后的内容不好。
  1. # test.pl

  2. package TestScalar;

  3. sub test {

  4. my $this = shift();

  5. print("\nIn TestScalar::test()\n");

  6. print("Scalar:\n ${$this}\n");

  7. }

  8. 

  9. package TestArray;

  10. sub test {

  11. my $this = shift();

  12. print("\nIn TestArray::test()\n");

  13. print("Array:\n");

  14. foreach my $item (@{$this}) {

  15. print(" $item\n");

  16. }

  17. }

  18. 

  19. package TestHash;

  20. sub test {

  21. my $this = shift();

  22. print("\nIn TestHash::test()\n");

  23. print("Hash:\n");

  24. while (my ($key, $value) = each %{$this}) {

  25. printf(" %-4s = %s\n", $key, $value);

  26. }

  27. }

  28. 

  29. package main;

  30. 

  31. my $name = "James Fancy";

  32. my $objScalar = \$name;

  33. my $objArray = ['James', 'Fancy', 'Jenny'];

  34. my $objHash = {'name' => 'James', 'age' => 30};

  35. 

  36. bless($objScalar, 'TestScalar');

  37. bless($objArray, 'TestArray');

  38. bless($objHash, 'TestHash');

  39. 

  40. $objScalar->test();

  41. $objArray->test();

  42. $objHash->test();

  43. 

  44. __END__

  45. 

  46. In TestScalar::test()

  47. Scalar:

  48. James Fancy

  49. 

  50. In TestArray::test()

  51. Array:

  52. James

  53. Fancy

  54. Jenny

  55. 

  56. In TestHash::test()

  57. Hash:

  58. name = James

  59. age = 30
复制代码
从上面的示例中可以看到，分别将3种类型的引用转变为对象。之所以要把类写成3个而非1个，主要是为了在Test里输出不同类型的数据。
类和对象的成员函数

　　成员函数就是在package中定义的子程序。成员函数是没有静态和非静态之分的，但我宁愿大家都把它看作是静态函数，因为虽然它即可以当作类成员函数来调用，也可以当用对象成员函数来调用，但在当作对象成员函数来调用的时候，Perl偷偷的传入了对象引用。这也解释了为什么通常成员函数里的第一句话往往是
  1. my $this = shift();
复制代码
当然，这里的$this只是一个局部变量，而不是关键字，你也可以用别的名称来代替它。比如很多人就喜欢用$self，或者$me等。
假如，对于一个成员函数，分别用类和对象来对它进行调用，会有什么不一样呢？再看一个示例：
  1. # test.pl

  2. package MyClass;

  3. 

  4. sub test {

  5. my ($this, @args) = @_;

  6. print('-' x 40, "\n");

  7. print("\$this is [$this], Ref of \$this is [", ref($this), "]\n");

  8. print("Args: [@args]\n");

  9. }

  10. 

  11. package main;

  12. 

  13. $obj = {};

  14. bless($obj, 'MyClass');

  15. 

  16. MyClass->test("MyClass->test(...)");

  17. $obj->test("\$obj->test(...)");

  18. 

  19. __END__

  20. ----------------------------------------

  21. $this is [MyClass], Ref of $this is []

  22. Args: [MyClass->test(...)]

  23. ----------------------------------------

  24. $this is [MyClass=HASH(0x178a44)], Ref of $this is [MyClass]

  25. Args: [$obj->test(...)]
复制代码
从结果可以看出来，不管哪种方法调用，第一个参数都是Perl偷偷传递进去的。如果是类调用，则第一个参数是该类。如果是对象调用，第一个参数是该对象。因此，只需要将ref($this)的结果和类名进行比较就清楚是哪种调用了。所以，一个容错性较好的成员函数，一开始要判断传入的第一个参数，比如
  1. sub foo {

  2. my $this = shift();

  3. return unless ($this ne 'MyClass');

  4. # 其它语句

  5. }
复制代码
这里还有一个疑问：既然package中定义的子程序都是成员函数，那不是类的package和是类的package有啥区别？它们在结构上没有一点区别，唯一的区别在处理中。在调用子程序的时候，Perl不会硬塞一个类或者对象在参数列表的最前面，但调用成员函数的时候会，所以区别是根据你的调用方式来区分的。

　　调用对象成员还好说，$obj->foo()就好，但是调用类成员的时候，怎么知道是调用的类成员还是包中的子程序呢？那就要看是通过“->”还是“::”来调用的了。下面的例子可以帮助理解：
  1. # test.pl

  2. package MyClass;

  3. use Data::Dumper;

  4. sub test {

  5. print('-' x 40, "\n");

  6. print(Dumper(@_));

  7. }

  8. 

  9. package main;

  10. 

  11. MyClass->test("MyClass->test(...)");

  12. MyClass::test("MyClass::test(...)");

  13. 

  14. __END__

  15. ----------------------------------------

  16. $VAR1 = 'MyClass';

  17. $VAR2 = 'MyClass->test(...)';

  18. ----------------------------------------

  19. $VAR1 = 'MyClass::test(...)';
复制代码
很明显，通过“::”调用的子程序没有被Perl塞入一个引用类的参数。

构造函数
　　Perl的OOP没有指定专门的构造函数，所以你可以把任何一个子程序当作构造函数，当然，重要的是其中的内容。既然脚本通常不是写给自己一个人看的，所以还是按照大家的习惯，把构造函数取名为new吧。按照多数OOP语言的习惯，new函数通常返回一个对象或其引用、指针。所以在Perl中，这个new函数要返回一个对象引用，理所当然地，把bless动作包含在new函数中是个好习惯。那么一个简单的new函数看起来就像这样：
  1. sub new {

  2. my $this = {};

  3. bless($this);

  4. }
复制代码
这个new函数中产生了一个Hash引用，bless它，并返回它。如果你疑惑为什么这里没有看到return语句，那么建议你去看看关于子程序中返回值的资料，顺便查一下bless函数的说明。来看看完整的程序了解一下是怎么使用new函数的。
  1. # test.pl

  2. package MyClass;

  3. 

  4. sub new {

  5. my $this = {};

  6. bless($this);

  7. }

  8. 

  9. package main;

  10. 

  11. my $obj1 = MyClass::new();

  12. my $obj2 = MyClass->new();

  13. my $obj3 = new MyClass();

  14. 

  15. print(join("\n", ref($obj1), ref($obj2), ref($obj3)));

  16. 

  17. __END__

  18. MyClass

  19. MyClass

  20. MyClass
复制代码
注意上面new MyClass()的效果和MyClass->new()效果是一样的。这里new不是关键字，而是函数名。同理，如果有一个foo成员函数的话，也可以foo MyClass(args)，它实际上是MyClass::foo(MyClass, args);

　　话说回来，如果需要初始化对象数据又该如何呢？前面说过，对象数据保存在引用的数据自身，所以我们通常是把一个Hash引用bless成对象。所以我们经常会看到这样调用new：
  1. my $obj = MyClass->new('key1' => 'value1', 'key2' => 'value2');
复制代码
或者
  1. my $obj = MyClass->new({'key1' => 'value1', 'key2' => 'value2'});
复制代码
两种调用方式的区别在于new函数中的处理不同，因为前者传入的是一个Hash实体，而后者传入的是一个Hash引用。为了兼容这两种情况，new函数通常会像下面程序中的写法：
  1. # test.pl

  2. package MyClass;

  3. 

  4. sub new {

  5. my $class = shift();

  6. my $this = ref(@_[0]) ? @_[0] : {@_};

  7. bless($this);

  8. }

  9. 

  10. package main;

  11. use Data::Dumper;

  12. 

  13. my $obj1 = MyClass->new('name' => 'James Fancy', 'age' => 30);

  14. my $obj2 = MyClass->new({'name' => 'James Fancy', 'age' => 30});

  15. 

  16. print(Dumper($obj1));

  17. print(Dumper($obj2));

  18. 

  19. __END__

  20. $VAR1 = bless( {

  21. 'name' => 'James Fancy',

  22. 'age' => 30

  23. }, 'MyClass' );

  24. $VAR1 = bless( {

  25. 'name' => 'James Fancy',

  26. 'age' => 30

  27. }, 'MyClass' );
复制代码
访问对象数据
　　既然通常是Hash引用被bless成对象，那就只说这种情况。
　　既然是Hash引用，所以访问数据最简单的办法就跟访问Hash引用一样。比如
  1. $obj->{'name'} = "You Name";

  2. my $name = $obj->{'name'};

  3. $obj->{'name'} = "You Name";

  4. my $name = $obj->{'name'};
复制代码
如果想少写点花括号，可以通过定义setter/getter的办法来解决。因为getter和setter可以根据有没参数来区分，所以合并在一个函数中成为可能，比如下面的name函数
  1. # test.pl

  2. package MyClass;

  3. sub new {

  4. my $class = shift();

  5. my $this = ref(@_[0]) ? @_[0] : {@_};

  6. bless($this);

  7. }

  8. sub name {

  9. my $this = shift();

  10. if (@_[0]) {

  11. $this->{'name'} = @_[0];

  12. }

  13. return $this->{'name'};

  14. }

  15. package main;

  16. my $obj = MyClass->new('name' => 'James Fancy');

  17. print($obj->name, "\n");

  18. print($obj->name("New Name"), "\n");

  19. __END__

  20. James Fancy

  21. New Name

  22. # test.pl

  23. package MyClass;

  24. sub new {

  25. my $class = shift();

  26. my $this = ref(@_[0]) ? @_[0] : {@_};

  27. bless($this);

  28. }

  29. sub name {

  30. my $this = shift();

  31. if (@_[0]) {

  32. $this->{'name'} = @_[0];

  33. }

  34. return $this->{'name'};

  35. }

  36. package main;

  37. my $obj = MyClass->new('name' => 'James Fancy');

  38. print($obj->name, "\n");

  39. print($obj->name("New Name"), "\n");

  40. __END__

  41. James Fancy

  42. New Name
复制代码
使用setter/getter的确可以使程序看起来简洁不少。但是对对象中的每个数据写一个getter/setter，还是很累人的，于是，AUTOLOAD函数就被抬出来了，看看下面的程序
  1. package MyClass;

  2. 

  3. sub new {

  4. my $class = shift();

  5. my $this = ref(@_[0]) ? @_[0] : {@_};

  6. bless($this, $class);

  7. }

  8. 

  9. sub AUTOLOAD {

  10. my $this = $_[0];

  11. if (!ref($this)) {

  12. return;

  13. }

  14. 

  15. my $name = $AUTOLOAD;

  16. 

  17. if (defined($name)) {

  18. $name =~ s/.*:://;

  19. } else {

  20. return;

  21. }

  22. 

  23. my $class = ref($this);

  24. if (defined($this->{$name}) || @_) {

  25. no strict 'refs';

  26. *{"${class}::$name"} = sub {

  27. my $this = shift();

  28. $this->{$name} = shift() if (@_);

  29. 

  30. # make a property in hash reference type to HashObject object.

  31. if (ref($this->{$name}) eq 'HASH') {

  32. bless($this->{$name}, $class);

  33. }

  34. 

  35. return $this->{$name};

  36. };

  37. 

  38. goto &$name;

  39. }

  40. }

  41. 

  42. package main;

  43. 

  44. my $obj = MyClass->new('name' => 'James Fancy');

  45. $obj->more1({'key', 'value of more1->key'});

  46. print($obj->name, "\n");

  47. print($obj->more1->key, "\n");

  48. print($obj->more2({})->key("value of more2->key"), "\n");

  49. 

  50. __END__

  51. James Fancy

  52. value of more1->key

  53. value of more2->key
复制代码
这样调用起来是不是方便多了？不过AUTOLOAD写起来很累人的。如果你只需要一个数据对象，网上有个Hash::AsObject的类很好用，用法和上面的最后一个示例差不多。
继承
　　我的确是对继承这个方面没怎么研究。不过简单的继承大概就是用use base语句引入基类而已，比如
  1. package Parent;

  2. 

  3. sub test1 {

  4. print("Parnet::test1\n");

  5. }

  6. 

  7. sub test {

  8. print("Parent::test\n");

  9. }

  10. 

  11. package Sub;

  12. use base Parent;

  13. 

  14. sub test {

  15. print("Sub::test\n");

  16. }

  17. 

  18. sub test2 {

  19. $_[0]->Parent::test();

  20. }

  21. 

  22. package main;

  23. 

  24. my $obj = bless({}, *Sub);

  25. $obj->test();

  26. $obj->test1();

  27. $obj->test2();

  28. 

  29. __END__

  30. Sub::test

  31. Parnet::test1

  32. Parent::test
复制代码




欢迎光临 批处理之家 (http://bbs.bathome.net/) Powered by Discuz! 7.2