by Kamran Husain
Today's lesson teaches you how to use the object-oriented programming (OOP) features of Perl as well as how to construct objects in Perl. The discussion also includes inheritance, overriding methods, and data encapsulation.
A module is a Perl package. Objects in Perl are based on references to data items within a package. An object in Perl is simply a reference to something that knows which class it belongs to. (References are covered on Day 18, "References in Perl 5.") For more information, you can consult the perlmod and perlobj text files at http://www.metronet.com. These files are the primary source of information on the Internet about Perl modules.
In object-oriented programming with other languages, you declare a class and then create objects of that class. All objects of a particular class behave in a certain way, which is governed by the methods of that class. You can create new classes by defining new ones or by inheriting properties from an existing class.
Programmers already familiar with object-oriented principles will recognize the terminology used here. Perl is, and pretty much always has been, an object-oriented language. In Perl 4, the use of packages provides different symbol tables from which to choose symbol names. Perl 5 changes the syntax a bit and somewhat formalizes the use of objects.
The next three declarations are extremely important to understanding how objects, classes, and methods work in Perl.
The rest of today's lesson covers each of the preceding items in more detail.
One rule is important enough to repeat: A Perl class is simply a package. When you see a Perl document that refers to a "class," think "package." Existing Perl 5 syntax enables you to create a class. If you are already a C programmer, you do not have to know a lot of new syntax. What might be a new concept to Perl 4 programmers is the use of the double colon (::) to signify the base and inherited classes.
One of the key features of OOP is inheritance. The inheritance feature offered by Perl, however, is not the same as you might expect from other object-oriented languages. Perl classes inherit methods only; you must use your own mechanisms to implement data inheritance.
Because each class is a package, it has its own name space with its own associative array of symbol names. Each class can therefore use its own independent set of symbol names. As with package references, you can address the variables in a class with the back quote (') operator. Members of a class are addressed as $class'$member. In Perl 5, you can use the double colon instead of the ' to get the reference. For example, $class'member is the same as $class::$member.
This section covers the requisite steps to take when you create
a new class. The example illustrates the semantics in the creation
of a simple class called Cocoa, which is used for printing
the required parts of a source code file for a simple Java application.
You will not become a Java expert, nor will this package require
you to have any experience in Java; the focus is the concept of
creating a class. The example could have just as easily used a
phone book application, but how many similar examples have you
already seen in books?
| NOTE |
I am currently still developing the package Java.pm. It's named Cocoa.pm in development because it does not have the high caffeine content of a full-featured, or even mildly useful, Java.pm package. Perhaps after reading today's lesson you will be able to contribute to the Java.pm Perl package; if so, send e-mail to khusain@ikra.com. Time now for a shameless plug for Perl Unleashed, which is also by Sams Publishing, due the summer of 1996. It will contain gobs of information about writing and using classes and packages-and track the initial development stages of the Java.pm package. (Hmmm. Maybe the package should be called Bean.pm in its early stages.) |
First of all, create a package file called Cocoa.pm. (The .pm extension, which is the default extension for packages, stands for Perl module.) A module is a package, and a package is a class for all practical purposes. Before you do anything else, place a 1; in the file. As you add more lines to the package file, make sure you keep the 1; as the last line. The following code shows the basic structure of the file:
package Cocoa; # # Put "require" statements in for all required,imported packages # # # Just add code here # 1; # terminate the package with the required 1;
This requirement is important: Don't forget to always keep the 1; line as the last of the package file. This statement is required for all packages in Perl. If you forget this statement, your package will not be processed by Perl.
Congratulations; you have just created your first package file. Now you are ready to add your methods to this package and make it a class. The first method you should add is the new() method, which must be called whenever you create a new object. The new() method is the constructor for the object.
A constructor is a Perl subroutine in a class that returns a reference to something that has the class name attached to it. Connecting a class name with a reference is referred to as "blessing" an object because the function to establish the connection is called bless.
The following code segment shows the syntax for the bless function:
bless YeReference [,classname]
YeReference is the reference to the object being blessed. The classname is optional and specifies the name of the package from which the object will get methods. If the classname is not specified, the name of the current package is used instead.
The way to create a constructor in Perl is to return a reference to an internal structure that has been blessed into this Cocoa class. Listing 19.1 shows the initial Cocoa.pm package.
Listing 19.1. The initial Cocoa.pm package. package Cocoa;
sub new {
my $this = {}; # Create an anonymous hash, and #self points to it.
bless $this; # Connect the hash to the package Cocoa.
return $this; # Return the reference to the hash.
}
1;
There is no output for Listing 19.1.
The {} constructs a reference to a hash that contains no key/value pairs. The returned value to this hash is assigned to the local variable $this. The bless() function takes that reference to $this, tells the object it references that it's now a Cocoa, and returns the reference.
The returned value to the calling function now refers to this anonymous hash. On return from the new() function, the $this reference is destroyed, but the calling function keeps a reference to this hash. Therefore, the reference count to the hash won't be zero and Perl keeps the hash in memory. (You do not have to keep it around, but it's nice to have it around for reference later.)
To create an object, you make a call such as the following:
$cup = new Cocoa;
Listing 19.2 shows you how to use this package to create the constructor.
Listing 19.2. Creating the constructor.
1 #!/usr/bin/perl 2 push (@INC,'pwd'); 3 use Cocoa; 4 $cup = new Cocoa;
Line 1 refers to the location of the Perl interpreter to use. Your Perl interpreter may be located at /usr/local/bin/perl or wherever you installed it.
In line 2, the local directory is added to the search path in @INC for the list of paths to use when looking for a package. You can create your module in a different directory and specify the path explicitly there. Had I created the package in /home/khusain/test/scripts/, line 2 would read as follows:
push (@INC,"/home/khusain/test/scripts");
In line 3, you include the package Cocoa.pm to get all the functionality in your script. The use statement asks Perl to look in the @INC path for a file named Cocoa.pm and include it in the copy of the source file being parsed. The use statement is required if you want to work with a class.
Line 4 creates the Cocoa object by calling the new function on it. Now comes the beauty (and confusion and power) of Perl. There is more than one way to do this. You can rewrite line 4 as the following:
$cup = Cocoa->new();
If you are a C programmer, you can use the double colons (::) to force the function new() from the Cocoa package. As a result, line 4 could also be written as the following:
$cup = Cocoa::new();
Nothing prevents you from adding more code in the constructor
than what is shown here. For the Cocoa.pm module, you
can, if you like, print a disclaimer when each object is created.
You might want to use the constructor to initialize variables
or set up arrays or pointers specific to the module.
 |
DO initialize variables in your module in the constructor. DO use the my construct to create variables in a method. DON'T use the local construct in a method unless you really do want the variables to be passed down to other subroutines. DON'T use global variables in the class module. |
| TIP |
When you are working with instance variables, it is sometimes easy to visualize a Perl object as simply an associative array. Then it's easy to see that each index in the associative array is a member of that class and each item at the index of the associative array is a value of that member. |
Listing 19.3 shows what the Cocoa constructor looks like.
Listing 19.3. Revised constructor for Cocoa.pm. sub new {
my $this = {};
print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk";
print "\n ** Did this code even get pass the javac compiler? ";
print "\n **/ \n";
bless $this;
return $this;
}
The following shows the output from running the test script called testme on this bare-bones class:
$ testme /* ** Created by Cocoa.pm ** Use at own risk ** Did this code even get pass the javac compiler? **/
Regardless of which of the three methods shown here you used to
create the Cocoa object, you should see the same output.
Great. Now you've created some comments at the beginning of a file with some print statements. You can just as easily call other functions in or outside of the package to get more initialization functionality. For example, as development progresses, you see the new() function evolve to resemble the following:
sub new {
my $this = {}
bless $this;
$this->doInitialization();
return $this;
}
When you create any given class, you should allow it to be inherited. You should be able to call the new operator with the class name as the first parameter. This capability to parse the class name from the first argument causes the class to be inherited. As a result, the new function becomes more or less like the following:
sub new {
my $class = shift; # Get the request class name
my $this = {};
bless $this, $class # Use class name to bless() reference
$this->doInitialization();
return $this;
}
The preceding method forces your class users to make calls in the form of one of three ways:
What if you wanted to use a reference to the object instead, such as $obj->new()? The doInitialization() method used will be whatever $class you blessed the object into. The following code uses the function call ref() to determine if the class exists per se. The ref() function returns true if the item passed to it is a reference and null if it is not a reference. With classes, the true value returned from the ref() function is the name of the class.
sub new {
my $this = shift; # Get the class name
my $class = ref($this) || $this;
Â# If class exists, use it else use reference.
my $this = {};
bless $this, $class
$this->doInitialization();
return $this;
}
Within the class package, the methods typically treat the reference as an ordinary reference. Outside the class package, the reference is generally treated as an opaque value that can only be accessed through the class's methods. You can access the values within the package directly, but it's not a good idea to do so because such access defeats the whole purpose of object orientation.
It's possible to bless a reference object more than once. However, the caveat is that the new class must get rid of the object at the previously blessed reference. For C and Pascal programmers, this is like assigning a pointer to malloced memory and then assigning the same pointer to another location without first freeing the previous location. In effect, a Perl object must belong to only one class at a time.
What's the real difference between an object and a reference? Perl objects are blessed to belong to a class. References are not blessed; if they are, they belong to a class and are objects. Objects know to which class they belong. References do not have a class to which they belong.
The arguments to a new() function for a constructor are called instance variables. Instance variables are used to do initialization for each instance of an object as it's created. For example, the new() function could expect a name for each new instance of the object created. Using instance variables allows you to customize each object as it is created.
You can use either an anonymous array or anonymous hash to hold instance variables. To use a hash to store the parameters coming in, the code would resemble the following:
sub new {
my $type = shift;
my %parm = @_;
my $this = {};
$this->{'Name'} = $parm{'Name'};
$this->{'x'} = $parm{'x'};
$this->{'y'} = $parm{'y'};
bless $this, $type;
}
You can also use an array instead of a hash to store the instance variables.
sub new {
my $type = shift;
my %parm = @_;
my $this = [];
$this->[0] = $parm{'Name'};
$this->[1] = $parm{'x'};
$this->[2] = $parm{'y'};
bless $this, $type;
}
To construct an object, you can pass the parameters with the new() function call. For example, the call to create the Cocoa object becomes the following:
$mug = Cocoa::new( 'Name' => 'top', 'x' => 10, 'y' => 20 );
The => operator has the same function of the comma operator, but => is a bit more readable. You can write this code with commas instead of the => operator if you prefer.
To access the variables as you would any other data members, you can use the following statements:
print "Name=$mug->{'Name'}\n";
print "x=$mug->{'x'}\n";
print "y=$mug->{'y'}\n";
A method in a Perl class is simply a Perl subroutine. Perl doesn't provide any special syntax for method definition. A method expects its first argument to be the object or package on which it is invoked. Perl has two types of methods: static and virtual.
A static method expects a class name as the first argument. A virtual method expects a reference to an object as the first argument. The way each method handles the first argument determines whether the method is static or virtual.
A static method applies functionality to the entire class as a whole because it uses the name of the class. Functionality in static methods is therefore applicable to all objects of the class. Generally, static methods ignore the first argument because they already know which class they are in. Constructors are static methods.
A virtual method expects a reference to an object as its first argument. Typically, the first thing a virtual method does is shift the first argument into a self or this variable and then use that shifted value as an ordinary reference. For example, consider the following code:
1. sub nameLister {
2. my $this = shift;
3. my ($keys ,$value );
4. while (($key, $value) = each (%$this)) {
5. print "\t$key is $value.\n";
6. }
7. }
Line 2 in the listing is where the $this variable is
set to point to the object. In line 4, the $this array
is de-referenced at every $key location.
| TIP |
Look at the .pm files in the Perl distribution for sample code that will show you how methods are declared and used. |
If you tried to invoke the Cocoa.pm package right now, you'd get an error message from Perl at compile time about the methods not being found. This error occurs because the Cocoa.pm methods have not been exported. To export these functions, you need the Exporter module. Add the following lines to the beginning of code in the package:
require Exporter; @ISA = qw(Exporter);
These two lines force the inclusion of the Exporter.pm module and then set the @ISA array with the name of the Exporter class to look for.
To export your own class's methods, you list them in the @EXPORT array. For example, to export the closeMain and declareMain methods, you use the following statement:
@EXPORT(declareMain, closeMain);
Inheritance in a Perl class is through the @ISA array. The @ISA array does not have to be defined in every package; however, when it is defined, Perl treats it as a special array of directory names. This array is similar to the @INC array, where directories are searched for files to include. The @ISA array contains the names of the classes (packages) to look for methods in other classes in if a method in the current package is not found. The @ISA array contains the names of the base classes from which the current class inherits. The search is done in the order that the classes are listed in the @ISA arrays.
All methods called by a class must belong to the same class or the base classes defined in the @ISA array. If a method isn't found in the @ISA array, Perl looks for an AUTOLOAD() routine. This optional routine is defined as sub in the current package. To use the AUTOLOAD function, you call the autoload.pm package with the use Autoload; statement. The AUTOLOAD function tries to load the called function from the installed Perl libraries. If the AUTOLOAD call also fails, Perl makes one final try at the UNIVERSAL class, which is the catch-all for all methods not defined elsewhere. Perl generates an error about unresolved functions if this step also fails.
There are two ways to invoke a method for an object: by making a reference to an object (virtual) or explicitly referring to the class name (static). You have to export a method to be able to call it. Add a few more methods to the Cocoa class to get the file to resemble the following code:
package Cocoa;
require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(setImports, declareMain, closeMain);
#
# This routine creates the references for imports in Java functions
#
sub setImports{
my $class = shift @_;
my @names = @_;
foreach (@names) {
print "import " . $_ . ";\n";
}
}
#
# This routine declares the main function in a Java script
#
sub declareMain{
my $class = shift @_;
my ( $name, $extends, $implements) = @_;
print "\n public class $name";
if ($extends) {
print " extends " . $extends;
}
if ($implements) {
print " implements " . $implements;
}
print " { \n";
}
#
# This routine declares the main function in a Java script
#
sub closeMain{
print "} \n";
}
#
# This subroutine creates the header for the file.
#
sub new {
my $this = {};
print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk \n */ \n";
bless $this;
return $this;
}
1;
Now, write a simple Perl script to use the methods for this class. Because you can only start and close the header, examine the following code for a script to create a skeleton Java applet source:
#!/usr/bin/perl use Cocoa; $cup = new Cocoa; $cup->setImports( 'java.io.InputStream', 'java.net.*'); $cup->declareMain( "Msg" , "java.applet.Applet", "Runnable"); $cup->closeMain();
This script generates code for a Java applet called Msg that extends the java.applet.Applet applet and implements functions that are runnable. You call the function with the $cup->... call. The following three lines of code:
$cup->setImports( 'java.io.InputStream', 'java.net.*');3 $cup->declareMain( "Msg" , "java.applet.Applet", "Runnable"); $cup->closeMain();
could be rewritten as functions:
Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*'); Cocoa::declareMain($cup, "Msg" , "java.applet.Applet", "Runnable"); Cocoa::closeMain($cup);
This type of equivalence was shown in the section "Blessing a Constructor," earlier today. In both cases, the first parameter is the reference to the object itself. Running the test script shown generates the following output:
/*
** Created by Cocoa.pm
** Use at own risk
*/
import java.io.InputStream;
import java.net.*;
public class Msg extends java.applet.Applet implements Runnable {
}
An important note about calling the methods: If you have any arguments in a method, use parentheses if you are using the -> (also known as indirect) method. The parentheses are required to include all the arguments with the following statement:
$cup->setImports( 'java.io.InputStream', 'java.net.*');
However, the following statement:
Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');
can also be rewritten without parentheses as this:
Cocoa::setImports $cup, 'java.io.InputStream', 'java.net.*' ;
The choice is yours about how you make your code readable to other programmers. Use parentheses if you feel that it will make the code more readable.
Sometimes you want to specify which class's method to use, such as when the same named method is specified in two different classes. For example, if the function grind is defined in both Espresso and Qava classes, you can specify which class's function to use by using the :: operator. The following calls would use the call in Espresso:
$mess = Espresso::grind("whole","lotta","bags");
Espresso::grind($mess, "whole","lotta","bags");
The following calls would use the grind() function in the Qava class:
$mess = Qava::grind("whole","lotta","bags");
Qava::grind($mess, "whole","lotta","bags");
You might want to call a method based on some action that the program you are writing has already taken. In other words, you want to use the Qava method for a certain condition and the Espresso method for another. In this case, you can use symbolic references to make the call to the required function, as in the following example:
$method = $local ? "Qava::" : "Espresso::";
$cup->{$method}grind(@args);
Perl tracks the number of links to objects. When the last reference to an object is freed to the memory pool, the object is automatically destroyed. This destruction of the object could occur after your code stops and the script is about to exit. For global variables, the destruction happens after the last line in your code executes.
If you want to capture control just before the object is freed, you can define a DESTROY() method in your class. Note the use of all capital letters in the name. The DESTROY() method is called just before the object is released, which enables you to do any necessary cleanup. The DESTROY() function does not call other DESTROY() functions automatically; Perl doesn't do nested destruction for you. If your constructor re-blessed a reference from one of your base classes, your DESTROY() might need to call DESTROY() for any base classes. All object references that are contained in a given object are freed and destroyed automatically when the current object is freed.
Usually, you do not have to define a DESTROY function, but when you do need it, it takes the following form:
sub DESTROY {
#
# Add code here.
#
}
For most purposes, Perl uses a simple, reference-based garbage collection system. The number of references to any given object at the time of garbage collection must be greater than zero, or the memory for that object is freed. When your program exits, an exhaustive search-and-destroy function in Perl does garbage collection. Everything in the process is summarily deleted. In UNIX or UNIX-like systems, this might seem like a waste, but it's actually quite necessary to perform in embedded systems or in a multithreaded environment.
Methods in classes are inherited with the paths in the @ISA array. Variables must be set up explicitly for inheritance. Assume you define a new class called Bean.pm to include some of the functionality that another class Coffee.pm will inherit.
The example in this section demonstrates how to inherit instance variables from one class (also referred to as a "superclass" or "base class"). The steps in inheritance require calling the superclass's constructor and adding one's own instance variables to the new object.
In this example, the Coffee class inherits values from the base class called Bean. The two files are called Coffee.pm and Bean.pm, respectively.
Listing 19.4 is the code for Bean.pm.
Listing 19.4. The code for Bean.pm.
package Bean;
require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(setBeanType);
sub new {
my $type = shift;
my $this = {};
$this->{'Bean'} = 'Colombian';
bless $this, $type;
return $this;
}
#
# This subroutine sets the class name
sub setBeanType{
my ($class, $name) = @_;
$class->{'Bean'} = $name;
print "Set bean to $name \n";
}
1;
Listing 19.4 has no output.
In this listing, the $this variable sets a value in the anonymous hash for the 'Bean' type to be 'Colombian'. The setBeanType() method is also declared so that the 'Bean' type can also be changed by a program.
The subroutine for resetting the value of 'Bean' uses the $class reference to get to the anonymous hash for the object. Remember that a reference to this anonymous hash created the reference in the first place with the new() function.
The values in the Bean class will be inherited by the Coffee class. The Coffee.pm file is shown in Listing 19.5.
Listing 19.5. The Coffee.pm file.
1 #
2 # The Coffee.pm file to illustrate inheritance.
3 #
4 package Coffee;
5 require Exporter;
6 require Bean;
7 @ISA = qw(Exporter, Bean);
8 @EXPORT = qw(setImports, declareMain, closeMain);
9 #
10 # set item
11 #
12 sub setCoffeeType{
13 my ($class,$name) = @_;
14 $class->{'Coffee'} = $name;
15 print "Set coffee type to $name \n";
16 }
17 #
18 # constructor
19 #
20 sub new {
21 my $type = shift;
22 my $this = Bean->new(); ##### <- LOOK HERE!!! ####
23 $this->{'Coffee'} = 'Instant'; # unless told otherwise
24 bless $this, $type;
25 return $this;
26 }
27 1;
Listing 19.5 has no output.
Note the use of the require Bean; statement in line 6. This line forces the inclusion of the Bean.pm file and all its related functions. Lines 12 through 16 define a sub-routine to use when resetting the value of the local variable in $class->{'Coffee'}.
Look at the new() constructor for the Coffee class in line 20. The $this reference points to the anonymous hash returned by Bean.pm and not a hash created locally. In other words, the following statement creates an entirely different hash that has nothing to do with the hash created in the Bean.pm constructor:
my $this = {}; # This is not the way to do it for inheritance.
my $this = $theSuperClass->new(); # this is the way.
Listing 19.6 shows how to call these functions.
Listing 19.6. Calling inherited methods.
1 #!/usr/bin/perl
2 push (@INC,'pwd');
3 use Coffee;
4 $cup = new Coffee;
5 print "\n -------------------- Initial values ------------ \n";
6 print "Coffee: $cup->{'Coffee'} \n";
7 print "Bean: $cup->{'Bean'} \n";
8 print "\n -------------------- Change Bean Type ---------- \n";
9 $cup->setBeanType('Mixed');
10 print "Bean Type is now $cup->{'Bean'} \n";
11 print "\n ------------------ Change Coffee Type ---------- \n";
12 $cup->setCoffeeType('Instant');
13 print "Type of coffee: $cup->{'Coffee'} \n";
-------------------- Initial values ------------ Coffee: Instant Bean: Colombian -------------------- Change Bean Type ---------- Set bean to Mixed Bean Type is now Mixed ------------------ Change Coffee Type ---------- Set coffee type to Instant Type of coffee: Instant
The initial values for the 'Bean' and 'Coffee' indices in the anonymous hash for the object are printed first. The member functions are called to set the values to different names and then printed.
Methods can have several types of arguments. It's how you process the arguments that counts. For example, you can add the following method to the Coffee.pm module:
sub makeCup {
my ($class, $cream, $sugar, $dope) = @_;
print "\n================================== \n";
print "Making a cup \n";
print "Add cream \n" if ($cream);
print "Add $sugar sugar cubes\n" if ($sugar);
print "Making some really addictive coffee ;-) \n" if ($dope);
print "================================== \n";
}
The function makeCup() takes three arguments but processes them only if it sees them. To test this functionality, consider Listing 19.7.
Listing 19.7. Using the makeCup() function.
1 #!/usr/bin/perl
2 push (@INC,'pwd');
3 use Coffee;
4 $cup = new Coffee;
5 #
6 # With no parameters
7 #
8 print "\n Calling with no parameters: \n";
9 $cup->makeCup;
10 #
11 # With one parameter
12 #
13 print "\n Calling with one parameter: \n";
14 $cup->makeCup('1');
15 #
16 # With two parameters
17 #
18 print "\n Calling with two parameters: \n";
19 $cup->makeCup(1,'2');
20 #
21 # With all three parameters
22 #
23 print "\n Calling with three parameters: \n";
24 $cup->makeCup('1',3,'1');
Calling with no parameters: ================================== Making a cup ================================== Calling with one parameter: ================================== Making a cup Add cream ================================== Calling with two parameters: ================================== Making a cup Add cream Add 2 sugar cubes ================================== Calling with three parameters: ================================== Making a cup Add cream Add 3 sugar cubes Making some really addictive coffee ;-) ==================================
Line 9 calls the function with no parameters. In line 14, the function call has one parameter. The parameters are passed either as strings or integers, something this particular method does not care about. Look at line 19 and line 24, where both strings and numbers are passed in the same function call. However, some methods you write in the future might require this distinction.
In any event, you can have default values set in the function if the expected parameter is not passed. The behavior of the method can be different depending on the number of arguments you pass it.
Inheriting functionality from another class is beneficial in that you can get all the exported functionality of the base class in your new class. To see an example of how this works, add a function in the Bean.pm class called printType. Here's the subroutine:
sub printType {
my $class = shift @_;
print "The type of Bean is $class->{'Bean'} \n";
}
Do not forget to update the @EXPORT array by adding the name of the function to export. The new statement should look like this:
@EXPORT = qw(setBeanType, printType, printType);
Now call the printType function. The next three lines show three ways to call the function:
$cup->Coffee::printType(); $cup->printType(); $cup->Bean::printType();
The output from all three lines is the same:
The type of Bean is Mixed The type of Bean is Mixed The type of Bean is Mixed
Why is this so? There is no printType() function in the inheriting class, so the printType() function in the base class is used instead. Naturally, if you want your own class to have its own printType function, you have to define it.
In the Coffee.pm file, add the following lines:
#
# This routine prints the type of $class->{'Coffee'}
#
sub printType {
my $class = shift @_;
print "The type of Coffee is $class->{'Coffee'} \n";
}
You must also modify the @EXPORT to work with this function:
@EXPORT = qw(setImports, declareMain, closeMain, printType);
Now the output from the three lines looks like this:
The type of Coffee is Instant The type of Coffee is Instant The type of Bean is Mixed
The base class function is called only when the Bean:: override is given. In the other cases, only the inherited class function is called.
What if you do not know the base class name or even where the name is defined? In this case, you can use the SUPER:: pseudo-class reserved word. Using the SUPER:: override enables you to call an overridden superclass method without actually knowing where that method is defined. The SUPER:: construct is meaningful only within the class.
If you're trying to control where the method search begins and you're executing in the class itself, you can use the SUPER:: pseudo class, which instructs Perl to start looking in your base class's @ISA list without explicitly naming it:
$this->SUPER::function( ... argument list ... );
Instead of Bean:: we can use SUPER::. The call to the function printType() becomes
$cup->SUPER::printType();
and the output is the following:
The type of Bean is Mixed
One advertised strength of object-oriented languages is the ease
with which new code can use old code. Packages in Perl let you
reuse code through the use of objects and inheritance. OOP languages
use data encapsulation to let you hide the inner workings of complicated
code. Packages and modules in Perl provide a great deal of data
encapsulation with the use of the my construct. Perl,
however, does not guarantee that a class inheriting your code
will not attempt to access your class variables directly, thereby
eliminating the advantage of data encapsulation. They can if they
really want to; however, this type of procedure is considered
bad practice, and shame on you if you do it.
|
DO define methods to access class variables. DON'T access class variables directly from outside the module. |
When writing a package, you should ensure that everything a method needs is available through the object or is passed as a parameter to the method. From within the package, access any global variables only through references passed through methods.
For static or global data to be used by the methods, you have to define the context of the data in the base class using the local() construct. The subclass will then call the base class to get the data for it. On occasion, a subclass might want to override that data and replace it with new data. When this happens, the superclass might not know how to find the new copy of the data. In such cases, it's best to define a reference to the data and then have all base classes and subclasses modify the variable through that reference.
Finally, you will see references to objects and classes such as the following:
use Coffee::Bean;
This code is interpreted to mean "Look for Bean.pm in the Coffee subdirectory in all the directories in the @INC array." If I were to move Bean.pm into the ./Coffee directory, all the previous examples would work with the new use statement. The advantage to this approach is that you have one subclass class file in one directory and the base class in a lower directory. It helps keep code organized. To have a statement like the following:
use Another::Sub::Menu;
you would see a directory sub-tree like this:
./Another/Sub/Menu.pm
This chapter provides a brief introduction to object-oriented programming in Perl. Perl provides the OOP features of data encapsulation and inheritance using modules and packages. A class in Perl is simply a package. A package for a class provides all the methods for objects created for the class.
An object is simply a reference to data that knows which class it belongs to. A method in a class is simply a subroutine. The only catch about writing such methods is that the name of the class is always the first argument of the method.
The bless() function is used to tie a reference to a class name. The bless() function is called in the constructor function new() to create an object and then connect the reference to the object with the name of the class.
With inheritance, the base class is the class from which methods (and data) are inherited. The base class is also called the superclass. The class that inherits these items from the superclass is called the subclass. Multiple inheritance is allowed in Perl. Data inheritance is the programmer's responsibility and requires using references. The subclass is allowed to know things about its immediate superclass; the superclass is not allowed to know anything about a subclass.
| Q: | What does the bless() function do? |
| A: | The bless() function takes one or two arguments. The first argument is a reference to an object. The second argument is optional and specifies the name of a class; if the name is not specified, the default is the current class. After the call, the reference uses the name as its class name. As a result, the reference becomes an object of the class whose name was specified. |
| Q: | What's the difference between an object and a reference? |
| A: | Objects are blessed; references are not. Objects belong to a class, but references do not have to. |
| Q: | What's the difference between static and virtual methods? |
| A: | Static methods expect a class name as the first argument. Virtual methods expect a reference to an object as the first argument. Static methods are class-wide; virtual methods are object-specific. |
| Q: | I just added a method to my class file, but it is never called! What's wrong? |
| A: | Make sure you are using the require Exporter; statement and that the name of the new function is in the @EXPORTER array. |
The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to give you experience in using what you've learned. Try and understand the quiz and exercise answers before you go on to tomorrow's lesson.
