You can use Class::MOP or it's offspring Moose to do this.

First the Class::MOP version ...

package TestPackage;
use metaclass; # this sets up your class to use Class::MOP
use Data::Dump qw( dump );

my $obj = bless {}, __PACKAGE__;

print 'Can dump()' if $obj->meta->has_method('dump');
[download]

my @methods = $obj->meta->get_method_list;
[download]

my @methods = $obj->meta->compute_all_applicable_methods;
[download]

Now, you could also use Moose and Moose::Role to do similar things. Moose is basically syntactic sugar over the mechanisms that Class::MOP provides, so all the above examples apply here as well. With roles** and Moose::Role you can do the interface checking you are talking about. Here is an example:

package MyFooInterface;
use Moose::Role;
requires 'bar';
[download]

package MyFoo;
use Moose;
with 'MyFooInterface';
sub bar { ... } 
# the bar method is required, the 
# class will fail to compile if it is 
# not present
[download]

my $foo = MyFoo->new;
if ($foo->does('MyFooInterface')) { ... }
[download]

• An excellent Intro to Moose (20 min talk)
• A slightly more involved into to Moose (50 min talk)
• A quick Role talk (20 min)

Footnotes:
* Locally defined methods are those defined directly in your class, and not inherited.
** If you don't already know, a role is not unlike a mixin or the traits mentioned above, but with a little bit more of a Perl-ish twist. They are a core part of Perl 6 in fact.

On the subject of Moose, I have a question ... Is multiple inheritance possible using Moose?
I have tried some simple examples such as this:

package Animal;
use Moose;
sub speak {
    my $self = shift;
    print 'A ', ref $self, ' goes ', $self->sound() . "\n";
}
1;

package Danger;
use Moose;
sub speak {
    my $self = shift;
    print 'through an eye patch ...' . "\n";
}
1;

package Mouse;
use Moose;
extends qw(Animal Danger);
has 'sound' => (is => 'rw', default => 'squeek');
after 'speak' => sub {
    my $self = shift;
    print '[but you can barely hear it!]' . "\n";
};
1;

package main;
my $danger_mouse = Mouse->new();
$danger_mouse->speak();
1;
[download]

The output I get is:

A Mouse goes squeek
[but you can barely hear it!]
[download]

If I used Class::Std to implement this (using CUMULATIVE(BASE FIRST)) like so:

package Animal;
use Class::Std;
{
    sub speak : CUMULATIVE(BASE FIRST) {
        my $self = shift;
        print 'A ', ref $self, ' goes ', $self->get_sound() . "\n";
    }
}
1;

package Danger;
use Class::Std;
{
    sub speak : CUMULATIVE(BASE FIRST) {
        my $self = shift;
        print 'through an eye patch ...' . "\n";
    }
}
1;

package Mouse;
use Class::Std;
use base qw(Animal Danger);
{
    my %sound : ATTR( :name<sound>, :default<squeek> );
    sub speak : CUMULATIVE(BASE FIRST) {
        my $self = shift;
        print '[but you can barely hear it!]' . "\n";
    }
}
1;
[download]

I get the output I expect:

A Mouse goes squeek
through an eye patch ...
[but you can barely hear it!]
[download]

Is there a way to achieve similar results with Moose? I would just like to know.
Thanks in advance =)
UPDATE
I knew I should have finished reading that post first =(
This is achievable with Moose::Roles ... and a little thought. Like so:

package Animal;
use Moose;
sub speak {
    my $self = shift;
    print 'A ', ref $self, ' goes ', $self->sound() . "\n";
}
1;

package Danger;
use Moose::Role;
requires 'speak';
after 'speak' => sub {
    my $self = shift;
    print 'through an eye patch ...' . "\n";
};
1;

package Mouse;
use Moose;
extends 'Animal';
with    'Danger';
has 'sound' => (is => 'rw', default => 'squeek');
after 'speak' => sub {
    my $self = shift;
    print '[but you can barely hear it!]' . "\n";
};
1;


package main;
my $danger_mouse = Mouse->new();
$danger_mouse->speak();
1;
[download]

This gives the same output as the Class::Std version. My apologies all for jumping the gun.

---

Smoothie, smoothie, hundre prosent naturlig!

There are two important things to note about the Moose solution, which make it superior to the Class::Std solution.

1. A Mouse is not a Danger

Inheritance is an "is-a" relationship, and the Class::Std version incorrectly models the Mouse's relationship with Danger. The Moose version states that a Mouse "does" Danger, which still doesn't read quite right, but Danger is clearly more of a Trait of this particular Mouse, and not something that the Mouse "is".

2. The CUMULATIVE(BASE FIRST) approach lacks a degree of control

Because CUMULATIVE(BASE FIRST) determines the order in which your methods are called, you are limited to how much control you can have. Using the Moose modifiers before/after/around you have a great degree of control over when and how your methods get called. Moose also provides augment/inner which only works with classes (it makes no sense for roles), but also provides a more flexible and powerful means of controlling dispatch. See the Moose::Cookbook::Recipe7 for a good example of this.

It should also be noted (with all due respect to TheDamian) that that Class::Std has 56 outstanding Bugs some over 2 years old and many which are quite serious. It also seems to be no longer maintained (last upload was Feb. 2006). In contrast, Moose is very actively developed by a handful of developers and is being used heavily in several large production sites so bugs tend to get fixed rather quickly.
-stvn

Actually, Perl is correct. $obj->dump() would "work" in your case. There is no difference between a subroutine in a package and a method of an object blessed into said package, at least as far as Perl is concerned. The arrow-call syntax $obj->method(@args) is little more than syntactic sugar around TestPackage::method($obj, @args).

There is no real concept of an interface in Perl other than the documentation of methods of a class/package.

Is there any other way to find out which methods an object implements, i.e. it's interface?

Since there's no notion of 'interface' in perl, you would need to implement a method $obj->interface,or some such, in a class. Walking the symbol table doesn't lead to reliable results either, since inspecting the CODE slots of typeglobs doesn't tell you which package those code refs were compiled into. See What CODE typeglob slot is my anonymous sub in? for details. (There's not much difference between anonymous coderefs and those stored in a glob besides the fact that the latter are stored in a typeglob slot.)

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Hope this helps!