Perl Objektorientierte Programmierung

Es gibt zwei verschiedene Implementierungen objektorientierter Programmierung in Perl:

  • Eine basiert auf anonymen Hash-Tabellen, wobei die Essenz jeder Objektinstanz eine Referenz auf eine anonyme Hash-Tabelle ist. In dieser anonymen Hash-Tabelle werden alle Instanzattribute gespeichert.

  • Die andere basiert auf Arrays. Beim Definieren einer Klasse erstellen wir ein Array für jedes Instanzattribut, und die Essenz jeder Objektinstanz ist eine Referenz auf einen Index einer Zeile in diesen Arrays. In diesen Arrays werden alle Instanzattribute gespeichert.


Objektorientierte Grundkonzepte

Objektorientierte Programmierung hat viele grundlegende Konzepte. Hier behandeln wir drei: Objekte, Klassen und Methoden.

  • ObjektEin Objekt ist eine Referenz auf ein Datenelement in einer Klasse.

  • KlasseEine Klasse ist ein Perl-Paket, das die für das Objekt bereitgestellten Methoden enthält.

  • MethodeEine Methode ist eine Perl-Subroutine, deren erster Parameter der Klassenname ist.

Perl stellt die Funktion bless() bereit, die zum Konstruieren von Objekten verwendet wird. Indem man eine Referenz über bless mit dem Klassennamen verknüpft, konstruiert die Rückgabe dieser Referenz ein Objekt.


Klassendefinition

Eine Klasse ist nur ein einfaches Paket.

Sie können ein Paket als Klasse verwenden und die Funktionen im Paket als Methoden der Klasse verwenden.

Perl-Pakete bieten unabhängige Namensräume, sodass Methoden- und Variablennamen aus verschiedenen Paketen nicht kollidieren.

Perl-Klassendateien haben die Erweiterung .pm.

Als Nächstes erstellen wir eine Klasse Person:

package Person;

Der Gültigkeitsbereich des Codes einer Klasse erstreckt sich bis zur letzten Zeile der Skriptdatei oder bis zum nächsten Schlüsselwort "package".


Erstellen und Verwenden von Objekten

Um eine Instanz (ein Objekt) einer Klasse zu erstellen, müssen wir einen Konstruktor definieren. Die meisten Programme verwenden den Klassennamen als Konstruktor, aber in Perl können Sie jeden beliebigen Namen verwenden.

Sie können verschiedene Perl-Variablen als Perl-Objekte verwenden. In den meisten Fällen verwenden wir Referenzen auf Arrays oder Hashes.

Als Nächstes erstellen wir einen Konstruktor für die Klasse Person unter Verwendung einer Perl-Hash-Referenz.

Beim Erstellen eines Objekts müssen Sie einen Konstruktor angeben, eine Subroutine, die eine Referenz auf das Objekt zurückgibt.

Das Beispiel ist wie folgt:

Beispiel

package Person; sub new { my $class = shift; my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Benutzerinformationen ausgeben print "Name:$self->{_firstName}\n"; print "Nachname:$self->{_lastName}\n"; print "Nummer:$self->{_ssn}\n"; bless $self, $class; return $self; }

Als Nächstes erstellen wir ein Objekt:

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

Methoden definieren

Perl-Klassenmethoden sind einfach Perl-Subroutinen, d. h. das, was üblicherweise Member-Funktionen genannt wird.

In der Perl-OOP bietet die Methodendefinition keine spezielle Syntax, erfordert aber, dass der erste Parameter einer Methode das Objekt oder das Paket ist, von dem aus sie referenziert wird.

Perl stellt keine privaten Variablen bereit, aber wir können Objektdaten über Hilfsmethoden verwalten.

Als Nächstes definieren wir eine Methode, um den Namen abzurufen:

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

Es kann auch so geschrieben werden:

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

Als Nächstes ändern wir den Code in der Datei Person.pm wie folgt:

Beispiel

#!/usr/bin/perl package Person; sub new { my $class = shift; my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Benutzerinformationen ausgeben print "Name:$self->{_firstName}\n"; print "Nachname:$self->{_lastName}\n"; print "Nummer:$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;

Der Code des Skripts employee.pl lautet wie folgt:

Beispiel

#!/usr/bin/perl use Person; $object = new Person( "Xiaoming", "Wang", 23234345); # Namen abrufen $firstName = $object->getFirstName(); print "Der Name vor dem Setzen ist :$firstName\n"; # Hilfsfunktion zum Setzen des Namens verwenden $object->setFirstName( "Xiaoqiang" ); # Namen über Hilfsfunktion abrufen $firstName = $object->getFirstName(); print "Der Name nach dem Setzen ist :$firstName\n";

Nach Ausführung des obigen Programms ist die Ausgabe:

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

Vererbung

In Perl werden Klassenmethoden über das @ISA-Array vererbt, das die Namen anderer Pakete (Klassen) enthält. Die Variablenvererbung muss explizit festgelegt werden.

Mehrfachvererbung liegt vor, wenn dieses @ISA-Array mehrere Klassen- (Paket-)Namen enthält.

Über @ISA können nur Methoden vererbt werden; Daten können nicht vererbt werden.

Als Nächstes erstellen wir eine Klasse Employee, die von der Klasse Person erbt.

Der Code der Datei Employee.pm lautet wie folgt:

Beispiel

#!/usr/bin/perl package Employee; use Person; use strict; our @ISA = qw(Person); # Von Person erben

Jetzt enthält die Klasse Employee alle Methoden und Attribute der Klasse Person. Wir geben den folgenden Code in die Datei main.pl ein und führen ihn aus:

Beispiel

#!/usr/bin/perl use Employee; $object = new Employee( "Xiaoming", "Wang", 23234345); # Namen abrufen $firstName = $object->getFirstName(); print "Der Name vor dem Setzen ist :$firstName\n"; # Hilfsfunktion zum Setzen des Namens verwenden $object->setFirstName( "Xiaoqiang" ); # Namen über Hilfsfunktion abrufen $firstName = $object->getFirstName(); print "Der Name nach dem Setzen ist :$firstName\n";

Nach Ausführung des obigen Programms ist die Ausgabe:

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

Methodenüberschreibung

Im obigen Beispiel erbt die Klasse Employee von der Klasse Person. Wenn die Methoden der Klasse Person jedoch die Anforderungen nicht erfüllen, müssen sie überschrieben werden.

Als Nächstes fügen wir der Klasse Employee einige neue Methoden hinzu und überschreiben Methoden der Klasse Person:

Beispiel

#!/usr/bin/perl package Employee; use Person; use strict; our @ISA = qw(Person); # Von Person erben # Konstruktor überschreiben sub new { my ($class) = @_; # Konstruktor der Elternklasse aufrufen my $self = $class->SUPER::new( $_[1], $_[2], $_[3] ); # Weitere Attribute hinzufügen $self->{_id} = undef; $self->{_title} = undef; bless $self, $class; return $self; } # Methode überschreiben sub getFirstName { my( $self ) = @_; # Dies ist eine Unterklassenfunktion print "Dies ist eine Unterklassenfunktion\n"; return $self->{_firstName}; } # Methode hinzufügen 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 in die Datei main.pl ein und führen ihn aus:

Beispiel

#!/usr/bin/perl use Employee; $object = new Employee( "Xiaoming", "Wang", 23234345); # Namen abrufen, unter Verwendung des modifizierten Konstruktors $firstName = $object->getFirstName(); print "Der Name vor dem Setzen ist :$firstName\n"; # Hilfsfunktion zum Setzen des Namens verwenden $object->setFirstName( "Xiaoqiang" ); # Namen über Hilfsfunktion abrufen $firstName = $object->getFirstName(); print "Der Name nach dem Setzen ist :$firstName\n";

Nach Ausführung des obigen Programms ist die Ausgabe:

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

Autoload

Wenn die angeforderte Methode nicht in der aktuellen Klasse, in allen Basisklassen der aktuellen Klasse oder in der UNIVERSAL-Klasse gefunden werden kann, sucht Perl nach einer Methode namens AUTOLOAD(). Wenn AUTOLOAD gefunden wird, wird sie aufgerufen, und die globale Variable $AUTOLOAD wird auf den vollqualifizierten Namen der fehlenden Methode gesetzt.

Wenn auch das noch fehlschlägt, meldet Perl einen Fehler und schlägt fehl.

Wenn Sie AUTOLOAD nicht von der Basisklasse erben möchten, ist es einfach: nur eine Zeile:

sub AUTOLOAD;

Destruktoren und Garbage Collection

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

Wenn Sie während der Zerstörung etwas tun möchten, können Sie eine Methode namens "DESTROY" in der Klasse definieren. Sie wird automatisch zu einem geeigneten Zeitpunkt aufgerufen und führt zusätzliche Aufräumaktionen aus, wie Sie es definieren.

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

Perl übergibt die Objektreferenz als einzigen Parameter an DESTROY. Beachten Sie, dass diese Referenz schreibgeschützt ist, was bedeutet, dass Sie sie nicht durch Zugriff auf $_ ändern können.

Wenn Sie die Objektreferenz erneut blessen, bevor der Destruktor zurückkehrt, ruft Perl nach der Rückkehr des Destruktors die DESTROY-Methode des Objekts auf, das Sie erneut geblesst haben. Dies gibt Ihnen die Möglichkeit, den Destruktor der Basisklasse oder einer anderen von Ihnen angegebenen Klasse aufzurufen. Es sollte beachtet werden, dass DESTROY auch manuell aufgerufen werden kann, aber normalerweise unnötig ist.

Nachdem das aktuelle Objekt freigegeben wurde, werden andere im aktuellen Objekt enthaltene Objekte automatisch freigegeben.


Objektorientiertes Perl-Beispiel

Anhand des folgenden Beispiels können wir die Anwendung von Perl-OOP weiter verstehen:

Beispiel

#!/usr/bin/perl # Das Folgende ist eine einfache Klassenimplementierung package MyClass; sub new { print "MyClass::new aufgerufen\n"; my $type = shift; # Paketname my $self = {}; # Referenz auf einen leeren Hash return bless $self, $type; } sub DESTROY { print "MyClass::DESTROY aufgerufen\n"; } sub MyMethod { print "MyClass::MyMethod aufgerufen!\n"; } # Implementierung der Vererbung package MySubClass; @ISA = qw( MyClass ); sub new { print "MySubClass::new aufgerufen\n"; my $type = shift; # Paketname my $self = MyClass->new; # Referenz auf einen leeren Hash return bless $self, $type; } sub DESTROY { print "MySubClass::DESTROY aufgerufen\n"; } sub MyMethod { my $self = shift; $self->SUPER::MyMethod(); print " MySubClass::MyMethod aufgerufen!\n"; } # Hauptprogramm, das die obigen Klassen aufruft package main; print "Aufruf der MyClass-Methode\n"; $myObject = MyClass->new(); $myObject->MyMethod(); print "Aufruf der MySubClass-Methode\n"; $myObject2 = MySubClass->new(); $myObject2->MyMethod(); print "Erstellen eines bereichsbezogenen\n"; { my $myObject2 = MyClass->new(); } # Destruktor automatisch aufrufen print "Objekt erstellen\n"; $myObject3 = My->new(); undef $myObject3; print "Skriptausführung beendet...\n"; # Automatische Destruktor-Ausführung

Wenn das obige Programm ausgeführt wird, lautet die Ausgabe:

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