package A;
sub new { bless {}, shift }
sub x { "A::x"; }
package B;
our @ISA="A";
package C;
our @ISA='A';
sub x{ shift->SUPER::x . " C::x" }
package main;
print A->new->x, "\n";
print B->new->x, "\n";
print C->new->x, "\n";
[download]

package A;

sub foo { print "this is from class A\n"; }

package B;
use base 'A';

sub foo { print "this is from class B\n"; }
sub bar { print "this is from class B, too\n"; }

package C;
use base 'A';

sub bar { print "Finally, this is from class C.\n"; }
[download]

In this example, package C inherits the foo method from package A, because it is declared a subclass with use base and does not define its own method foo. Package B, on the other hand, defines its own foo method, which overrides the parent class.

See perlboot and perltoot for more information about doing OOP in Perl.

In a class inheriting from class A, any method you declare will replace class A's method of the same name in your new class, so your class B's 123 need do nothing special. In class C, you can access the superclass's method using the special pseudo-package SUPER:::

  package C;
  our @ISA = qw/ A /;
  sub 123 {
    my $self = shift;
    # let my superclass do its thing first
    my $result = $self->SUPER::123(@_);
    # now I'll do a bit
    ...
  }
[download]

Note that occasionally you may need to be careful to propagate your caller's context to the SUPER:: call, if the supermethod acts differently depending on it. Eg:

  sub 123 {
    my $self = shift;
    my(@array, $scalar);
    if (wantarray) {
      @array = $self->SUPER::123(@_);
    } elsif (defined wantarray) {
      $scalar = $self->SUPER::123(@_);
    } else {
      $self->SUPER::123(@_);
    }
    # do more stuff
    return wantarray ? @array : $scalar;
  }
[download]

For more complex class hierarchies, or if generating class methods at runtime, you may find the specific semantics of SUPER:: insufficient. If so, you may also want to look at the NEXT module.

Hugo