Perl OOPs, Modules,Classes,Objects

Perl Tutorial : Perl data types
Perl Tutorial : Perl Operators
Perl Tutorial : Perl loops
Perl Tutorial : Perl Conditionals
Perl Tutorial : Perl Subroutines

Perl Tutorial : Perl regex
Perl Tutorial : Perl Files
Perl Tutorial : Perl & Databases
Perl Tutorial : Perl OOPs
Perl Tutorial : Perl signals
Perl Tutorial : Perl threads
Perl Tutorial : Perl Debugging

Introcution to Perl CGI

Introduction to modperl

Home >> perloops >>

Perl OOP

Why Object Oriented approach?
A major factor in the invention of Object-Oriented approach is to remove some of the flaws encountered with the procedural approach. In OOP, data is treated as a critical element and does not allow it to flow freely. It bounds data closely to the functions that operate on it and protects it from accidental modification from outside functions. OOP allows decomposition of a problem into a number of entities called objects and then builds data and functions around these objects. A major advantage of OOP is code reusability. Some important features of Object Oriented programming are as follows:

Emphasis on data rather than procedure
Programs are divided into Objects
Data is hidden and cannot be accessed by external functions
Objects can communicate with each other through functions
New data and functions can be easily added whenever necessary
Follows bottom-up approach

Concepts of OOP:

Objects

Classes

Data Abstraction and Encapsulation

Inheritance

Polymorphism

Briefly on Concepts:

Objects
Objects are the basic run-time entities in an object-oriented system. Programming problem is analyzed in terms of objects and nature of communication between them. When a program is executed, objects interact with each other by sending messages. Different objects can also interact with each other without knowing the details of their data or code.

Classes
A class is a collection of objects of similar type. Once a class is defined, any number of objects can be created which belong to that class.

Data Abstraction and Encapsulation
Abstraction refers to the act of representing essential features without including the background details or explanations. Classes use the concept of abstraction and are defined as a list of abstract attributes.

Storing data and functions in a single unit (class) is encapsulation. Data cannot be accessible to the outside world and only those functions which are stored in the class can access it.

Inheritance
Inheritance is the process by which objects can acquire the properties of objects of other class. In OOP, inheritance provides reusability, like, adding additional features to an existing class without modifying it. This is achieved by deriving a new class from the existing one. The new class will have combined features of both the classes.

Polymorphism
Polymorphism means the ability to take more than one form. An operation may exhibit different behaviors in different instances. The behavior depends on the data types used in the operation. Polymorphism is extensively used in implementing Inheritance. Advantages of OOP
Object-Oriented Programming has the following advantages over conventional approaches:

OOP provides a clear modular structure for programs which makes it good for defining abstract datatypes where implementation details are hidden and the unit has a clearly defined interface.
OOP makes it easy to maintain and modify existing code as new objects can be created with small differences to existing ones.
OOP provides a good framework for code libraries where supplied software components can be easily adapted and modified by the programmer. This is particularly useful for developing graphical user interfaces.

Perl Package

To create a class in Perl, we first create a package.

A package (module) is a module of variables and subroutines, which can be re-used over and over again.

They provide a separate namespace within a Perl program that keeps subroutines and variables from conflicting with those in other packages.
To declare a class named Person in Perl we do:
package Person;

The scope of the package definition extends to the end of the file

or until another package keyword is encountered.

Perl Methods

A method (subroutine) is a way of accessing objects. In Perl, a method is just a subroutine defined within a particular package. So to define a method to print our Person object, we do:

sub print {
    my ($self) = @_; ## creating reference
    #print Person info
    printf( "Name:%s %s\n\n", $self->firstName, $self->lastName );
}

The subroutine print is now associated with the package Person. To call the method print on a Person object, we use the Perl "arrow" notation. If the variable $mike contains a Person object, we would call print on that object by writing:
$mike->print();

When the object method is invoked, a reference to the object is passed in along with any other arguments (including class name). This is important since the method now has access to the object on which it is to operate.

How do we create object?

To create an instance of a class (an object) we need an object constructor.

This constructor is a method defined within the package.

Most programmers choose to name this object constructor method new, but in Perl one can use any name.

One can use any kind of Perl variable as an object in Perl.

Most Perl programmers choose either references to arrays or hashes.
Let's create our constructor for our Person class using a Perl hash reference;

package Person;
sub new {
    my $self = {
        _firstName => undef,
        _lastName  => undef,
        _ssn       => undef,
        _address   => undef,
        _salary    => undef,
        _dept      => undef
    };
    bless $self, 'Person';
    return $self;
}
sub print {
    my ($self) = @_; ## creating reference
    #print Person info
    printf( "Name:%s %s\n\n", $self->firstName, $self->lastName );
}

We created a subroutine (method) called new associatedwith the package Person.

Other method is print (as discussed earlier).

The entries of the hash reference $self become the attributes of our object. We then use the bless function on the hash reference.

The bless function takes two arguments: a reference to the variable to be marked and a string containing the name of the class. This indicates that the variable now belongs to the class Person.
To create an instance of our Person object:
my $mike = new Person();

We have not defined accessor methods or done any error checking on the input values or keys or the anonymous hash reference, but we have the start of a Perl Person OO framework. To make our constructor more flexible and to make our class inheritable (more on that later), we can define it to use the $class variable to bless the hash reference.

#constructor
sub new {
    my ($class) = @_;
    my $self = {
        _firstName => undef,
        _lastName  => undef,
        _ssn       => undef,
        _address   => undef,
        _salary    => undef,
        _dept      => undef
    };
    bless $self, $class;
    return $self;
}

Other object-oriented languages have the concept of security of data to prevent a programmer from changing an object data directly and so provide accessor methods to modify object data. Perl does not have private variables but we can still use the concept of accessor methods and ask programmers to not mess with our object innards.

For our Person class, we should provides accessor methods for our object attributes; name, address, title, ssn,salary,dept.

package Person;
use strict;
use Address;  #Person class will contain an Address
#constructor
sub new {
    my ($class) = @_;
    my $self = {
        _firstName => undef,
        _lastName  => undef,
        _ssn       => undef,
        _address   => undef
        _salary    => undef,
        _dept      => undef
    };
    bless $self, $class;
    return $self;
}
#accessor method for Person first name
sub firstName {
    my ( $self, $firstName ) = @_;
    $self->{_firstName} = $firstName if defined ($firstName);
    return $self->{_firstName};
}
#accessor method for Person last name
sub lastName {
    my ( $self, $lastName ) = @_;
    $self->{_lastName} = $lastName if defined($lastName);
    return $self->{_lastName};
}
#accessor method for Person address
sub address {
    my ( $self, $address ) = @_;
    $self->{_address} = $address if defined($address);
    return $self->{_address};
}
#accessor method for Person social security number
sub ssn {
    my ( $self, $ssn ) = @_;
    $self->{_ssn} = $ssn if defined($ssn);
    return $self->{_ssn};
}
sub salary {
    my ( $self, $salary ) = @_;
    $self->{_salary} = $salary if defined($salary);
    return $self->{_salary};
}
sub dept {
    my ( $self, $dept ) = @_;
    $self->{_dept} = $dept if defined($dept);
    return $self->{_dept};
}

sub print {
    my ($self) = @_;
    #print Person info
    printf( "Name:%s %s\n\n", $self->firstName, $self->lastName );
}
1;

Making Objects

Object-oriented programming sometimes involves inheritance. Inheritance simply means allowing one class called the Child to inherit methods and attributes from another, called the Parent, so you don't have to write the same code again and again. For example, we can have a class Employee which inherits from Person. This is referred to as an "isa" relationship because an employee is a person. Perl has a special variable, @ISA, to help with this.

@ISA governs (method) inheritance. So to create a new Employee class that will inherit methods and attributes from our Person class, we simply code:

# class Employee
package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

What we have done is load the Person class and declare that Employee class inherits methods from it. We have declared no methods for Employee but an Employee object will behave just like a Person object. We should be able to write code:

#create Employee class instance
my $mike =  new Employee();
 
#set object attributes
$mike->firstName('mike');
$mike->lastName('Weis');

without any other changes. Now let's add some methods.

# class Employee
package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person
#constructor
sub new {
    my ($class) = @_;
    #call the constructor of the parent class, Person.
    my $self = $class->SUPER::new();
    $self->{_id}   = undef;
    $self->{_title} = undef;
    bless $self, $class;
    return $self;
}
#accessor method for  id
sub id {
    my ( $self, $id ) = @_;
    $self->{_id} = $id if defined($id);
    return ( $self->{_id} );
}
#accessor method for  title
sub title {
    my ( $self, $title ) = @_;
    $self->{_title} = $title if defined($title);
    return ( $self->{_title} );
}
sub print {
    my ($self) = @_;
    # we will call the print method of the parent class
    $self->SUPER::print;
    $self->address->print;
}
1;

Looking at the code, you will notice that we have a new method and a print method. Both the child class and its parent class have the same method defined. We have overridden the parent class' methods with the ones from the child. When those methods are called on an Employee object, we will get the Employee class' version of the method. This concept of using the methods of an existing object and modifying them is known as polymorphism.

Putting it together
So now that we have a complete set of classes, we can write a small program to test them.

use strict;
use warnings;
use diagnostics;
use Employee;
#create Employee class instance
my $mike =  eval { new Employee(); }  or die ($@);
 
#set object attributes
$mike->firstName('mike');
$mike->lastName('Weis');
$mike->id(0731034);
$mike->title('Perl Programmer');
$mike->address( new Address() );
$mike->address->street('30 Hudson court');
$mike->address->city('Jersey City');
$mike->address->state('NJ');
$mike->address->zip('665030');
#diplay Employee info
$mike->print();

Let's execute our code and see the output:

$ ./test.pl

Name:mike Weis
Address:30 Hudson court
Jersey City, NJ 665030