A Horse Is a Horse, of Course of Course—or Is It?
Invoking an Instance Method
Accessing the Instance Data
How to Build a Horse
Inheriting the Constructor
Making a Method Work with Either Classes or Instances
Adding Parameters to a Method
More Interesting Instances
A Horse of a Different Color
Getting Your Deposit Back
Don't Look Inside the Box
Faster Getters and Setters
Getters That Double as Setters
Restricting a Method to Class-Only or Instance-Only
Exercise
Using the simple syntax introduced in Chapter 8, you have class methods, (multiple) inheritance, overriding, and extending. You've been able to factor out common code and provide a way to reuse implementations with variations. This is at the core of what objects provide, but objects also provide instance data, which we haven't even begun to cover.
Let's look at the code used in Chapter 8 for the Animal classes and Horse classes:
{ package Animal; sub speak { my $class = shift; print "a $class goes ", $class->sound, "!\n" } } { package Horse; @ISA = qw(Animal); sub sound { "neigh" } }
This lets you invoke Horse->speak to ripple upward to Animal::speak, calling back to Horse::sound to get the specific sound, and the output of:
a Horse goes neigh!
But all Horse objects would have to be absolutely identical. If you add a subroutine, all horses automatically share it. That's great for making horses identical, but how do you capture the properties of an individual horse? For example, suppose you want to give your horse a name. There's got to be a way to keep its name separate from those of other horses.
You can do so by establishing an instance. An instance is generally created by a class, much like a car is created by a car factory. An instance will have associated properties, called instance variables (or member variables, if you come from a C++ or Java background). An instance has a unique identity (like the serial number of a registered horse), shared properties (the color and talents of the horse), and common behavior (i.e., pulling the reins back tells the horse to stop).
In Perl, an instance must be a reference to one of the built-in types. Start with the simplest reference that can hold a horse's name: a scalar reference:[37]
[37]The simplest, but rarely used in real code for reasons you'll see shortly
my $name = "Mr. Ed"; my $tv_horse = \$name;
Now $tv_horse is a reference to what will be the instance-specific data (the name). The final step in turning this into a real instance involves a special operator called bless:
bless $tv_horse, "Horse";
The bless operator follows the reference to find what variable it points to—in this case the scalar $name. Then it "blesses" that variable, turning $tv_horse into an object —a Horse object, in fact. (Imagine that a little sticky-note that says Horse is now attached to $name.)
At this point, $tv_horse is an instance of Horse.[38] That is, it's a specific horse. The reference is otherwise unchanged and can still be used with traditional dereferencing operators.[39]
[38]Actually, $tv_horse points to the object, but in common terms, you nearly always deal with objects by references to those objects. Hence, it's simpler to say that $tv_horse is the horse, not "the thing that $tv_horse is referencing."
[39]Although doing so outside the class is a bad idea, as you'll see later.
Copyright © 2003 O'Reilly & Associates. All rights reserved.