Object-Oriented Perl

Introduction

Perl's object-oriented programming (OOP) system looks different from what you might have seen in languages like Java or Python, because Perl builds OOP out of simpler pieces you already know: packages, references, and hashes. Understanding these building blocks demystifies Perl OOP and makes even modern, higher-level tools like Moo and Moose easier to understand later.

Packages as Classes

In Perl, a package is simply a named namespace for variables and subroutines. Classic Perl OOP uses a package as a class: the package name becomes the class name, and subroutines defined within it become that class's methods.

package Dog;
use strict;
use warnings;

sub bark {
    print "Woof!\n";
}

1;

On its own, this is just a namespace with one subroutine in it — nothing object-oriented is happening yet. What turns a plain data structure into an "object" of this class is the bless function.

The bless Function

bless takes a reference (almost always a hash reference, used to store the object's data) and associates it with a package name, turning it into an "object" of that class. From that point on, Perl knows which package to look in when you call a method on that reference.

package Dog;
use strict;
use warnings;

sub bark {
    my ($self) = @_;
    print "$self->{name} says Woof!\n";
}

1;

# File: main.pl
use strict;
use warnings;
use Dog;

my $data = { name => 'Rex' };
my $rex = bless($data, 'Dog');

$rex->bark();
print ref($rex), "\n";

ref($rex) now returns "Dog" instead of "HASH", because bless has tagged this reference as belonging to the Dog class. This is exactly what lets $rex->bark() know to look for the bark subroutine inside the Dog package.

Writing a Constructor

Perl has no dedicated constructor syntax — by convention, classes define a subroutine named new that creates the underlying hash reference, blesses it, and returns it. This convention is followed so consistently across the Perl ecosystem that it is effectively a rule.

package Dog;
use strict;
use warnings;

sub new {
    my ($class, %args) = @_;

    my $self = {
        name => $args{name} // 'Unnamed',
        breed => $args{breed} // 'Unknown',
    };

    return bless($self, $class);
}

sub bark {
    my ($self) = @_;
    print "$self->{name} the $self->{breed} says Woof!\n";
}

1;

# File: main.pl
use strict;
use warnings;
use Dog;

my $rex = Dog->new(name => 'Rex', breed => 'Labrador');
$rex->bark();

Defining Methods

A method is just a regular subroutine defined inside the class's package, with one convention: the first argument it receives is always the object (or the class name, for a constructor) it was called on. By convention, this first argument is unpacked into a variable named $self.

package Dog;
use strict;
use warnings;

sub new {
    my ($class, %args) = @_;
    my $self = { name => $args{name} // 'Unnamed', energy => 100 };
    return bless($self, $class);
}

sub bark {
    my ($self) = @_;
    $self->{energy} -= 5;
    print "$self->{name} barks! (energy: $self->{energy})\n";
}

sub rest {
    my ($self) = @_;
    $self->{energy} += 20;
    print "$self->{name} rests. (energy: $self->{energy})\n";
}

1;

use strict;
use warnings;
use Dog;

my $rex = Dog->new(name => 'Rex');
$rex->bark();
$rex->bark();
$rex->rest();

Calling Methods With ->

The arrow operator (->) is used to call a method on an object, exactly the same arrow used earlier to dereference hash and array references. Perl uses the object's blessed class to look up which package's subroutine to run, automatically passing the object itself as the first argument.

use strict;
use warnings;
use Dog;

my $rex = Dog->new(name => 'Rex');

# These two calls are equivalent:
$rex->bark();
Dog::bark($rex);

Inheritance Basics

A class can inherit methods from another class using the parent pragma (or the older use base). If a subclass does not define its own version of a method, Perl automatically looks it up in the parent class instead.

package Animal;
use strict;
use warnings;

sub new {
    my ($class, %args) = @_;
    my $self = { name => $args{name} // 'Unnamed' };
    return bless($self, $class);
}

sub speak {
    my ($self) = @_;
    print "$self->{name} makes a sound.\n";
}

1;

package Cat;
use strict;
use warnings;
use parent -norequire, 'Animal';

sub speak {
    my ($self) = @_;
    print "$self->{name} says Meow!\n";
}

1;

use strict;
use warnings;
use Animal;
use Cat;

my $generic = Animal->new(name => 'Generic Animal');
my $cat = Cat->new(name => 'Whiskers');

$generic->speak();
$cat->speak();

Cat inherits the new constructor directly from Animal (it does not redefine it), but overrides speak with its own version. This is the classic OOP concept of method overriding, implemented here with nothing more exotic than packages, bless, and inheritance via parent.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Object-oriented Perl builds classes and objects out of the same fundamentals you already know — packages, references, and hashes — wrapped up with the bless function. With this foundation in place, you are ready to make your programs more robust by handling things that can go wrong, which is exactly what the next lesson on error handling with eval and die covers.