Classes as Packages, Objects as Blessed References
Classic Perl OO has no dedicated 'class' keyword before Perl 5.38 — instead, a class is a package, and an object is a reference (usually to a hash) that has been 'bless'-ed into that package. The bless() function takes a reference and a package name and stores that package name inside the reference's internal structure, so 'ref($obj)' returns the class name and method calls via the arrow operator '$obj->method()' know which package's symbol table to search for 'method'. A typical constructor is a subroutine named 'new' that creates an empty hashref, blesses it, and returns it: 'sub new { my $class = shift; my $self = {}; bless $self, $class; return $self; }' — nothing about the name 'new' is magic, it's just the community convention.
Cricket analogy: A cricketer only officially becomes 'Team India' on paper once the BCCI selection committee formally attaches that designation to their name, exactly like bless() attaching a package name to a reference to make it recognized as that class.
package Animal;
sub new {
my ($class, %args) = @_;
my $self = { name => $args{name} || 'Unnamed' };
return bless $self, $class;
}
sub speak {
my $self = shift;
return $self->{name} . " makes a sound.";
}
package Dog;
our @ISA = ('Animal'); # Dog inherits from Animal
sub speak {
my $self = shift;
return $self->{name} . " barks.";
}
package main;
my $generic = Animal->new(name => 'Creature');
my $rex = Dog->new(name => 'Rex');
print $generic->speak, "\n"; # Creature makes a sound.
print $rex->speak, "\n"; # Rex barks.Inheritance, Method Resolution, and SUPER::
When you call '$rex->speak', Perl checks package Dog for a 'speak' subroutine first; since Dog defines its own, that override runs instead of Animal's. If Dog had no 'speak' of its own, Perl would walk '@ISA' to find and run 'Animal::speak' instead — this walk is called method resolution order (MRO). To call a parent's version of an overridden method from inside the child (common when you want to extend rather than fully replace behavior), you use the special 'SUPER::' pseudo-package: 'sub speak { my $self = shift; my $base = $self->SUPER::speak(); return $base . " Specifically, it barks."; }' explicitly dispatches to the parent class's method regardless of what @ISA currently contains at that call site.
Cricket analogy: A domestic player called up to the national side keeps their state-team batting technique unless the national coach specifically overrides it with new instruction, mirroring how Dog::speak overrides Animal::speak only where Dog defines its own version.
Accessors, Encapsulation, and Moo/Moose
Because a blessed hashref's keys are directly accessible as '$self->{name}', classic Perl OO has no built-in privacy enforcement — anyone with the object reference can reach in and mutate '$obj->{name}' directly, bypassing any validation an accessor method would normally provide. The idiomatic fix is to write accessor methods like 'sub name { my $self = shift; if (@_) { $self->{name} = shift } return $self->{name}; }' and treat direct hash-key access as an internal implementation detail, though nothing in the language enforces that discipline. Modern code sidesteps writing this boilerplate by using Moo or Moose, which generate accessors, constructors, and type-checked attributes declaratively: 'has name => (is => "rw", isa => "Str", required => 1);' replaces dozens of lines of hand-written bless/accessor code with one declarative line.
Cricket analogy: A dressing room with no locker doors means any player can rummage through a teammate's kit bag directly, just as a blessed hashref with no accessor methods lets any caller reach in and mutate $obj->{name} directly.
Moo is a lightweight, faster-loading alternative to Moose with a nearly identical 'has' attribute syntax for the common cases; reach for Moose specifically when you need its richer meta-object protocol, type constraint system, or role composition features that Moo intentionally omits for speed.
Roles vs. Inheritance
Deep inheritance hierarchies in Perl OO often become brittle as behavior gets scattered across many ancestor classes, which is why Moose and Moo both support roles via 'with "SomeRole";' — a role is a bundle of methods and required-method contracts that gets composed flatly into a consuming class at compile time, rather than being layered on through @ISA. Unlike inheritance, a class can consume multiple roles without the diamond-inheritance ambiguity that multiple @ISA parents create, because role composition either succeeds cleanly or fails loudly at compile time if two roles define conflicting methods the consuming class doesn't resolve. A common pattern is 'package Logger; use Moose::Role; requires "log_prefix"; sub log { my $self = shift; print $self->log_prefix, ": ", @_, "\n"; }' which any class can consume as long as it separately implements 'log_prefix'.
Cricket analogy: A player being certified as both a 'wicketkeeper' and a 'left-arm spinner' through two separate specialist certifications, composed together into one player profile, mirrors a class consuming two Moose roles without the ambiguity of multiple @ISA parents.
Perl 5.38 introduced native 'use feature "class";' syntax (class, field, method keywords) as an experimental core alternative to Moose/Moo. As of Perl 5.40 it remains marked experimental and lacks some Moose features like roles and type constraints, so most production codebases in 2026 still rely on Moose or Moo for anything beyond the simplest classes.
- A Perl class is a package; an object is a reference blessed into that package via bless().
- Method calls ($obj->method) search the object's package first, then walk @ISA for inherited methods.
- SUPER::method() explicitly dispatches to a parent class's implementation from inside an override.
- Classic Perl OO has no enforced encapsulation — accessor methods are convention, not language enforcement.
- Moo and Moose replace hand-written bless/accessor boilerplate with declarative 'has' attributes.
- Roles (via 'with') compose behavior flatly across classes, avoiding diamond-inheritance ambiguity.
- Perl 5.38+'s native 'class' feature exists but remains experimental and less feature-complete than Moose as of 2026.
Practice what you learned
1. What makes an ordinary Perl reference into an 'object' in classic Perl OO?
2. What does 'SUPER::method()' do inside an overriding method?
3. How does classic Perl OO enforce private/protected attributes?
4. What problem do roles (via Moose/Moo's 'with') solve that plain @ISA inheritance struggles with?
5. As of Perl 5.40 in 2026, what is the status of the native 'use feature "class";' syntax?
Was this page helpful?
You May Also Like
Packages and Namespaces
Understand how Perl's 'package' keyword partitions global symbol tables to avoid naming collisions and how namespaces underpin every module and class.
Exception Handling in Perl
Learn how Perl handles errors through die/eval, the modern try/catch feature, and object-based exceptions using Try::Tiny or custom exception classes.
Writing Your Own Module
Build, structure, document, test, and package a distributable Perl module from scratch, from the initial .pm file to a CPAN-ready distribution.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics