7.4 Object Syntax

Perl uses two forms of syntax for invoking methods on objects. For both types of syntax, the object reference or class name is given as the first argument. A method that takes a class name is called a class method , and one that takes an object reference is called an instance method .

Class methods provide functionality for the entire class, not just for a single object that belongs to the class. Class methods expect a class name as their first argument. Following this explanation, a constructor is an example of a class method:

sub new {
   my $self = {};
   bless $self;
   return $self;
}

On the other hand, an instance method expects an object reference as its first argument. An instance method will shift the first argument and use this argument as a reference:

sub instance_method {
   my $self = shift;
   my($one, $two, $three) = @_;
   # do stuff
}

Here is an example of a constructor creating a new object and returning a reference:

$tri = new Triangle::Right (side1 => 3, side2 => 4);

This example creates a new right-triangle object and references it with $tri . The parameters are given as a hash-style list. This is common for constructors, as they set initial parameters for an object that is probably just a hash. Now that we have an object, we can invoke some method on it. Suppose Triangle::Right defines a method, hypot , that returns the length of the hypotenuse for a given right-triangle object. It would be used like this:

$h = hypot $tri;
print "The hypotenuse is: $h.\n";

In this particular example, there happens to be no additional arguments to the hypot method, but there could have been.

With the arrow ( -> ) notation, the left side of the arrow must be an object reference or a class name, while the right side of the arrow must be a method defined for that object. Any arguments must follow the method inside of parentheses. For example:

$obj->method(
args
)
CLASS->method(
args
)

You have to use parentheses because this form can't be used as a list operator, although the first type of method syntax can.

The examples given above would look like this using the arrow syntax:

$tri = Triangle::Right->new(side1 => 3, side2 => 4);
$h = $tri->hypot();
print "The hypotenuse is: $h.\n";

The arrow syntax provides a helpful visual relationship between the object and its method, but both forms of syntax do the same thing. Precedence for the arrow syntax is left to right, exactly the same as the dereferencing operator. This allows you to chain together objects and methods if you want to simplify things. You just have to make sure you have an object to the left of the arrow and a method to the right:

%sides = (side1 => 3, side2 => 4);
$h = Triangle::Right->new(%sides)->hypot();
print "The hypotenuse is: $h.\n";

In this example, you never assign a variable name to the right-triangle object; the reference is passed directly to the hypot method.