Perl OOP

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

package.

subroutines, which can be re-used over and over again.

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;

end of the file

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 %snn", $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?

an object constructor.

package.

constructor method new, but in Perl one can use any

name.

in Perl.

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 %snn", $self->firstName, $self->lastName );  }  

associatedwith the package Person.

attributes of our object. We then use the bless function

on the hash 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 %snn", $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