Perl Object-Oriented

Es gibt zwei verschiedene Perl objektorientierten Programmierung zu implementieren:

Ein anonymer Hash-Tabelle-basierten Ansatz, die Essenz eines jeden Objektinstanz ist ein Bezugspunkt auf einen anonymen Hash-Tabelle. In diesem anonymen Hash-Tabelle, die alle Eigenschaften der Instanz zu speichern.
Die zweite auf eine Reihe von Möglichkeiten, in der Definition einer Klasse basiert, werden wir eine Eigenschaft für jede Instanz des Arrays, und das Wesen eines jeden Objektinstanz ist ein Zeiger auf das Array in einer Reihe der Index Referenz erstellen. In diesen Anordnungen, die Erinnerung an all die Eigenschaften der Instanz.

Grundlegende Konzepte der objektorientierten

Es gibt viele grundlegende Konzepte der objektorientierten, wo wir erhielten drei: Objekte, Klassen und Methoden.

Objekt: Das Objekt ist eine Klasse Referenzdaten..
Klasse: Klasse ist ein Perl - Paket, das das Objekt enthält , ein Verfahren der Klasse bereitzustellen.
Methoden: Die Methode ist eine Perlfunktionen, der Klassenname ist das erste Argument.

Perl stellt eine segnen () Funktion, segnen verwendet wird, um das Objekt über einen Verweis zu konstruieren und den Namen mit dieser Klasse, kehren diese Referenz assoziiert segnen, ein Objekt zu konstruieren.

Klassendefinition

Eine Klasse ist nur ein einfaches Paket.

Sie können ein Paket als Klasse zu verwenden, und stellte die Tasche als Funktion der Klassenmethode zu verwenden.

Perl-Paket bietet einen eigenen Namensraum, Methode von verschiedenen Paketen und Variablennamen nicht in Konflikt stehen.

Perl-Erweiterungsklassen für .pm Datei.

Als Nächstes erstellen wir eine Klasse Person:

package Person;

Klasse Codebereich bis zur letzten Zeile der Skriptdatei oder auf ein Paket vor dem nächsten Schlüsselwort.

Erstellen und Verwenden von Objekten

Erstellen Sie eine Klasse Instanz (Objekt) wir brauchen einen Konstruktor zu definieren, die meisten Programme den Klassennamen als Konstruktor verwenden, können Perl einen beliebigen Namen verwenden.

Sie können eine Vielzahl von Variablen wie Perl Perl-Objekt verwenden. In den meisten Fällen werden wir ein Array oder Hash-Referenz verwenden.

Als Nächstes erstellen wir einen Konstruktor für die Klasse Person, verwenden Sie ein Perl-Hash-Referenz.

Wenn Sie ein Objekt erstellen, müssen Sie einen Konstruktor zu schaffen, das ein Unterprogramm, das eine Objektreferenz zurückgibt.

Beispiele sind wie folgt:

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

Als Nächstes erstellen wir ein Objekt:

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

Definition Methode

Perl-Klasse Methoden nur, aber es ist ein Perlfunktionen, die auch als Member-Funktionen bekannt.

Die objektorientierte Perl Perl Methodendefinition stellt keine besondere Syntax, aber der erste Parameter gibt die Methode für das referenzierte Objekt oder Paket.

Perl bietet keine privaten Variablen, aber wir können Objektdaten durch die Hilfs Art und Weise zu verwalten.

Als nächstes definieren wir einen Weg, um den Namen zu erhalten:

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

Das gleiche kann auch schreiben:

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

Als nächstes ändern wir den Code Person.pm Datei wie folgt:

#!/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 Script-Code ist wie folgt:

#!/usr/bin/perl

use Person;

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

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

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

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

Nachdem das obige Programm ausgeführt wird, ist die Ausgabe:

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

ererben

Perl-Klasse Methoden nacheinander durch @ISA Array, das Array, das andere Pakete enthält (wie) der Name der Variablen muss explizit festgelegt werden, um zu erben.

Mehrfachvererbung ist die @ISA Array mit einer Vielzahl von Klasse (Paket) Namen umfasst.

Das Verfahren kann nur durch @ISA vererbt werden, können die Daten nicht vererbt werden.

Als Nächstes erstellen wir eine Klasse Mitarbeiter Person-Klasse erbt.

Employee.pm Datei Code ist wie folgt:

#!/usr/bin/perl

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

Jetzt Employee-Klasse enthält alle Methoden und Eigenschaften der Person-Klasse, geben wir den folgenden Code in main.pl Datei und führen:

#!/usr/bin/perl

use Employee;

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

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

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

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

Nachdem das obige Programm ausgeführt wird, ist die Ausgabe:

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

Methode überschreibt

Das obige Beispiel erstreckt sich Employee-Klasse die Klasse Person, aber wenn die Person-Klasse Methoden nicht der Nachfrage gerecht zu werden, ist es notwendig, seine Methoden neu zu schreiben.

Als nächstes fügen wir in der Employee-Klasse einige neue Methoden, und die Person-Klasse Methoden außer Kraft setzen:

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

Wir geben den folgenden Code main.pl Datei und führen:

#!/usr/bin/perl

use Employee;

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

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

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

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

Nachdem das obige Programm ausgeführt wird, ist die Ausgabe:

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

Laden Standard

Wenn die Klasse in der aktuellen, die aktuelle Klasse aller Basisklasse und Klassenmethoden UNIVERSAL nicht gefunden werden kann, sucht dann nach einer Methode namens AUTOLOAD () erneut. Wenn AUTOLOAD gefunden wird, wird es nennen, während Sie den vollständig qualifizierten Namen der globalen Variablen $ AUTOLOAD Wert der fehlenden Methoden setzen.

Wenn nicht, dann versagt es Perl und Irrtum.

Wenn Sie nicht möchten, dass die Basisklasse AUTOLOAD zu erben, sehr einfach, nur einen Satz:

sub AUTOLOAD;

Destruktoren und Müllabfuhr

Wenn die letzte Referenz auf ein Objekt freigegeben wird, wird das Objekt automatisch zerstört.

Wenn Sie etwas in der destructor tun möchten, wenn Sie eine Methode "destroy" genannt wird, in der Klasse definiert. Es wird die entsprechende Zeit automatisch aufrufen, und um zusätzliche Bereinigungsaktionen durchführen nach dem, was Sie meinen.

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

Perl Objektverweis wird übergeben als einziger Parameter zu zerstören. Beachten Sie, dass dieses Zitat schreibgeschützt ist, was bedeutet, dass Sie nicht die $ zugreifen kann _ [0], um es zu ändern. (Anmerkung des Übersetzers: Siehe perlsub), sondern das Objekt selbst (wie "$ {$ _ [0]" oder "@ {$ _ [0]}" und "% {$ _ [0]}", etc.) oder sein kann geschrieben.

Wenn Sie den Objektverweis erneut segnen, bevor die destructor zurückkehrt, Perl rufen Sie dann erneut zu segnen DESTROY Methode dieses Objekts nach den destructor zurückkehrt. Auf diese Weise können Sie die Gelegenheit haben, die Basisklasse aufrufen oder Sie destructor anderen Klassen angeben. Es sollte beachtet werden, zerstören kann auch manuell aufgerufen werden, ist aber in der Regel nicht erforderlich.

Nach der Veröffentlichung des aktuellen Objekts, andere in dem aktuellen Objekt enthaltenen Objekte automatisch freigegeben.

Beispiele für objektorientierte Perl

Wir können weiterhin durch die folgenden Beispiele Perl objektorientierte Anwendungen verstanden werden:

#!/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";
# 自动执行析构函数

Das obige Programm, das Ausgabe ist:

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

Zurück: Perl Socket - Programmierung

Weiter: Perl Database Connectivity

Perl Kurs

Perl Object-Oriented

Grundlegende Konzepte der objektorientierten

Klassendefinition

Erstellen und Verwenden von Objekten

Definition Methode

ererben

Methode überschreibt

Laden Standard

Destruktoren und Müllabfuhr

Beispiele für objektorientierte Perl