Commit | Line | Data |
a0d0e21e |
1 | =head1 NAME |
2 | |
3 | perlobj - Perl objects |
4 | |
5 | =head1 DESCRIPTION |
6 | |
7 | First of all, you need to understand what references are in Perl. See |
8 | L<perlref> for that. |
9 | |
10 | Here are three very simple definitions that you should find reassuring. |
11 | |
12 | =over 4 |
13 | |
14 | =item 1. |
15 | |
16 | An object is simply a reference that happens to know which class it |
17 | belongs to. |
18 | |
19 | =item 2. |
20 | |
21 | A class is simply a package that happens to provide methods to deal |
22 | with object references. |
23 | |
24 | =item 3. |
25 | |
26 | A method is simply a subroutine that expects an object reference (or |
27 | a package name, for static methods) as the first argument. |
28 | |
29 | =back |
30 | |
31 | We'll cover these points now in more depth. |
32 | |
33 | =head2 An Object is Simply a Reference |
34 | |
35 | Unlike say C++, Perl doesn't provide any special syntax for |
36 | constructors. A constructor is merely a subroutine that returns a |
37 | reference that has been "blessed" into a class, generally the |
38 | class that the subroutine is defined in. Here is a typical |
39 | constructor: |
40 | |
41 | package Critter; |
42 | sub new { bless {} } |
43 | |
44 | The C<{}> constructs a reference to an anonymous hash containing no |
45 | key/value pairs. The bless() takes that reference and tells the object |
46 | it references that it's now a Critter, and returns the reference. |
47 | This is for convenience, since the referenced object itself knows that |
48 | it has been blessed, and its reference to it could have been returned |
49 | directly, like this: |
50 | |
51 | sub new { |
52 | my $self = {}; |
53 | bless $self; |
54 | return $self; |
55 | } |
56 | |
57 | In fact, you often see such a thing in more complicated constructors |
58 | that wish to call methods in the class as part of the construction: |
59 | |
60 | sub new { |
61 | my $self = {} |
62 | bless $self; |
63 | $self->initialize(); |
64 | $self; |
65 | } |
66 | |
67 | Within the class package, the methods will typically deal with the |
68 | reference as an ordinary reference. Outside the class package, |
69 | the reference is generally treated as an opaque value that may |
70 | only be accessed through the class's methods. |
71 | |
748a9306 |
72 | A constructor may re-bless a referenced object currently belonging to |
a0d0e21e |
73 | another class, but then the new class is responsible for all cleanup |
74 | later. The previous blessing is forgotten, as an object may only |
75 | belong to one class at a time. (Although of course it's free to |
76 | inherit methods from many classes.) |
77 | |
78 | A clarification: Perl objects are blessed. References are not. Objects |
79 | know which package they belong to. References do not. The bless() |
80 | function simply uses the reference in order to find the object. Consider |
81 | the following example: |
82 | |
83 | $a = {}; |
84 | $b = $a; |
85 | bless $a, BLAH; |
86 | print "\$b is a ", ref($b), "\n"; |
87 | |
88 | This reports $b as being a BLAH, so obviously bless() |
89 | operated on the object and not on the reference. |
90 | |
91 | =head2 A Class is Simply a Package |
92 | |
93 | Unlike say C++, Perl doesn't provide any special syntax for class |
94 | definitions. You just use a package as a class by putting method |
95 | definitions into the class. |
96 | |
97 | There is a special array within each package called @ISA which says |
98 | where else to look for a method if you can't find it in the current |
99 | package. This is how Perl implements inheritance. Each element of the |
100 | @ISA array is just the name of another package that happens to be a |
101 | class package. The classes are searched (depth first) for missing |
102 | methods in the order that they occur in @ISA. The classes accessible |
103 | through @ISA are known as base classes of the current class. |
104 | |
105 | If a missing method is found in one of the base classes, it is cached |
106 | in the current class for efficiency. Changing @ISA or defining new |
107 | subroutines invalidates the cache and causes Perl to do the lookup again. |
108 | |
109 | If a method isn't found, but an AUTOLOAD routine is found, then |
110 | that is called on behalf of the missing method. |
111 | |
112 | If neither a method nor an AUTOLOAD routine is found in @ISA, then one |
113 | last try is made for the method (or an AUTOLOAD routine) in a class |
114 | called UNIVERSAL. If that doesn't work, Perl finally gives up and |
115 | complains. |
116 | |
117 | Perl classes only do method inheritance. Data inheritance is left |
118 | up to the class itself. By and large, this is not a problem in Perl, |
119 | because most classes model the attributes of their object using |
120 | an anonymous hash, which serves as its own little namespace to be |
121 | carved up by the various classes that might want to do something |
122 | with the object. |
123 | |
124 | =head2 A Method is Simply a Subroutine |
125 | |
126 | Unlike say C++, Perl doesn't provide any special syntax for method |
127 | definition. (It does provide a little syntax for method invocation |
128 | though. More on that later.) A method expects its first argument |
129 | to be the object or package it is being invoked on. There are just two |
130 | types of methods, which we'll call static and virtual, in honor of |
131 | the two C++ method types they most closely resemble. |
132 | |
133 | A static method expects a class name as the first argument. It |
134 | provides functionality for the class as a whole, not for any individual |
135 | object belonging to the class. Constructors are typically static |
136 | methods. Many static methods simply ignore their first argument, since |
137 | they already know what package they're in, and don't care what package |
138 | they were invoked via. (These aren't necessarily the same, since |
139 | static methods follow the inheritance tree just like ordinary virtual |
140 | methods.) Another typical use for static methods is to look up an |
141 | object by name: |
142 | |
143 | sub find { |
144 | my ($class, $name) = @_; |
145 | $objtable{$name}; |
146 | } |
147 | |
148 | A virtual method expects an object reference as its first argument. |
149 | Typically it shifts the first argument into a "self" or "this" variable, |
150 | and then uses that as an ordinary reference. |
151 | |
152 | sub display { |
153 | my $self = shift; |
154 | my @keys = @_ ? @_ : sort keys %$self; |
155 | foreach $key (@keys) { |
156 | print "\t$key => $self->{$key}\n"; |
157 | } |
158 | } |
159 | |
160 | =head2 Method Invocation |
161 | |
162 | There are two ways to invoke a method, one of which you're already |
163 | familiar with, and the other of which will look familiar. Perl 4 |
164 | already had an "indirect object" syntax that you use when you say |
165 | |
166 | print STDERR "help!!!\n"; |
167 | |
168 | This same syntax can be used to call either static or virtual methods. |
169 | We'll use the two methods defined above, the static method to lookup |
170 | an object reference and the virtual method to print out its attributes. |
171 | |
172 | $fred = find Critter "Fred"; |
173 | display $fred 'Height', 'Weight'; |
174 | |
175 | These could be combined into one statement by using a BLOCK in the |
176 | indirect object slot: |
177 | |
178 | display {find Critter "Fred"} 'Height', 'Weight'; |
179 | |
180 | For C++ fans, there's also a syntax using -> notation that does exactly |
181 | the same thing. The parentheses are required if there are any arguments. |
182 | |
183 | $fred = Critter->find("Fred"); |
184 | $fred->display('Height', 'Weight'); |
185 | |
186 | or in one statement, |
187 | |
188 | Critter->find("Fred")->display('Height', 'Weight'); |
189 | |
190 | There are times when one syntax is more readable, and times when the |
191 | other syntax is more readable. The indirect object syntax is less |
192 | cluttered, but it has the same ambiguity as ordinary list operators. |
193 | Indirect object method calls are parsed using the same rule as list |
194 | operators: "If it looks like a function, it is a function". (Presuming |
195 | for the moment that you think two words in a row can look like a |
196 | function name. C++ programmers seem to think so with some regularity, |
197 | especially when the first word is "new".) Thus, the parens of |
198 | |
199 | new Critter ('Barney', 1.5, 70) |
200 | |
201 | are assumed to surround ALL the arguments of the method call, regardless |
202 | of what comes after. Saying |
203 | |
204 | new Critter ('Bam' x 2), 1.4, 45 |
205 | |
206 | would be equivalent to |
207 | |
208 | Critter->new('Bam' x 2), 1.4, 45 |
209 | |
210 | which is unlikely to do what you want. |
211 | |
212 | There are times when you wish to specify which class's method to use. |
213 | In this case, you can call your method as an ordinary subroutine |
214 | call, being sure to pass the requisite first argument explicitly: |
215 | |
216 | $fred = MyCritter::find("Critter", "Fred"); |
217 | MyCritter::display($fred, 'Height', 'Weight'); |
218 | |
219 | Note however, that this does not do any inheritance. If you merely |
220 | wish to specify that Perl should I<START> looking for a method in a |
221 | particular package, use an ordinary method call, but qualify the method |
222 | name with the package like this: |
223 | |
224 | $fred = Critter->MyCritter::find("Fred"); |
225 | $fred->MyCritter::display('Height', 'Weight'); |
226 | |
748a9306 |
227 | Sometimes you want to call a method when you don't know the method name |
228 | ahead of time. You can use the arrow form, replacing the method name |
229 | with a simple scalar variable containing the method name: |
230 | |
231 | $method = $fast ? "findfirst" : "findbest"; |
232 | $fred->$method(@args); |
233 | |
a0d0e21e |
234 | =head2 Destructors |
235 | |
236 | When the last reference to an object goes away, the object is |
237 | automatically destroyed. (This may even be after you exit, if you've |
238 | stored references in global variables.) If you want to capture control |
239 | just before the object is freed, you may define a DESTROY method in |
240 | your class. It will automatically be called at the appropriate moment, |
241 | and you can do any extra cleanup you need to do. |
242 | |
243 | Perl doesn't do nested destruction for you. If your constructor |
244 | reblessed a reference from one of your base classes, your DESTROY may |
245 | need to call DESTROY for any base classes that need it. But this only |
246 | applies to reblessed objects--an object reference that is merely |
247 | I<CONTAINED> in the current object will be freed and destroyed |
248 | automatically when the current object is freed. |
249 | |
748a9306 |
250 | =head2 WARNING |
251 | |
252 | An indirect object is limited to a name, a scalar variable, or a block, |
253 | because it would have to do too much lookahead otherwise, just like any |
254 | other postfix dereference in the language. The left side of -> is not so |
255 | limited, because it's an infix operator, not a postfix operator. |
256 | |
257 | That means that below, A and B are equivalent to each other, and C and D |
258 | are equivalent, but AB and CD are different: |
259 | |
260 | A: method $obref->{"fieldname"} |
261 | B: (method $obref)->{"fieldname"} |
262 | C: $obref->{"fieldname"}->method() |
263 | D: method {$obref->{"fieldname"}} |
264 | |
a0d0e21e |
265 | =head2 Summary |
266 | |
267 | That's about all there is to it. Now you just need to go off and buy a |
268 | book about object-oriented design methodology, and bang your forehead |
269 | with it for the next six months or so. |
270 | |
271 | =head1 SEE ALSO |
272 | |
273 | You should also check out L<perlbot> for other object tricks, traps, and tips. |