面向对象的概念在Perl中是如何工作的

我正在读一本关于perl的书，到目前为止，我理解OOP的概念，直到遇到以下代码：

sub new {
    my $invocant = shift;
    my $class   = ref($invocant) || $invocant;
    my $self = {
        color  => "bay",
        legs   => 4,
        owner  => undef,
        @_,                 # Override previous attributes
    };
    return bless $self, $class;
}
$ed       = Horse->new;                    # A 4-legged bay horse
$stallion = Horse->new(color => "black");  # A 4-legged black horse

我在该代码中看到的是，在

new

子例程中传递的任何内容都被视为包名，该包名将使用此代码转换为对象引用：

sub new {
    my $invocant = shift;
    my $class   = ref($invocant) || $invocant;
    my $self = {
        color  => "bay",
        legs   => 4,
        owner  => undef,
        @_,                 # Override previous attributes
    };
    return bless $self, $class;
}
$ed       = Horse->new;                    # A 4-legged bay horse
$stallion = Horse->new(color => "black");  # A 4-legged black horse

my$invocant=shift#这一个只获取作为传递参数的包的名称

返回$self，$class

那么散列（不是空散列）的预声明有什么用呢？为什么列表的最后部分提供了
@
？为什么
下面是基于上述代码的声明：

此Horse构造函数在用作实例方法时忽略其invocant的现有属性。您可以创建第二个设计为作为实例方法调用的构造函数，如果设计正确，您可以使用调用对象中的值作为新对象的默认值：

这90%的陈述我都不明白

什么是实例方法？还是对象方法？你能举个例子吗
我知道这是我的$class=ref（$invocant）| |$invocant是对象和实例方法，但我不知道它们有什么不同，或者如何使用它们

上面提到的“第二个构造函数”是：

$steed  = Horse->new(color => "dun");
$foal   = $steed->clone(owner => "EquuGen Guild, Ltd.");
sub clone {
    my $model = shift;
    my $self  = $model->new(%$model, @_);
    return $self;     # Previously blessed by ->new
}

再说一次，我不知道它是干什么的。所以任何人都可以为我澄清这一点

那么散列（不是空散列）的预声明有什么用呢？为什么在清单的最后部分提供了?？为什么

将列表分配给哈希时，该列表将被视为键值对列表。如果一个键出现两次，后一个值将覆盖前一个值。因此，
@
之前的键值是默认值，可以由传递到
new
（
@
）的参数覆盖

再说一次，我不知道它是干什么的

它创建一个新对象，将发票的值传递给构造函数以复制发票

那么散列（不是空散列）的预声明有什么用呢？为什么在清单的最后部分提供了?？为什么

将列表分配给哈希时，该列表将被视为键值对列表。如果一个键出现两次，后一个值将覆盖前一个值。因此，
@
之前的键值是默认值，可以由传递到
new
（
@
）的参数覆盖

再说一次，我不知道它是干什么的

它创建一个新对象，将发票的值传递给构造函数以复制发票

那么散列（不是空散列）的预声明有什么用呢？为什么在清单的最后部分提供了?？为什么

这是一种非常聪明的方法，可以让您同时实现两件事：

允许您拥有构造函数的默认值

允许您使用传入构造函数调用的


这是怎么回事？基于您需要了解的关于散列的3件事：


一个散列可以被看作一个列表，通过将其展平为“key1”、“value1”、“key2”、“value2”。。。列表如果将散列作为参数传递给子例程，就会发生这种情况：
mySub（%hash1）

一个列表（包含偶数个元素）可以通过反向过程转换为哈希

从列表中构造的哈希（其中某个键被多次遇到）将只具有该键一次，并且（这里很重要）结果哈希中该键的值将是与该键关联的值中的最后一个实例


换句话说，以下4个赋值产生相同的精确结果数据结构：



例如：


如果传入的哈希没有
颜色
键，只有腿：
马->新（腿=>3）


@
数组将包含2个元素，“legs”和“3”（通过展平该散列获得）

然后，将从以下列表中构造要分配给
$self
的新哈希：

 ("color","bay", 
 "legs", "4", # Will get overwritten
 # more 
 "legs", "3")


现在，根据上面的第三个项目符号，“legs”，“4”对在散列赋值中被后面的“legs”，“3”覆盖；因此，结果散列的（默认）颜色值为“bay”，腿部参数值为“3”



那么散列（不是空散列）的预声明有什么用呢？为什么在清单的最后部分提供了?？为什么

这是一种非常聪明的方法，可以让您同时实现两件事：

允许您拥有构造函数的默认值

允许您使用传入构造函数调用的


这是怎么回事？基于您需要了解的关于散列的3件事：


一个散列可以被看作一个列表，通过将其展平为“key1”、“value1”、“key2”、“value2”。。。列表如果将散列作为参数传递给子例程，就会发生这种情况：
mySub（%hash1）

一个列表（包含偶数个元素）可以通过反向过程转换为哈希

从列表中构造的哈希（其中某个键被多次遇到）将只具有该键一次，并且（这里很重要）结果哈希中该键的值将是与该键关联的值中的最后一个实例


换句话说，以下4个赋值产生相同的精确结果数据结构：



例如：


如果传入的哈希没有
颜色
键，只有腿：
马->新（腿=>3）


@
数组
$invocant->method(@args)
# roughly equivalent to Class::method($invocant, @args)

my $object = bless { x => 1.0, y => -12 } => 'Point';

Class->class_method;
my $foo = Class->new; # another class method
$foo->instance_method;

my %hash = ( x => 1, x => 2 );

my $sleipnir = Horse->new(legs => 8, owner => 'Odin');

my $shadowfax = $sleipnir->new(owner => 'Gandalf');

my $shadowfax = Horse->new(owner => 'Gandalf');

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

    my $self = {
        color  => "bay",
        legs   => 4,
        owner  => undef,
        %args,                 # Override previous attributes
    };
    return bless $self, $class;
} 

my $class   = ref($invocant) || $invocant;

my $horse = Horse->new;

my $other_horse = $horse-new;