ch14.htm

this is a book on pearl , simple example with explanation is given here. it could be beneficial for

Get the name of the class from the parameter array.<BR>

Assign the rest of the parameters to the </I><TT><I>%params</I></TT><I>

hash.<BR>

Assign a refereNCe to one of the entries in the </I><TT><I>%Colors</I></TT><I>

hash to </I><TT><I>$self</I></TT><I>.

This will be used as the object refereNCe.<BR>

Bless the hash entry into the </I><TT><I>Color</I></TT><I>

class and return </I><TT><I>$self</I></TT><I>

as the object refereNCe.<BR>

Start the </I><TT><I>main</I></TT><I>

namespace.<BR>

Print a message on </I><TT><I>STDOUT</I></TT><I>.

<BR>

Call the constructor for the </I><TT><I>Pen</I></TT><I>

class. Assign the object refereNCe to </I><TT><I>$item</I></TT><I>.

<BR>

Use </I><TT><I>%properties</I></TT><I>

as a temporary value to simplify the derefereNCing process.<BR>

Print the three property values to verify that the property initialization

worked.</I>

</BLOCKQUOTE>

<HR>

<BLOCKQUOTE>

<B>Listing 14.5&nbsp;&nbsp;14LST05.PL-How One Class Can Use or

Contain Another Class<BR>

</B>

</BLOCKQUOTE>

<BLOCKQUOTE>

<PRE>

package Inventory_item;

    sub new {

        my($class)  = shift;

        my(%params) = @_;

        bless {

            &quot;PART_NUM&quot;    =&gt; $params{&quot;PART_NUM&quot;},

            &quot;QTY_ON_HAND&quot; =&gt; $params{&quot;QTY_ON_HAND&quot;}

        }, $class;

}



package Pen;

    @ISA = (Inventory_item);



    sub new {

        my($class) = shift;

        my(%params) = @_;

        my($self) = Inventory_item-&gt;new(@_);



        $self-&gt;{&quot;INK_COLOR&quot;} = Color-&gt;new($params{&quot;INK_COLOR&quot;});



        return(bless($self, $class));

    }



package Color;

    print(&quot;Executing Color statements\n&quot;);

    $colors{&quot;blue&quot;}  = &quot;Die Lot 13&quot;;

    $colors{&quot;red&quot;}   = &quot;Die Lot 5&quot;;



    sub new {

        my($class) = shift;

        my($param) = @_;

        my($self) = \$colors{$param};



        return(bless($self, $class));

    }





package main;

    print(&quot;Executing main statements\n&quot;);



    $pen = Pen-&gt;new(

        &quot;PART_NUM&quot;    =&gt; &quot;12A-34&quot;,

        &quot;QTY_ON_HAND&quot; =&gt; 34,

        &quot;INK_COLOR&quot;   =&gt; &quot;blue&quot;);



    %properties = %{$pen};

    print(&quot;The part number is &quot; . $properties{'PART_NUM'}     . &quot;\n&quot;);

    print(&quot;The quantity is &quot;    . $properties{'QTY_ON_HAND'}  . &quot;\n&quot;);

    print(&quot;The ink color is &quot;   . ${$properties{'INK_COLOR'}} . &quot;\n&quot;);

</PRE>

</BLOCKQUOTE>

<HR>

<P>

This program displays

<BLOCKQUOTE>

<PRE>

Executing Color statements

Executing main statements

The part number is 12A-34

The quantity is 34

The ink color is Die Lot 13

</PRE>

</BLOCKQUOTE>

<P>

Where to start? You already know about the <TT>Inventory_item</TT>

class and the <TT>@ISA</TT> array.

Let's look at the assignment to the <TT>INK_COLOR</TT>

entry of the <TT>Pen</TT> class. This

line, <TT>$self-&gt;{&quot;INK_COLOR&quot;}

= Color-&gt;new($params{&quot;INK_COLOR&quot;});</TT>,

is used to call the constructor for the <TT>Color</TT>

class. The expression <TT>$params{&quot;INK_COLOR&quot;}</TT>

passes the value of <TT>&quot;blue&quot;</TT>

to the <TT>Color</TT> constructor,

which returns a refereNCe to one of the colors in the <TT>%colors</TT>

associative array.

<P>

You can tell that Perl executes all statements that are not inside

fuNCtions because the <TT>print</TT>

statement in the <TT>Color</TT> package

is executed before the <TT>print</TT>

statement in the <TT>main</TT> package.

This is why you can define hash entries inside the <TT>Color</TT>

class. When variables are defined inside a package but outside

a fuNCtion, they are called <I>static</I> variables. You can access

one of the hash entries in the <TT>Color</TT>

package like this: <TT>$Color::colors{&quot;blue&quot;}</TT>.

<H2><A NAME="StaticVersusRegularMethodsandVariables"><FONT SIZE=5 COLOR=#FF0000>

Static Versus Regular Methods and Variables</FONT></A></H2>

<P>

You already learned that a static method is one that can be called

without needing an instantiated object. Actually, you can also

have static variables as you saw in the last section. Static variables

can be used to emulate <I>constants</I>, values that don't change.

Constants are very useful. For example, you can use them for tax

rates, mathematical constants, and things such as state abbreviations.

Here is an example using a small Perl script:

<BLOCKQUOTE>

<PRE>

package Math;

    $math{'PI'} = 3.1415;



package main;

    print(&quot;The value of PI is $Math::math{'PI'}.\n&quot;);

</PRE>

</BLOCKQUOTE>

<P>

This program displays

<BLOCKQUOTE>

<PRE>

The value of PI is 3.1415.

</PRE>

</BLOCKQUOTE>

<P>

You can also do this:

<BLOCKQUOTE>

<PRE>

package Math;

    $PI = 3.1415;

package main;

    print(&quot;The value of PI is $Math::PI.\n&quot;);

</PRE>

</BLOCKQUOTE>

<P>

Because you have been using a static method all along-the <TT>new()</TT>

method-I'll take this opportunity to demonstrate a regular fuNCtion.

Listing 14.6 shows how to use the <TT>UNIVERSAL</TT>

package to define a utility fuNCtion that is available to all

classes. 

<P>

<IMG SRC="pseudo.gif" BORDER=1 ALIGN=RIGHT><p>

<BLOCKQUOTE>

<I>Start a definition of the </I><TT><I>UNIVERSAL</I></TT><I>

class.<BR>

Define the </I><TT><I>lookup()</I></TT><I>

method.<BR>

DerefereNCe the object refereNCe (the first element of </I><TT><I>@_</I></TT><I>)

and use the second parameter as the key into the anonymous hash.

Return the value of the hash entry.<BR>

Start a definition of the </I><TT><I>Inventory_item</I></TT><I>

class.<BR>

Define the constructor for the class.<BR>

Assign the rest of the parameters to the </I><TT><I>%params</I></TT><I>

hash.<BR>

Bless the anonymous hash with the class name.<BR>

Use </I><TT><I>%params</I></TT><I>

to initialize the class properties.<BR>

Start the </I><TT><I>main</I></TT><I>

namespace.<BR>

Call the constructor for the </I><TT><I>Inventory_item</I></TT><I>

class. Assign the object refereNCe to </I><TT><I>$item</I></TT><I>.

<BR>

Print the two property values using the </I><TT><I>lookup()</I></TT><I>

method to verify that the property initialization worked.</I>

</BLOCKQUOTE>

<HR>

<BLOCKQUOTE>

<B>Listing 14.6&nbsp;&nbsp;14LST06.PL-Using a Static Method to

Retrieve Class Properties<BR>

</B>

</BLOCKQUOTE>

<BLOCKQUOTE>

<PRE>

package UNIVERSAL;

    sub lookup {

        return(%{$_[0]}-&gt;{$_[1]});

    }



package Inventory_item;

    sub new {

        my($class)  = shift;

        my(%params) = @_;

        my($self)   = { };

                             

        $self-&gt;{&quot;PART_NUM&quot;}    = $params{&quot;PART_NUM&quot;};

        $self-&gt;{&quot;QTY_ON_HAND&quot;} = $params{&quot;QTY_ON_HAND&quot;};



        return(bless($self, $class));

    }



package main;



    $item = Inventory_item-&gt;new(&quot;PART_NUM&quot;=&gt;&quot;12A-34&quot;, &quot;QTY_ON_HAND&quot;=&gt;34);



    print(&quot;The part number is &quot; . $item-&gt;lookup('PART_NUM')     . &quot;\n&quot;);

    print(&quot;The quantity is &quot;    . $item-&gt;lookup('QTY_ON_HAND')  . &quot;\n&quot;);

</PRE>

</BLOCKQUOTE>

<HR>

<P>

I don't think this example needs any further explanation, so let's

use the space normally reserved to further discussion of the listing

and show you another utility fuNCtion instead. The <TT>printAll()</TT>

fuNCtion shown here displays all the properties of a class, or

you can specify one or more properties to display:

<BLOCKQUOTE>

<PRE>

sub printAll {

    my($self) = shift;

    my(@keys) = @_ ? @_ : sort(keys(%{$self}));



    print(&quot;CLASS: $self\n&quot;);

    foreach $key (@keys) {

        printf(&quot;\t%10.10s =&gt; $self-&gt;{$key}\n&quot;, $key);

    }

}

</PRE>

</BLOCKQUOTE>

<P>

If you put this fuNCtion into the <TT>UNIVERSAL</TT>

package, it will be available to any classes you define.

<P>

After constructing an inventory object, the statement <TT>$item-&gt;printAll();</TT>

might display

<BLOCKQUOTE>

<PRE>

CLASS: Inventory_item=HASH(0x77ceac)

          PART_NUM =&gt; 12A-34

        QTY_ON_HAN =&gt; 34

</PRE>

</BLOCKQUOTE>

<P>

and the statement <TT>$item-&gt;printAll('PART_NUM');</TT>

might display

<BLOCKQUOTE>

<PRE>

CLASS: Inventory_item=HASH(0x77ceac)

          PART_NUM =&gt; 12A-34

</PRE>

</BLOCKQUOTE>

<H2><A NAME="Summary"><FONT SIZE=5 COLOR=#FF0000>

Summary</FONT></A></H2>

<P>

This chapter served as an introduction to objects. It was not

intended to turn you into an overnight object guru. I hope that

enough information was presented so you have an understanding

of the object terminology and can read other people's programs.

You can also create your own methods and properties. However,

if you need to create more than a few small objects, consider

reading a book devoted specifically to object-oriented programming.

I give this advice because the relationships between objects can

become complex quickly when more than five objects are being used.

<P>

You learned earlier in the chapter that object-oriented programming

has its own terminology. This terminology lets you think of objects

in a computer language independent manner. After describing the

object or class as a set of properties (information) and methods

(fuNCtions), the class can be programmed using C++, Perl, or Delphi.

The programming language is relegated to the role of an implementation

detail.

<P>

The four big coNCepts in object-oriented programming are abstraction,

eNCapsulation, inheritaNCe, and polymorphism. Abstraction means

to isolate the access of a property from how it's stored. ENCapsulation

means that properties and the methods that act on them are defined

together. InheritaNCe means that one class (the child) can be

derived from another (the parent), and the child class will have

all the properties and methods defined in the parent. Polymorphism

means that the child class can override properties and methods

defined in the parent simply by using the same property or method

name.

<P>

After defining these words, you read about creating some classes

for an inventory system; the <TT>Inventory_item</TT>

and <TT>Pen</TT> classes were described.

The <TT>Pen</TT> class was derived

from the <TT>Inventory_item</TT> class.

These classes were used in examples to show how abstraction and

polymorphism work.

<P>

Next, you looked at object-oriented Perl scripts. You read that

it's good to keep all class property information in anonymous

hashes and that the <TT>bless()</TT>

fuNCtion is used to change the data type of a variable-even anonymous

ones.

<P>

You saw how to initialize properties by passing values to the

<TT>new()</TT> constructor fuNCtion.

With this technique, you can use named parameters and therefore

create partially initialized objects if needed. Child classes

in Perl will not automatically inherit properties from its parents.

However, using anonymous hashes totally avoids this issue because

the parent constructor can be explicitly called to create the

object. Then, the child can simply add entries to the anonymous

hash.

<P>

You saw an example of how one class can contain another. The <TT>Pen</TT>

class used this technique to hold an instaNCe of the <TT>Color</TT>

class.

<P>

Static variables and methods are independent of any specific object.

For example, the <TT>Color</TT> class

used a static hash to hold values for the colors blue and red.

Static variables can be accessed using the notation <TT>$Color::colors{&quot;blue&quot;}</TT>.

Of course, only static hash variables use this notation, but scalars

and arrays are accessed similarly. You can use static methods

like <TT>new()</TT> to create new

instaNCes of a class.

<P>

You also saw that the <TT>@ISA</TT>

array is used to hold a list of parent classes for the base class.

In addition, you learned that the <TT>UNIVERSAL</TT>

class is invisibly added to the end of the <TT>@ISA</TT>

array-making it the the last class searched for an undefined method.

The <TT>AUTOLOAD()</TT> method is

normally used to load undefined methods; however, in this chapter,

it was used instead to display an error message telling which

method