Latest web development tutorials

Perl Object-Oriented

Ci sono due diversi Perl per implementare la programmazione orientata agli oggetti:

  • Un approccio hash anonimo basato su tabelle, l'essenza di ogni istanza di oggetto è un punto di riferimento a una tabella hash anonimo. In questa tabella hash anonimo per memorizzare tutte le proprietà dell'istanza.
  • La seconda si basa su una serie di modi, nella definizione di una classe, creeremo una proprietà per ogni istanza della matrice, e l'essenza di ogni istanza di oggetto è un puntatore alla matrice di fila il riferimento dell'indice. In questi array, la memoria di tutte le proprietà dell'istanza.

Concetti di base di object-oriented

Ci sono molti concetti di base di object-oriented, dove abbiamo ricevuto tre: oggetti, classi e metodi.

  • Oggetto: l'oggetto è un elementi di dati di riferimento di classe..

  • Classe: Classe è un pacchetto Perl, che contiene lo scopo di realizzare un metodo della classe.

  • Metodi: Il metodo è una subroutine Perl, il nome della classe è il suo primo argomento.

Perl fornisce una funzione bless (), benedica viene utilizzato per costruire l'oggetto attraverso un punto di riferimento e benedire il nome associato a questa classe, restituire questo riferimento per costruire un oggetto.

definizione di classe

Una classe è solo un pacchetto semplice.

È possibile usare un pacchetto come classe, e mettere il sacchetto in funzione del metodo di classe da utilizzare.

pacchetto Perl fornisce uno spazio dei nomi a parte, il metodo di diversi pacchetti e nomi di variabili non sono in contrasto.

Perl file di classi di estensione per .pm.

Poi creiamo una classe Persona: 

package Person;

gamma codice della classe per l'ultima riga del file di script, o di un pacchetto prima della parola chiave successivo.

Creazione e utilizzo di oggetti

Creare una istanza di classe (oggetto) abbiamo bisogno di definire un costruttore, la maggior parte dei programmi utilizzano il nome della classe come un costruttore, Perl può utilizzare qualsiasi nome.

È possibile utilizzare una varietà di variabili come oggetto Perl Perl. Nella maggior parte dei casi useremo un riferimento array o hash.

Poi creiamo un costruttore per la classe Person, utilizzare un riferimento hash Perl.

Quando si crea un oggetto, è necessario fornire un costruttore, che è una subroutine che restituisce un riferimento a un oggetto.

Esempi sono i seguenti: 

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;
}

Successivamente, creiamo un oggetto: 

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

metodo definizione

solo metodi di classe Perl, ma è una subroutine Perl, noto anche come funzioni membro.

Orientata agli oggetti in Perl Perl definizione di metodo non fornisce alcuna sintassi speciale, ma il primo parametro specifica il metodo per l'oggetto o il pacchetto di riferimento.

Perl non fornisce variabili private, ma siamo in grado di gestire i dati degli oggetti attraverso il modo ausiliario.

Successivo definiamo un modo per ottenere il nome: 

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

Lo stesso si può anche scrivere: 

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

Avanti, modifichiamo il file Person.pm codice, come 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 codice di script è il seguente: 

#!/usr/bin/perl

use Person;

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

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

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

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

Dopo l'esecuzione del programma di cui sopra, l'uscita è: 

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

ereditare

metodi di classe Perl in successione da @ISA matrice, la matrice che contiene altri pacchetti (classe) nome, erediterà la variabile deve essere impostata in modo esplicito.

L'ereditarietà multipla è la matrice @ISA comprendente una pluralità di classe (package) nome.

Il metodo può essere ereditata solo attraverso @ISA, i dati non possono essere ereditate.

Poi creiamo un Dipendente classe eredita classe Persona.

codice del file Employee.pm è il seguente: 

#!/usr/bin/perl

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

Ora classe Employee contiene tutti i metodi e le proprietà della classe Persona, entriamo il seguente codice nel file di main.pl ed eseguire: 

#!/usr/bin/perl

use Employee;

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

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

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

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

Dopo l'esecuzione del programma di cui sopra, l'uscita è: 

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

override del metodo

L'esempio di cui sopra, classe Employee estende la classe persona, ma se i metodi della classe persona non può soddisfare la domanda, è necessario riscrivere i suoi metodi.

Successivamente, si aggiungono alcuni nuovi metodi nella classe Employee, e sovrascrivere i metodi della classe Persona: 

#!/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;

Entriamo il seguente file main.pl codice ed eseguire: 

#!/usr/bin/perl

use Employee;

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

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

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

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

Dopo l'esecuzione del programma di cui sopra, l'uscita è: 

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

Caricamento di default

Se la classe nella corrente, la classe corrente di tutta la classe base, e metodi di classe universale richiesta non può essere trovata, poi cerca un metodo chiamato AUTOLOAD di nuovo (). Se trovato AUTOLOAD, si chiamerà, mentre impostando il nome completo del valore di $ AUTOLOAD variabile globale dei metodi mancanti.

Se no, allora non è riuscito Perl ed errori.

Se non si desidera ereditare la classe base AUTOLOAD, molto semplice, basta una sola frase: 

sub AUTOLOAD;

Distruttori e la raccolta dei rifiuti

Quando viene rilasciato l'ultimo riferimento a un oggetto, l'oggetto viene distrutto automaticamente.

Se si vuole fare qualcosa nel distruttore, quando è possibile un metodo chiamato "distruggere" è definito nella classe. Si chiamerà automaticamente al momento opportuno, e di effettuare azioni di pulizia aggiuntivi in ​​base a quello che vuoi dire. 

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

riferimento a un oggetto Perl verrà passato di distruggere l'unico parametro. Si noti che questa citazione è di sola lettura, che significa che non è possibile accedere al $ _ [0] per modificarlo. (Nota del traduttore: Vedere perlsub), ma l'oggetto stesso (come "$ {$ _ [0]" o "@ {$ _ [0]}" e "% {$ _ [0]}", etc.) o può essere scrivere.

Se si ri-benedica il riferimento all'oggetto prima che i rendimenti distruttore, Perl quindi si chiama re-benedica DISTRUGGERE metodo di tale oggetto, dopo il ritorno distruttore. Ciò consente di avere la possibilità di chiamare la classe di base o si specifica destructor altre classi. Va notato, DISTRUGGERE può essere richiamato manualmente, ma non è solitamente necessario.

Dopo l'uscita dell'oggetto corrente, altri oggetti contenuti nell'oggetto corrente viene rilasciato automaticamente.

Esempi di Perl orientato agli oggetti

Possiamo essere ulteriormente compresi dai seguenti applicazioni orientate agli oggetti esempi 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";
# 自动执行析构函数

Il programma precedente, l'uscita è: 

调用 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