This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
bab365609e160ebeccbfbd6e746c9c8c3982ae90
[perl5.git] / pod / perlboot.pod
1 =head1 NAME
2
3 perlboot - Beginner's Object-Oriented Tutorial
4
5 =head1 DESCRIPTION
6
7 If you're not familiar with objects from other languages, some of the
8 other Perl object documentation may be a little daunting, such as
9 L<perlobj>, a basic reference in using objects, and L<perltoot>, which
10 introduces readers to the pecularities of Perl's object system in a
11 tutorial way.
12
13 So, let's take a different approach, presuming no prior object
14 experience. It helps if you know about subroutines (L<perlsub>),
15 references (L<perlref> et. seq.), and packages (L<perlmod>), so become
16 familiar with those first if you haven't already.
17
18 =head2 If we could talk to the animals...
19
20 Let's let the animals talk for a moment:
21
22     sub Cow::speak {
23       print "a Cow goes moooo!\n";
24     }
25     sub Horse::speak {
26       print "a Horse goes neigh!\n";
27     }
28     sub Sheep::speak {
29       print "a Sheep goes baaaah!\n"
30     }
31
32     Cow::speak;
33     Horse::speak;
34     Sheep::speak;
35
36 This results in:
37
38     a Cow goes moooo!
39     a Horse goes neigh!
40     a Sheep goes baaaah!
41
42 Nothing spectacular here.  Simple subroutines, albeit from separate
43 packages, and called using the full package name.  So let's create
44 an entire pasture:
45
46     # Cow::speak, Horse::speak, Sheep::speak as before
47     @pasture = qw(Cow Cow Horse Sheep Sheep);
48     foreach $animal (@pasture) {
49       &{$animal."::speak"};
50     }
51
52 This results in:
53
54     a Cow goes moooo!
55     a Cow goes moooo!
56     a Horse goes neigh!
57     a Sheep goes baaaah!
58     a Sheep goes baaaah!
59
60 Wow.  That symbolic coderef de-referencing there is pretty nasty.
61 We're counting on C<no strict subs> mode, certainly not recommended
62 for larger programs.  And why was that necessary?  Because the name of
63 the package seems to be inseparable from the name of the subroutine we
64 want to invoke within that package.
65
66 Or is it?
67
68 =head2 Introducing the method invocation arrow
69
70 For now, let's say that C<< Class->method >> invokes subroutine
71 C<method> in package C<Class>.  (Here, "Class" is used in its
72 "category" meaning, not its "scholastic" meaning.) That's not
73 completely accurate, but we'll do this one step at a time.  Now let's
74 use it like so:
75
76     # Cow::speak, Horse::speak, Sheep::speak as before
77     Cow->speak;
78     Horse->speak;
79     Sheep->speak;
80
81 And once again, this results in:
82
83     a Cow goes moooo!
84     a Horse goes neigh!
85     a Sheep goes baaaah!
86
87 That's not fun yet.  Same number of characters, all constant, no
88 variables.  But yet, the parts are separable now.  Watch:
89
90     $a = "Cow";
91     $a->speak; # invokes Cow->speak
92
93 Ahh!  Now that the package name has been parted from the subroutine
94 name, we can use a variable package name.  And this time, we've got
95 something that works even when C<use strict refs> is enabled.
96
97 =head2 Invoking a barnyard
98
99 Let's take that new arrow invocation and put it back in the barnyard
100 example:
101
102     sub Cow::speak {
103       print "a Cow goes moooo!\n";
104     }
105     sub Horse::speak {
106       print "a Horse goes neigh!\n";
107     }
108     sub Sheep::speak {
109       print "a Sheep goes baaaah!\n"
110     }
111
112     @pasture = qw(Cow Cow Horse Sheep Sheep);
113     foreach $animal (@pasture) {
114       $animal->speak;
115     }
116
117 There!  Now we have the animals all talking, and safely at that,
118 without the use of symbolic coderefs.
119
120 But look at all that common code.  Each of the C<speak> routines has a
121 similar structure: a C<print> operator and a string that contains
122 common text, except for two of the words.  It'd be nice if we could
123 factor out the commonality, in case we decide later to change it all
124 to C<says> instead of C<goes>.
125
126 And we actually have a way of doing that without much fuss, but we
127 have to hear a bit more about what the method invocation arrow is
128 actually doing for us.
129
130 =head2 The extra parameter of method invocation
131
132 The invocation of:
133
134     Class->method(@args)
135
136 attempts to invoke subroutine C<Class::method> as:
137
138     Class::method("Class", @args);
139
140 (If the subroutine can't be found, "inheritance" kicks in, but we'll
141 get to that later.)  This means that we get the class name as the
142 first parameter.  So we can rewrite the C<Sheep> speaking subroutine
143 as:
144
145     sub Sheep::speak {
146       my $class = shift;
147       print "a $class goes baaaah!\n";
148     }
149
150 And the other two animals come out similarly:
151
152     sub Cow::speak {
153       my $class = shift;
154       print "a $class goes moooo!\n";
155     }
156     sub Horse::speak {
157       my $class = shift;
158       print "a $class goes neigh!\n";
159     }
160
161 In each case, C<$class> will get the value appropriate for that
162 subroutine.  But once again, we have a lot of similar structure.  Can
163 we factor that out even further?  Yes, by calling another method in
164 the same class.
165
166 =head2 Calling a second method to simplify things
167
168 Let's call out from C<speak> to a helper method called C<sound>.
169 This method provides the constant text for the sound itself.
170
171     { package Cow;
172       sub sound { "moooo" }
173       sub speak {
174         my $class = shift;
175         print "a $class goes ", $class->sound, "!\n"
176       }
177     }
178
179 Now, when we call C<< Cow->speak >>, we get a C<$class> of C<Cow> in
180 C<speak>.  This in turn selects the C<< Cow->sound >> method, which
181 returns C<moooo>.  But how different would this be for the C<Horse>?
182
183     { package Horse;
184       sub sound { "neigh" }
185       sub speak {
186         my $class = shift;
187         print "a $class goes ", $class->sound, "!\n"
188       }
189     }
190
191 Only the name of the package and the specific sound change.  So can we
192 somehow share the definition for C<speak> between the Cow and the
193 Horse?  Yes, with inheritance!
194
195 =head2 Inheriting the windpipes
196
197 We'll define a common subroutine package called C<Animal>, with the
198 definition for C<speak>:
199
200     { package Animal;
201       sub speak {
202         my $class = shift;
203         print "a $class goes ", $class->sound, "!\n"
204       }
205     }
206
207 Then, for each animal, we say it "inherits" from C<Animal>, along
208 with the animal-specific sound:
209
210     { package Cow;
211       @ISA = qw(Animal);
212       sub sound { "moooo" }
213     }
214
215 Note the added C<@ISA> array.  We'll get to that in a minute.
216
217 But what happens when we invoke C<< Cow->speak >> now?
218
219 First, Perl constructs the argument list.  In this case, it's just
220 C<Cow>.  Then Perl looks for C<Cow::speak>.  But that's not there, so
221 Perl checks for the inheritance array C<@Cow::ISA>.  It's there,
222 and contains the single name C<Animal>.
223
224 Perl next checks for C<speak> inside C<Animal> instead, as in
225 C<Animal::speak>.  And that's found, so Perl invokes that subroutine
226 with the already frozen argument list.
227
228 Inside the C<Animal::speak> subroutine, C<$class> becomes C<Cow> (the
229 first argument).  So when we get to the step of invoking
230 C<< $class->sound >>, it'll be looking for C<< Cow->sound >>, which
231 gets it on the first try without looking at C<@ISA>.  Success!
232
233 =head2 A few notes about @ISA
234
235 This magical C<@ISA> variable (pronounced "is a" not "ice-uh"), has
236 declared that C<Cow> "is a" C<Animal>.  Note that it's an array,
237 not a simple single value, because on rare occasions, it makes sense
238 to have more than one parent class searched for the missing methods.
239
240 If C<Animal> also had an C<@ISA>, then we'd check there too.  The
241 search is recursive, depth-first, left-to-right in each C<@ISA>.
242 Typically, each C<@ISA> has only one element (multiple elements means
243 multiple inheritance and multiple headaches), so we get a nice tree of
244 inheritance.
245
246 When we turn on C<use strict>, we'll get complaints on C<@ISA>, since
247 it's not a variable containing an explicit package name, nor is it a
248 lexical ("my") variable.  We can't make it a lexical variable though,
249 so there's a couple of straightforward ways to handle that.
250
251 The easiest is to just spell the package name out:
252
253     @Cow::ISA = qw(Animal);
254
255 Or allow it as an implictly named package variable:
256
257     package Cow;
258     use vars qw(@ISA);
259     @ISA = qw(Animal);
260
261 If you're bringing in the class from outside, via an object-oriented
262 module, you change:
263
264     package Cow;
265     use Animal;
266     use vars qw(@ISA);
267     @ISA = qw(Animal);
268
269 into just:
270
271     package Cow;
272     use base qw(Animal);
273
274 And that's pretty darn compact.
275
276 =head2 Overriding the methods
277
278 Let's add a mouse, which can barely be heard:
279
280     # Animal package from before
281     { package Mouse;
282       @ISA = qw(Animal);
283       sub sound { "squeak" }
284       sub speak {
285         my $class = shift;
286         print "a $class goes ", $class->sound, "!\n";
287         print "[but you can barely hear it!]\n";
288       }
289     }
290
291     Mouse->speak;
292
293 which results in:
294
295     a Mouse goes squeak!
296     [but you can barely hear it!]
297
298 Here, C<Mouse> has its own speaking routine, so C<< Mouse->speak >>
299 doesn't immediately invoke C<< Animal->speak >>.  This is known as
300 "overriding".  In fact, we didn't even need to say that a C<Mouse> was
301 an C<Animal> at all, since all of the methods needed for C<speak> are
302 completely defined with C<Mouse>.
303
304 But we've now duplicated some of the code from C<< Animal->speak >>,
305 and this can once again be a maintenance headache.  So, can we avoid
306 that?  Can we say somehow that a C<Mouse> does everything any other
307 C<Animal> does, but add in the extra comment?  Sure!
308
309 First, we can invoke the C<Animal::speak> method directly:
310
311     # Animal package from before
312     { package Mouse;
313       @ISA = qw(Animal);
314       sub sound { "squeak" }
315       sub speak {
316         my $class = shift;
317         Animal::speak($class);
318         print "[but you can barely hear it!]\n";
319       }
320     }
321
322 Note that we have to include the C<$class> parameter (almost surely
323 the value of C<"Mouse">) as the first parameter to C<Animal::speak>,
324 since we've stopped using the method arrow.  Why did we stop?  Well,
325 if we invoke C<< Animal->speak >> there, the first parameter to the
326 method will be C<"Animal"> not C<"Mouse">, and when time comes for it
327 to call for the C<sound>, it won't have the right class to come back
328 to this package.
329
330 Invoking C<Animal::speak> directly is a mess, however.  What if
331 C<Animal::speak> didn't exist before, and was being inherited from a
332 class mentioned in C<@Animal::ISA>?  Because we are no longer using
333 the method arrow, we get one and only one chance to hit the right
334 subroutine.
335
336 Also note that the C<Animal> classname is now hardwired into the
337 subroutine selection.  This is a mess if someone maintains the code,
338 changing C<@ISA> for <Mouse> and didn't notice C<Animal> there in
339 C<speak>.  So, this is probably not the right way to go.
340
341 =head2 Starting the search from a different place
342
343 A better solution is to tell Perl to search from a higher place
344 in the inheritance chain:
345
346     # same Animal as before
347     { package Mouse;
348       # same @ISA, &sound as before
349       sub speak {
350         my $class = shift;
351         $class->Animal::speak;
352         print "[but you can barely hear it!]\n";
353       }
354     }
355
356 Ahh.  This works.  Using this syntax, we start with C<Animal> to find
357 C<speak>, and use all of C<Animal>'s inheritance chain if not found
358 immediately.  And yet the first parameter will be C<$class>, so the
359 found C<speak> method will get C<Mouse> as its first entry, and
360 eventually work its way back to C<Mouse::sound> for the details.
361
362 But this isn't the best solution.  We still have to keep the C<@ISA>
363 and the initial search package coordinated.  Worse, if C<Mouse> had
364 multiple entries in C<@ISA>, we wouldn't necessarily know which one
365 had actually defined C<speak>.  So, is there an even better way?
366
367 =head2 The SUPER way of doing things
368
369 By changing the C<Animal> class to the C<SUPER> class in that
370 invocation, we get a search of all of our super classes (classes
371 listed in C<@ISA>) automatically:
372
373     # same Animal as before
374     { package Mouse;
375       # same @ISA, &sound as before
376       sub speak {
377         my $class = shift;
378         $class->SUPER::speak;
379         print "[but you can barely hear it!]\n";
380       }
381     }
382
383 So, C<SUPER::speak> means look in the current package's C<@ISA> for
384 C<speak>, invoking the first one found.
385
386 =head2 Where we're at so far...
387
388 So far, we've seen the method arrow syntax:
389
390   Class->method(@args);
391
392 or the equivalent:
393
394   $a = "Class";
395   $a->method(@args);
396
397 which constructs an argument list of:
398
399   ("Class", @args)
400
401 and attempts to invoke
402
403   Class::method("Class", @Args);
404
405 However, if C<Class::method> is not found, then C<@Class::ISA> is examined
406 (recursively) to locate a package that does indeed contain C<method>,
407 and that subroutine is invoked instead.
408
409 Using this simple syntax, we have class methods, (multiple)
410 inheritance, overriding, and extending.  Using just what we've seen so
411 far, we've been able to factor out common code, and provide a nice way
412 to reuse implementations with variations.  This is at the core of what
413 objects provide, but objects also provide instance data, which we
414 haven't even begun to cover.
415
416 =head2 A horse is a horse, of course of course -- or is it?
417
418 Let's start with the code for the C<Animal> class
419 and the C<Horse> class:
420
421   { package Animal;
422     sub speak {
423       my $class = shift;
424       print "a $class goes ", $class->sound, "!\n"
425     }
426   }
427   { package Horse;
428     @ISA = qw(Animal);
429     sub sound { "neigh" }
430   }
431
432 This lets us invoke C<< Horse->speak >> to ripple upward to
433 C<Animal::speak>, calling back to C<Horse::sound> to get the specific
434 sound, and the output of:
435
436   a Horse goes neigh!
437
438 But all of our Horse objects would have to be absolutely identical.
439 If I add a subroutine, all horses automatically share it.  That's
440 great for making horses the same, but how do we capture the
441 distinctions about an individual horse?  For example, suppose I want
442 to give my first horse a name.  There's got to be a way to keep its
443 name separate from the other horses.
444
445 We can do that by drawing a new distinction, called an "instance".
446 An "instance" is generally created by a class.  In Perl, any reference
447 can be an instance, so let's start with the simplest reference
448 that can hold a horse's name: a scalar reference.
449
450   my $name = "Mr. Ed";
451   my $talking = \$name;
452
453 So now C<$talking> is a reference to what will be the instance-specific
454 data (the name).  The final step in turning this into a real instance
455 is with a special operator called C<bless>:
456
457   bless $talking, Horse;
458
459 This operator stores information about the package named C<Horse> into
460 the thing pointed at by the reference.  At this point, we say
461 C<$talking> is an instance of C<Horse>.  That is, it's a specific
462 horse.  The reference is otherwise unchanged, and can still be used
463 with traditional dereferencing operators.
464
465 =head2 Invoking an instance method
466
467 The method arrow can be used on instances, as well as names of
468 packages (classes).  So, let's get the sound that C<$talking> makes:
469
470   my $noise = $talking->sound;
471
472 To invoke C<sound>, Perl first notes that C<$talking> is a blessed
473 reference (and thus an instance).  It then constructs an argument
474 list, in this case from just C<($talking)>.  (Later we'll see that
475 arguments will take their place following the instance variable,
476 just like with classes.)
477
478 Now for the fun part: Perl takes the class in which the instance was
479 blessed, in this case C<Horse>, and uses that to locate the subroutine
480 to invoke the method.  In this case, C<Horse::sound> is found directly
481 (without using inheritance), yielding the final subroutine invocation:
482
483   Horse::sound($talking)
484
485 Note that the first parameter here is still the instance, not the name
486 of the class as before.  We'll get C<neigh> as the return value, and
487 that'll end up as the C<$noise> variable above.
488
489 If Horse::sound had not been found, we'd be wandering up the
490 C<@Horse::ISA> list to try to find the method in one of the
491 superclasses, just as for a class method.  The only difference between
492 a class method and an instance method is whether the first parameter
493 is a instance (a blessed reference) or a class name (a string).
494
495 =head2 Accessing the instance data
496
497 Because we get the instance as the first parameter, we can now access
498 the instance-specific data.  In this case, let's add a way to get at
499 the name:
500
501   { package Horse;
502     @ISA = qw(Animal);
503     sub sound { "neigh" }
504     sub name {
505       my $self = shift;
506       $$self;
507     }
508   }
509
510 Now we call for the name:
511
512   print $talking->name, " says ", $talking->sound, "\n";
513
514 Inside C<Horse::name>, the C<@_> array contains just C<$talking>,
515 which the C<shift> stores into C<$self>.  (It's traditional to shift
516 the first parameter off into a variable named C<$self> for instance
517 methods, so stay with that unless you have strong reasons otherwise.)
518 Then, C<$self> gets de-referenced as a scalar ref, yielding C<Mr. Ed>,
519 and we're done with that.  The result is:
520
521   Mr. Ed says neigh.
522
523 =head2 How to build a horse
524
525 Of course, if we constructed all of our horses by hand, we'd most
526 likely make mistakes from time to time.  We're also violating one of
527 the properties of object-oriented programming, in that the "inside
528 guts" of a Horse are visible.  That's good if you're a veterinarian,
529 but not if you just like to own horses.  So, let's let the Horse class
530 build a new horse:
531
532   { package Horse;
533     @ISA = qw(Animal);
534     sub sound { "neigh" }
535     sub name {
536       my $self = shift;
537       $$self;
538     }
539     sub named {
540       my $class = shift;
541       my $name = shift;
542       bless \$name, $class;
543     }
544   }
545
546 Now with the new C<named> method, we can build a horse:
547
548   my $talking = Horse->named("Mr. Ed");
549
550 Notice we're back to a class method, so the two arguments to
551 C<Horse::named> are C<Horse> and C<Mr. Ed>.  The C<bless> operator
552 not only blesses C<$name>, it also returns the reference to C<$name>,
553 so that's fine as a return value.  And that's how to build a horse.
554
555 =head2 Inheriting the constructor
556
557 But was there anything specific to C<Horse> in that method?  No.  Therefore,
558 it's also the same recipe for building anything else that inherited from
559 C<Animal>, so let's put it there:
560
561   { package Animal;
562     sub speak {
563       my $class = shift;
564       print "a $class goes ", $class->sound, "!\n"
565     }
566     sub name {
567       my $self = shift;
568       $$self;
569     }
570     sub named {
571       my $class = shift;
572       my $name = shift;
573       bless \$name, $class;
574     }
575   }
576   { package Horse;
577     @ISA = qw(Animal);
578     sub sound { "neigh" }
579   }
580
581 Ahh, but what happens if we invoke C<speak> on an instance?
582
583   my $talking = Horse->named("Mr. Ed");
584   $talking->speak;
585
586 We get a debugging value:
587
588   a Horse=SCALAR(0xaca42ac) goes neigh!
589
590 Why?  Because the C<Animal::speak> routine is expecting a classname as
591 its first parameter, not an instance.  When the instance is passed in,
592 we'll end up using a blessed scalar reference as a string, and that
593 shows up as we saw it just now.
594
595 =head2 Making a method work with either classes or instances
596
597 All we need is for a method to detect if it is being called on a class
598 or called on an instance.  The most straightforward way is with the
599 C<ref> operator.  This returns a string (the classname) when used on a
600 blessed reference, and C<undef> when used on a string (like a
601 classname).  Let's modify the C<name> method first to notice the change:
602
603   sub name {
604     my $either = shift;
605     ref $either
606       ? $$either # it's an instance, return name
607       : "an unnamed $either"; # it's a class, return generic
608   }
609
610 Here, the C<?:> operator comes in handy to select either the
611 dereference or a derived string.  Now we can use this with either an
612 instance or a class.  Note that I've changed the first parameter
613 holder to C<$either> to show that this is intended:
614
615   my $talking = Horse->named("Mr. Ed");
616   print Horse->name, "\n"; # prints "an unnamed Horse\n"
617   print $talking->name, "\n"; # prints "Mr Ed.\n"
618
619 and now we'll fix C<speak> to use this:
620
621   sub speak {
622     my $either = shift;
623     print $either->name, " goes ", $either->sound, "\n";
624   }
625
626 And since C<sound> already worked with either a class or an instance,
627 we're done!
628
629 =head2 Adding parameters to a method
630
631 Let's train our animals to eat:
632
633   { package Animal;
634     sub named {
635       my $class = shift;
636       my $name = shift;
637       bless \$name, $class;
638     }
639     sub name {
640       my $either = shift;
641       ref $either
642         ? $$either # it's an instance, return name
643         : "an unnamed $either"; # it's a class, return generic
644     }
645     sub speak {
646       my $either = shift;
647       print $either->name, " goes ", $either->sound, "\n";
648     }
649     sub eat {
650       my $either = shift;
651       my $food = shift;
652       print $either->name, " eats $food.\n";
653     }
654   }
655   { package Horse;
656     @ISA = qw(Animal);
657     sub sound { "neigh" }
658   }
659   { package Sheep;
660     @ISA = qw(Animal);
661     sub sound { "baaaah" }
662   }
663
664 And now try it out:
665
666   my $talking = Horse->named("Mr. Ed");
667   $talking->eat("hay");
668   Sheep->eat("grass");
669
670 which prints:
671
672   Mr. Ed eats hay.
673   an unnamed Sheep eats grass.
674
675 An instance method with parameters gets invoked with the instance,
676 and then the list of parameters.  So that first invocation is like:
677
678   Animal::eat($talking, "hay");
679
680 =head2 More interesting instances
681
682 What if an instance needs more data?  Most interesting instances are
683 made of many items, each of which can in turn be a reference or even
684 another object.  The easiest way to store these is often in a hash.
685 The keys of the hash serve as the names of parts of the object (often
686 called "instance variables" or "member variables"), and the
687 corresponding values are, well, the values.
688
689 But how do we turn the horse into a hash?  Recall that an object was
690 any blessed reference.  We can just as easily make it a blessed hash
691 reference as a blessed scalar reference, as long as everything that
692 looks at the reference is changed accordingly.
693
694 Let's make a sheep that has a name and a color:
695
696   my $bad = bless { Name => "Evil", Color => "black" }, Sheep;
697
698 so C<< $bad->{Name} >> has C<Evil>, and C<< $bad->{Color} >> has
699 C<black>.  But we want to make C<< $bad->name >> access the name, and
700 that's now messed up because it's expecting a scalar reference.  Not
701 to worry, because that's pretty easy to fix up:
702
703   ## in Animal
704   sub name {
705     my $either = shift;
706     ref $either ?
707       $either->{Name} :
708       "an unnamed $either";
709   }
710
711 And of course C<named> still builds a scalar sheep, so let's fix that
712 as well:
713
714   ## in Animal
715   sub named {
716     my $class = shift;
717     my $name = shift;
718     my $self = { Name => $name, Color => $class->default_color };
719     bless $self, $class;
720   }
721
722 What's this C<default_color>?  Well, if C<named> has only the name,
723 we still need to set a color, so we'll have a class-specific initial color.
724 For a sheep, we might define it as white:
725
726   ## in Sheep
727   sub default_color { "white" }
728
729 And then to keep from having to define one for each additional class,
730 we'll define a "backstop" method that serves as the "default default",
731 directly in C<Animal>:
732
733   ## in Animal
734   sub default_color { "brown" }
735
736 Now, because C<name> and C<named> were the only methods that
737 referenced the "structure" of the object, the rest of the methods can
738 remain the same, so C<speak> still works as before.
739
740 =head2 A horse of a different color
741
742 But having all our horses be brown would be boring.  So let's add a
743 method or two to get and set the color.
744
745   ## in Animal
746   sub color {
747     $_[0]->{Color}
748   }
749   sub set_color {
750     $_[0]->{Color} = $_[1];
751   }
752
753 Note the alternate way of accessing the arguments: C<$_[0]> is used
754 in-place, rather than with a C<shift>.  (This saves us a bit of time
755 for something that may be invoked frequently.)  And now we can fix
756 that color for Mr. Ed:
757
758   my $talking = Horse->named("Mr. Ed");
759   $talking->set_color("black-and-white");
760   print $talking->name, " is colored ", $talking->color, "\n";
761
762 which results in:
763
764   Mr. Ed is colored black-and-white
765
766 =head2 Summary
767
768 So, now we have class methods, constructors, instance methods,
769 instance data, and even accessors.  But that's still just the
770 beginning of what Perl has to offer.  We haven't even begun to talk
771 about accessors that double as getters and setters, destructors,
772 indirect object notation, subclasses that add instance data, per-class
773 data, overloading, "isa" and "can" tests, C<UNIVERSAL> class, and so
774 on.  That's for the rest of the Perl documentation to cover.
775 Hopefully, this gets you started, though.
776
777 =head1 SEE ALSO
778
779 For more information, see L<perlobj> (for all the gritty details about
780 Perl objects, now that you've seen the basics), L<perltoot> (the
781 tutorial for those who already know objects), L<perlbot> (for some
782 more tricks), and books such as Damian Conway's excellent I<Object
783 Oriented Perl>.
784
785 =head1 COPYRIGHT
786
787 Copyright (c) 1999, 2000 by Randal L. Schwartz and Stonehenge
788 Consulting Services, Inc.  Permission is hereby granted to distribute
789 this document intact with the Perl distribution, and in accordance
790 with the licenses of the Perl distribution; derived documents must
791 include this copyright notice intact.
792
793 Portions of this text have been derived from Perl Training materials
794 originally appearing in the I<Packages, References, Objects, and
795 Modules> course taught by instructors for Stonehenge Consulting
796 Services, Inc. and used with permission.
797
798 Portions of this text have been derived from materials originally
799 appearing in I<Linux Magazine> and used with permission.