NAME
Object::Simple::Guide - Object::Simple Guide
GUIDE
1. Create attribute method
At first, you create a class inheriting Object::Simple by -base
flag.
package SomeClass;
use Object::Simple -base;
Object::Simple have new
method. This is a constructor. It can receive hash and hash reference as arguments.
my $obj = SomeClass->new;
my $obj = SomeClass->new(foo => 1, bar => 2);
my $obj = SomeClass->new({foo => 1, bar => 2});
You can create attribute method by has
function.
has 'foo';
You can set and get the value by attribute method.
# Set the value
$obj->foo(1);
# Get the value
my $foo = $obj->foo;
You can specify a default value for the attribute method.
__PACKAGE__->attr(foo => 1);
If the value of foo
is not exists and foo
is called, You can get the default value.
my $default_value = $obj->foo;
If you want to specify a reference or object as default value, it must be sub reference, whose return value is the default value. This is requirment not to share the default value with other objects.
has foo => sub { [] };
has foo => sub { {} };
has foo => sub { SomeClass->new };
You can create attribute methods at once.
has [qw/foo bar baz/];
has [qw/foo bar baz/] => 0;
You can create all attribute methods at once.
has [qw/foo bar baz/],
some => 1,
other => sub { 5 };
If arguments count is odd number, first argument is for attribute method not having default value.
Create Class
I show a example to understand Object::Simple well.
Point class, which have two attribute, x
and y
, and clear
method to set x
and y
to 0.
package Point;
use Object::Simple -base;
has x => 0;
has y => 0;
sub clear {
my $self = shift;
$self->x(0);
$self->y(0);
}
You can use Point class in the folowing way.
use Point;
my $point = Point->new(x => 3, y => 5);
print $point->x;
$point->y(9);
$point->clear;
Point3D class, which inherit Point class. This class has z
attribute in addition to x
and y
. clear
method is overridden to clear x
, y
and z
.
package Point3D;
use Point -base;
has z => 0;
sub clear {
my $self = shift;
$self->SUPER::clear;
$self->z(0);
}
You can use Point3D class in the folowing way.
use Point3D;
my $point = Point->new(x => 3, y => 5, z => 8);
print $point->z;
$point->z(9);
$point->clear;
2. Concepts of Object-Oriented programing
Inheritance
I explain the essence of Object-Oriented programing to use Object::Simple well.
First concept of Object-Oriented programing is Inheritance. Inheritance means that If Class Q inherit Class P, Class Q can call all method of class P.
+---+
| P | Base class
+---+ having method1 and method2
|
+---+
| Q | Sub class
+---+ having method3
Class Q inherits Class P, so Q can call all methods of P in addition to methods of Q. In other words, Q can call method1
, method2
, and method3
To inherit a class, use base module.
package P;
sub method1 { ... }
sub method2 { ... }
package Q;
use base 'P';
sub method3 { ... }
Perl has useful functions and methods to help Object-Oriented programing.
To know the object is belong to what class, use ref
function.
my $class = ref $obj;
To know whether the object inherits the specified class, use isa
method.
$obj->isa('SomeClass');
To know whether the object(or class) can call the specified method, use can
method
SomeClass->can('method1');
$obj->can('method1');
Capsulation
Second concept of Object-Oriented programing is capsulation. Capsulation means that you don't touch internal data directory. You must use public methods in documentation. If you keep this rule, All the things become simple.
To keep this rule, Use attribute method to get and set to the value.
my $value = $obj->foo;
$obj->foo(1);
To access the value directory is bad manner.
my $value = $obj->{foo}; # Bad manner!
$obj->{foo} = 1; # Bad manner!
Polymorphism
Third concept Object-Oriented programing is polymorphism. Polymorphism is devieded into two concepts, overloading and overriding.
Perl programer don't have to care overloading. Perl is dynamic language, so subroutine can receive any value. Overloading is worth for languages having static type variable, like C++ or Java.
Overriding means that in sub class you can change the process of the base class's method.
package P;
sub method1 { return 1 }
package Q;
use base 'P';
sub method1 { return 2 }
method1
of class P return 1. method1
of class Q return 2. That is to say, method1
is overridden in class Q.
my $obj_a = P->new;
$obj_p->method1; # Return value is 1
my $obj_b = Q->new;
$obj_q->method1; # Return value is 2
If you want to call the method of base class from sub class, use SUPER pseudo-class.
package Q;
sub method1 {
my $self = shift;
my $value = $self->SUPER::method1; # return value is 1
return 2 + $value;
}
If you understand only these three concepts, you can do enough powerful Object-Oriented programming. and source code is readable for other language users.
3. Offten used techniques
Override new method
new
method is overridden if needed.
Example:
Initialize the object
sub new {
my $self = shift->SUPER::new(@_);
# Initialization
return $self;
}
Example:
Change arguments of new
.
sub new {
my $self = shift;
$self->SUPER::new(x => $_[0], y => $_[1]);
return $self;
}
You can pass array to new
method by overridden new
method.
my $point = Point->new(4, 5);
4. Other features
Strict arguments check
Object::Simple pay attention to the usability. If wrong number arguments is passed to new
method, exception is thrown.
my $obj = SomeClass->new(1); # Exception!
as is the attribute method.
$obj->foo(a => 1); # Execption!
Import methods
You can import methods of Object::Simple. This is useful in case you don't want to use multiple inheritance.
package SomeClass;
use Object::Simple qw/new attr/;
__PACKAGE__->attr('foo');
Note that you can't override new
method because new
method is imported in the class, not inherited from base class.
Method chain
Method chain is available because attribute method return self-object when it is called to set the value,
$obj->foo(1)->bar(4)->baz(6);
Call attr
from object.
You can call attr
from object.
$obj->attr(foo => 1);
Accessor is added to the class the object belong to
Staibility
(2011/2/23 3.0621)
Object::Simple is very stable. I keep Object::Simple backword compatible as possible.
Methods written in documentation will not changed and not removed