Perl objektorientiert

Es gibt zwei verschiedene Implementierungen der objektorientierten Programmierung in Perl:

Eine basiert auf der anonymen Hash-Tabellenmethode. Das Wesentliche jeder Objektinstanz ist eine Referenz, die auf die anonyme Hash-Tabelle verweist. In dieser anonymen Hash-Tabelle werden alle Instanzattribute gespeichert.

Die zweite ist die Array-basierte Methode. Beim Definieren einer Klasse erstellen wir ein Array für jedes Instanzattribut, und das Wesentliche jeder Objektinstanz ist eine Referenz, die auf einen Zeilenindex in diesen Arrays verweist. In diesen Arrays werden alle Instanzeigenschaften gespeichert.

Objektorientierte Grundkonzepte

Es gibt viele Grundkonzepte in der Objektorientierung, hier akzeptieren wir drei: Objekte, Klassen und Methoden.

Objekt : Ein Objekt ist eine Referenz auf ein Datenelement in einer Klasse. .

Klasse : Eine Klasse ist ein Perl-Paket, das Klassen enthält, die Objektmethoden bereitstellen.

Methode : Eine Methode ist eine Perl-Subroutine und der Klassenname ist ihr erster Parameter.

Perl stellt die Funktion bless() bereit, die zum Erstellen von Objekten verwendet wird. Bless verknüpft eine Referenz mit dem Klassennamen und erstellt ein Objekt, indem die Referenz zurückgegeben wird.

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 stellen unabhängige Namensräume bereit, sodass Methoden- und Variablennamen in verschiedenen Paketen nicht in Konflikt geraten.

Die Dateierweiterung für Perl-Klassen ist .pm.

Als nächstes erstellen wir eine Person-Klasse:

 Paket Person;

Der Codebereich der Klasse reicht bis zur letzten Zeile der Skriptdatei oder vor dem nächsten Paketschlüsselwort.

Objekte erstellen und verwenden

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 einen beliebigen Namen verwenden.

Sie können verschiedene Perl-Variablen als Perl-Objekte verwenden. Meistens verwenden wir Referenzarrays oder Hashes.

Als Nächstes erstellen wir mithilfe der Hash-Referenz von Perl einen Konstruktor für die Person-Klasse.

Beim Erstellen eines Objekts müssen Sie einen Konstruktor bereitstellen, bei dem es sich um eine Unterroutine handelt, die eine Referenz auf das Objekt zurückgibt.

Beispiele sind wie folgt:

Beispiel

Paket Person ; sub neu { Mein $class = Verschiebung ; mein $self = { _firstName => Shift , _lastName => Shift , _ssn => Shift , } # Benutzerinformationen ausgeben drucken " Name: $self ->{_firstName} n " ; print " Nachname: $self ->{_lastName} n " ; print " Zahl: $self - >{_ssn} n " ; $self , $class ; return $ selbst }

Als nächstes erstellen wir ein Objekt:

 $object = new Person( "Xiao Ming", "王", 23234345);

Methode definieren

Die Methode der Perl-Klasse ist lediglich eine Perl-Subroutine, die allgemein als Mitgliedsfunktion bezeichnet wird.

Die Methodendefinition von Perl im objektorientierten Perl stellt keine spezielle Syntax bereit, legt jedoch fest, dass der erste Parameter der Methode das Objekt oder sein referenziertes Paket ist.

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

Als nächstes definieren wir eine Methode, um den Namen zu erhalten:

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

Sie können auch so schreiben:

 sub setFirstName { my ( $self, $firstName ) = @_; $self->{_firstName} = $firstName falls definiert($firstName};}

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

Beispiel

#!/usr/bin/perl Paket Person ; sub neu { Mein $class = Verschiebung ; mein $self = { _firstName => Shift , _lastName => Shift , _ssn => Shift , } # Benutzerinformationen ausgeben drucken " Name: $self ->{_firstName} n " ; print " Nachname: $self ->{_lastName} n " ; print " Zahl: $self - >{_ssn} n " ; $self , $class ; return $ selbst } sub setFirstName { Mein ( $self , $firstName ) = @_ ; $self -> { _firstName } = $firstName Wenn definiert ( $firstName ) ; return $ self -> { _firstName } ; sub getFirstName { Mein ( $selbst ) = @_ ; zurück $ self -> { _firstName } ; 1 ;

Der Skriptcode „employee.pl“ lautet wie folgt:

Beispiel

#!/usr/bin/perl benutze Person ; $object = new Person ( „ Xiao Ming “ , „王“ , 23234345 ) # Holen Sie sich den Namen $firstName = $object -> getFirstName ( ) ; print " Setzen Sie den vorherigen Namen auf: $firstName n " # Verwenden Sie Hilfsfunktionen, um den Namen festzulegen $object -> setFirstName ( „ Xiaoqiang “ ) ; # Holen Sie sich den Namen über die Hilfsfunktion $firstName = $object -> getFirstName ( ) ; print „ Der Name nach der Einstellung ist: $firstName n “ ;

Nach der Ausführung des obigen Programms lautet das Ausgabeergebnis:

 $ perl Employee.pl Name: Xiao Ming Nachname: Wang Nummer: 23234345 Name vor Einstellung: Xiao Ming Name nach Einstellung: Xiao Qiang

erben

Klassenmethoden in Perl werden über das @ISA-Array vererbt. Dieses Array enthält die Namen anderer Pakete (Klassen). Die Vererbung von Variablen muss explizit festgelegt werden.

Mehrfachvererbung bedeutet, dass das @ISA-Array mehrere Klassennamen (Paketnamen) enthält.

Über @ISA können nur Methoden geerbt werden, keine Daten.

Als nächstes erstellen wir eine Employee-Klasse, die die Person-Klasse erbt.

Der Code der Datei „Employee.pm“ sieht folgendermaßen aus:

Beispiel

#!/usr/bin/perl Paket Mitarbeiter ; verwenden Sie Person ; verwenden Sie strikt unser @ISA = qw( Person ) ; #Geerbt von Person

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

Beispiel

#!/usr/bin/perl benutze Employee ; $object = new Mitarbeiter ( „ Xiao Ming “ , „王“ , 23234345 ) # Holen Sie sich den Namen $firstName = $object -> getFirstName ( ) ; print " Setzen Sie den vorherigen Namen auf: $firstName n " # Verwenden Sie Hilfsfunktionen, um den Namen festzulegen $object -> setFirstName ( „ Xiaoqiang “ ) ; # Holen Sie sich den Namen über die Hilfsfunktion $firstName = $object -> getFirstName ( ) ; print „ Der Name nach der Einstellung ist: $firstName n “ ;

Nach der Ausführung des obigen Programms lautet das Ausgabeergebnis:

 $ perl main.pl Name: Xiao Ming Nachname: Wang Nummer: 23234345 Name vor der Einstellung ist: Xiao Ming Name nach der Einstellung: Xiao Qiang

Überschreibende Methode

Im obigen Beispiel erbt die Employee-Klasse die Person-Klasse, aber wenn die Methoden der Person-Klasse die Anforderungen nicht erfüllen können, müssen ihre Methoden neu geschrieben werden.

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

Beispiel

#!/usr/bin/perl Paket Mitarbeiter ; verwenden Sie Person ; verwenden Sie strikt unser @ISA = qw( Person ) ; #Geerbt von Person # Konstruktor überschreiben sub neu { Mein ( $class ) = @_ ; # Rufen Sie den Konstruktor der übergeordneten Klasse auf Mein $self = $class -> SUPER :: new ( $_ [ 1 ] , $_ [ 2 ] , $_ [ 3 ] ) ; # Weitere Attribute hinzufügen $self -> { _id } = undef ; $ self -> { _title } = undef ; $self , $class ; return $ selbst } # Methode überschreiben sub getFirstName { Mein ( $selbst ) = @_ ; # Dies ist eine Unterklassenfunktion drucken „ Dies ist eine Unterklassenfunktion n “ ; $ self -> { _firstName } ; # Methode hinzufügen sub setLastName { Mein ( $self , $lastName ) = @_ ; $self -> { _lastName } = $lastName Wenn definiert ( $lastName ) ; return $ self -> { _lastName } ; sub getLastName { Mein ( $selbst ) = @_ ; zurück $ self -> { _lastName } ; 1 ;

Wir geben den folgenden Code in die Datei main.pl ein und führen ihn aus:

Beispiel

#!/usr/bin/perl benutze Employee ; $object = new Mitarbeiter ( „ Xiao Ming “ , „ Wang “ , 23234345 ) # Holen Sie sich den Namen und verwenden Sie den geänderten Konstruktor $firstName = $object -> getFirstName ( ) ; print " Setzen Sie den vorherigen Namen auf: $firstName n " # Verwenden Sie Hilfsfunktionen, um den Namen festzulegen $object -> setFirstName ( „ Xiaoqiang “ ) ; # Holen Sie sich den Namen über die Hilfsfunktion $firstName = $object -> getFirstName ( ) ; print „ Der Name nach der Einstellung ist: $firstName n “ ;

Nach der Ausführung des obigen Programms lautet das Ausgabeergebnis:

 $ perl main.pl Name: Xiao Ming Nachname: Wang Nummer: 23234345 Dies ist der Name der Unterklassenfunktion vor der Einstellung: Xiao Ming Dies ist der Name der Unterklassenfunktion nach der Einstellung: Xiaoqiang

Standardmäßig geladen

Wenn die angeforderte Methode nicht in der aktuellen Klasse, allen Basisklassen der aktuellen Klasse und der UNIVERSAL-Klasse gefunden wird, wird erneut nach einer Methode namens AUTOLOAD() gesucht. Wenn AUTOLOAD gefunden wird, wird es aufgerufen und die globale Variable $AUTOLOAD wird auf den vollständig qualifizierten Namen der fehlenden Methode gesetzt.

Wenn das nicht funktioniert, schlägt Perl mit einem Fehler fehl.

Wenn Sie AUTOLOAD nicht von der Basisklasse erben möchten, ist es ganz einfach, nur ein Satz:

 sub AUTOLOAD;

Destruktor und Garbage Collection

Das Objekt wird automatisch zerstört, wenn der letzte Verweis auf das Objekt freigegeben wird.

Wenn Sie während der Zerstörung etwas tun möchten, können Sie in der Klasse eine Methode namens „DESTROY“ definieren. Es wird zum richtigen Zeitpunkt automatisch aufgerufen und führt nach Wunsch weitere Bereinigungsaktionen durch.

 package MyClass;...sub DESTROY{ print "MyClass::DESTROY aufgerufenn";}

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 $_[0] ändern können. (Anmerkung des Übersetzers: Siehe perlsub) Aber das Objekt selbst (wie „${$_[0]“ oder „@{$_[0]}“ und „%{$_[0]}“ usw.) kann noch geschrieben werden.

Wenn Sie einen Objektverweis vor der Rückkehr des Destruktors erneut selektieren, ruft Perl nach der Rückkehr des Destruktors die DESTROY-Methode des Objekts auf, das Sie reaktiviert haben. Dadurch haben Sie die Möglichkeit, den Destruktor der Basisklasse oder anderer von Ihnen angegebener Klassen aufzurufen. Es ist zu beachten, dass DESTROY auch manuell aufgerufen werden kann, dies ist jedoch in der Regel nicht erforderlich.

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

Beispiele für objektorientierte Perl-Objekte

Anhand der folgenden Beispiele können wir die objektorientierte Anwendung von Perl besser verstehen:

Beispiel

#!/usr/bin/perl #Das Folgende ist eine einfache Klassenimplementierung Paket MyClass ; sub neu { drucken " MyClass::new aufgerufen n " ; my $type = shift ; # Paketname Mein $self = { } ; # Referenz auf leeren Hash zurückkehren segnen $self , $ type } sub ZERSTÖREN { drucken " MyClass::DESTROY aufgerufen n " ; sub MeineMethode { drucken " MyClass::MyMethod aufgerufen! n " } #Vererbungsimplementierung Paket MySubClass ; @ISA = qw ( MyClass ) ; neu { drucken " MySubClass::new aufgerufen n " ; my $type = shift ; # Paketname Mein $self = MyClass -> new ; # Referenz leerer Hash zurückkehren segnen $self , $ type } sub ZERSTÖREN { drucken " MySubClass::DESTROY aufgerufen n " } sub MeineMethode { Mein $self = shift ; $self -> SUPER :: MyMethod ( ) ; print " MySubClass:: MyMethod aufgerufen! n " } # Rufen Sie das Hauptprogramm der obigen Klasse auf Paket main ; drucken „ MyClass-Methode aufrufen n “ ; $myObject = MyClass -> new ( ) ; $ myObject -> MyMethod ( ) ; „ MySubClass - Methode aufrufen n “ ; $ myObject2 = MySubClass - > new ( ) ;​ „ Erstelle ein Bereichsobjekt n “ ; Mein $myObject2 = MyClass - > new ( ) ; # Rufen Sie den Destruktor automatisch auf drucken „ Objekt erstellen n “ ; $myObject3 = MyClass - > new ( ) ; $myObject3 ; drucken " Skriptausführung endet... n " # Den Destruktor automatisch ausführen

Wenn Sie das obige Programm ausführen, lautet das Ausgabeergebnis:

 Rufen Sie die MyClass-Methode MyClass::new aufgerufenMyClass::MyMethod aufgerufen auf! Rufen Sie die MySubClass-Methode MySubClass::new aufgerufenMyClass::MyMethod aufgerufen auf! aufgerufen Objekt erstellen MyClass::new aufgerufen MyClass::DESTROY aufgerufen Skriptausführung endet...MyClass::DESTROY aufgerufenMySubClass::DESTROY aufgerufen