Latest web development tutorials

Perl orientado a objeto

Há dois Perl diferente para implementar programação orientada a objetos:

  • Uma abordagem baseada em tabela hash anônimo, a essência de cada instância do objeto é um ponto de referência a uma tabela hash anônimo. Nesta tabela hash anônimo para armazenar todas as propriedades de instância.
  • O segundo é baseado em uma variedade de formas, na definição de uma classe, vamos criar uma propriedade para cada instância da matriz, ea essência de cada instância do objeto é um ponteiro para a matriz em uma fileira a referência de índice. Nessas matrizes, a memória de todas as propriedades de instância.

conceitos básicos de orientada a objeto

Existem muitos conceitos básicos de objeto-orientado, onde recebemos três: objetos, classes e métodos.

  • Objeto: o objeto é um itens de dados de referência de classe..

  • Classe: Classe é um pacote de Perl, que contém o objecto proporcionar um método da classe.

  • Métodos: O método é uma sub-rotina Perl, o nome da classe é o seu primeiro argumento.

Perl fornece uma função abençoe (), abençoe é usado para construir o objeto através de uma referência e abençoar o nome associado a esta classe, devolva esta referência para a construção de um objeto.

definição de classe

Uma classe é apenas um pacote simples.

Você pode usar um pacote como uma classe, e colocar o saco em função do método de classe a ser usada.

pacote Perl fornece um espaço para nome separado, o método de pacotes diferentes e nomes de variáveis ​​não entram em conflito.

arquivo Perl classes de extensão para .pm.

Em seguida, criamos uma classe Pessoa: 

package Person;

intervalo de código de classe para a última linha do arquivo de script, ou para um pacote antes da próxima palavra-chave.

Criando e usando objetos

Criar uma instância de classe (objeto), precisamos definir um construtor, a maioria dos programas usam o nome da classe como um construtor, Perl pode usar qualquer nome.

Você pode usar uma variedade de variáveis ​​como Perl Perl objeto. Na maioria dos casos, vamos utilizar uma referência de matriz ou hash.

Em seguida, criamos um construtor para a classe Person, use uma referência de hash Perl.

Quando você cria um objeto, você precisa fornecer um construtor, que é uma sub-rotina que retorna uma referência de objeto.

Exemplos são os seguintes: 

package Person;
sub new
{
    my $class = shift;
    my $self = {
        _firstName => shift,
        _lastName  => shift,
        _ssn       => shift,
    };
    # 输出用户信息
    print "名字：$self->{_firstName}\n";
    print "姓氏：$self->{_lastName}\n";
    print "编号：$self->{_ssn}\n";
    bless $self, $class;
    return $self;
}

Em seguida, criamos um objeto: 

$object = new Person( "小明", "王", 23234345);

método definição

métodos da classe Perl única, mas é uma sub-rotina Perl, também conhecido como funções de membro.

Perl Perl definição do método orientado a objeto não fornece qualquer sintaxe especial, mas o primeiro parâmetro especifica o método para o objeto ou pacote referenciado.

Perl não fornecer variáveis ​​privadas, mas podemos gerenciar dados de objeto através da forma como auxiliar.

Em seguida, definimos uma maneira de obter o nome: 

sub getFirstName {
    return $self->{_firstName};
}

O mesmo também pode escrever: 

sub setFirstName {
    my ( $self, $firstName ) = @_;
    $self->{_firstName} = $firstName if defined($firstName);
    return $self->{_firstName};
}

A seguir, modificar o ficheiro Person.pm código, como se segue: 

#!/usr/bin/perl 

package Person;

sub new
{
    my $class = shift;
    my $self = {
        _firstName => shift,
        _lastName  => shift,
        _ssn       => shift,
    };
    # 输出用户信息
    print "名字：$self->{_firstName}\n";
    print "姓氏：$self->{_lastName}\n";
    print "编号：$self->{_ssn}\n";
    bless $self, $class;
    return $self;
}
sub setFirstName {
    my ( $self, $firstName ) = @_;
    $self->{_firstName} = $firstName if defined($firstName);
    return $self->{_firstName};
}

sub getFirstName {
    my( $self ) = @_;
    return $self->{_firstName};
}
1;

employee.pl código de script é a seguinte: 

#!/usr/bin/perl

use Person;

$object = new Person( "小明", "王", 23234345);
# 获取姓名
$firstName = $object->getFirstName();

print "设置前姓名为 : $firstName\n";

# 使用辅助函数设置姓名
$object->setFirstName( "小强" );

# 通过辅助函数获取姓名
$firstName = $object->getFirstName();
print "设置后姓名为 : $firstName\n";

Depois de executar o programa acima, a saída é: 

$ perl employee.pl
名字：小明
姓氏：王
编号：23234345
设置前姓名为 : 小明
设置后姓名为 : 小强

herdar

métodos da classe Perl em sucessão através de array @ISA, a matriz que contém outros pacotes (classe) nome, herdar a variável deve ser definida explicitamente.

herança múltipla é a matriz @ISA compreendendo uma pluralidade de classe (pacote) nome.

O método só pode ser herdada através @ISA, os dados não podem ser herdadas.

Em seguida, criamos um funcionário classe herda da classe Pessoa.

código de arquivo Employee.pm é a seguinte: 

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # 从 Person 继承

Agora classe Employee contém todos os métodos e propriedades da classe Pessoa, que insira o seguinte código no arquivo main.pl e executar: 

#!/usr/bin/perl

use Employee;

$object = new Employee( "小明", "王", 23234345);
# 获取姓名
$firstName = $object->getFirstName();

print "设置前姓名为 : $firstName\n";

# 使用辅助函数设置姓名
$object->setFirstName( "小强" );

# 通过辅助函数获取姓名
$firstName = $object->getFirstName();
print "设置后姓名为 : $firstName\n";

Depois de executar o programa acima, a saída é: 

$ perl main.pl
名字：小明
姓氏：王
编号：23234345
设置前姓名为 : 小明
设置后姓名为 : 小强

substitui o método

O exemplo acima, a classe Employee estende a classe Pessoa, mas se os métodos de classe A pessoa não pode atender a demanda, é necessário reescrever seus métodos.

Em seguida, vamos adicionar alguns novos métodos na classe de funcionários, e substituir os métodos da classe Pessoa: 

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # 从 Person 继承

# 重写构造函数
sub new {
    my ($class) = @_;

    # 调用父类的构造函数
    my $self = $class->SUPER::new( $_[1], $_[2], $_[3] );
    # 添加更多属性
    $self->{_id}   = undef;
    $self->{_title} = undef;
    bless $self, $class;
    return $self;
}

# 重写方法
sub getFirstName {
    my( $self ) = @_;
    # 这是子类函数
    print "这是子类函数\n";
    return $self->{_firstName};
}

# 添加方法
sub setLastName{
    my ( $self, $lastName ) = @_;
    $self->{_lastName} = $lastName if defined($lastName);
    return $self->{_lastName};
}

sub getLastName {
    my( $self ) = @_;
    return $self->{_lastName};
}

1;

Entramos no seguinte arquivo main.pl código e execute: 

#!/usr/bin/perl

use Employee;

$object = new Employee( "小明", "王", 23234345);
# 获取姓名，使用修改后的构造函数
$firstName = $object->getFirstName();

print "设置前姓名为 : $firstName\n";

# 使用辅助函数设置姓名
$object->setFirstName( "小强" );

# 通过辅助函数获取姓名
$firstName = $object->getFirstName();
print "设置后姓名为 : $firstName\n";

Depois de executar o programa acima, a saída é: 

$ perl main.pl
名字：小明
姓氏：王
编号：23234345
这是子类函数
设置前姓名为 : 小明
这是子类函数
设置后姓名为 : 小强

Carregando padrão

Se a classe no atual, a classe atual de toda a classe base, e métodos de classe UNIVERSAL solicitados não pode ser encontrado, em seguida, procura por um método chamado AUTOLOAD () novamente. Se for encontrado AUTOLOAD, ele irá chamar, ao definir o nome completo do valor R $ AUTOLOAD variável global dos métodos ausentes.

Se não, então ele falhou Perl e erro.

Se você não quer herdar o AUTOLOAD classe base, muito simples, apenas uma frase: 

sub AUTOLOAD;

Destruidores e coleta de lixo

Quando a última referência a um objeto é liberado, o objeto é automaticamente destruído.

Se você quiser fazer alguma coisa no processo de destruição quando você pode um método chamado "destruir" é definido na classe. Ele irá chamar automaticamente o tempo apropriado, e para realizar ações de limpeza adicionais de acordo com o que você quer dizer. 

package MyClass;
...
sub DESTROY
{
    print "MyClass::DESTROY called\n";
}

referência de objeto Perl será passado para destruir o único parâmetro. Note-se que esta citação é somente leitura, o que significa que você não pode acessar o $ _ [0] para modificá-lo. (Nota do tradutor: Ver perlsub), mas o próprio objeto (como "$ {$ _ [0]" ou "@ {$ _ [0]}" e "% {$ _ [0]}", etc.), ou pode ser escrito.

Se você re-abençoar a referência de objeto antes de o destruidor retornos, Perl, então, chamá-lo para re-abençoar DESTRUIR método desse objeto após o destruidor retornos. Isso permite que você tenha a oportunidade de chamar a classe base ou você especificar destructor outras classes. Deve notar-se, destrua também pode ser chamado manualmente, mas normalmente não é necessário.

Após o lançamento do objeto atual, outros objetos contidos no objeto atual é automaticamente liberado.

Exemplos de Perl orientado a objeto

Podemos ainda ser entendida pelas seguintes aplicações orientadas a objetos exemplos Perl: 

#!/usr/bin/perl

# 下面是简单的类实现
package MyClass;

sub new
{
   print "MyClass::new called\n";
   my $type = shift;            # 包名
   my $self = {};               # 引用空哈希
   return bless $self, $type;   
}

sub DESTROY
{
   print "MyClass::DESTROY called\n";
}

sub MyMethod
{
   print "MyClass::MyMethod called!\n";
}


# 继承实现
package MySubClass;

@ISA = qw( MyClass );

sub new
{
   print "MySubClass::new called\n";
   my $type = shift;            # 包名
   my $self = MyClass->new;     # 引用空哈希
   return bless $self, $type;  
}

sub DESTROY
{
   print "MySubClass::DESTROY called\n";
}

sub MyMethod
{
   my $self = shift;
   $self->SUPER::MyMethod();
   print "   MySubClass::MyMethod called!\n";
}

# 调用以上类的主程序
package main;

print "调用 MyClass 方法\n";

$myObject = MyClass->new();
$myObject->MyMethod();

print "调用 MySubClass 方法\n";

$myObject2 = MySubClass->new();
$myObject2->MyMethod();

print "创建一个作用域对象\n";
{
  my $myObject2 = MyClass->new();
}
# 自动调用析构函数

print "创建对象\n";
$myObject3 = MyClass->new();
undef $myObject3;

print "脚本执行结束...\n";
# 自动执行析构函数

O programa acima, a saída é: 

调用 MyClass 方法
MyClass::new called
MyClass::MyMethod called!
调用 MySubClass 方法
MySubClass::new called
MyClass::new called
MyClass::MyMethod called!
   MySubClass::MyMethod called!
创建一个作用域对象
MyClass::new called
MyClass::DESTROY called
创建对象
MyClass::new called
MyClass::DESTROY called
脚本执行结束...
MyClass::DESTROY called
MySubClass::DESTROY called