In Perl circles, modules and object-oriented programming are often spoken of in the same breath, but the connection is misleading. The implementation of modules in Perl is object-oriented, but that doesn’t mean that the actual modules are objectified. Perl modules don’t necessarily involve objects just because the Perl programmer has encapsulated their code in a module.
Generally, an object is an instance of a class. So in Perl
terms, the object is created by calling a constructor, and will be
used to create a new object and a reference to it. (Often, the
constructor is named new
,
but Create
is also
used in Win32 classes.) This reference is a regular scalar variable,
except that it refers to an underlying object that knows which class
it belongs to. In your programs, you will use the reference to
manipulate the object.
Methods are subroutines that expect an object reference as a first argument, such as:
sub in_class { my $class = shift; # object reference my ($this, $that) = @_; # params }
Methods may be invoked like this:
PackageName->constructor(args
)->method_name(args
);
or:
$object = PackageName->constructor(args
); $object->method_name(args
);
Objects have a specific set of available methods within their class, but they also inherit methods from their parent class, if they have one.
Objects are destroyed when the last reference to them
goes away. You can control this capture before the object is destroyed
with the DESTROY
method. The
DESTROY
method should be defined
somewhere in the class. You do not call DESTROY
explicitly; it will be called at an
appropriate time. Object references contained in the current object
will be freed when the current object is freed. Most of the time, you
won’t need to explicitly destroy an object, but there are occasions
when you should, such as when you are done with a socket
object.
3.145.33.235