Perl orienté objet

Il existe deux implémentations différentes de la programmation orientée objet en Perl :

L'une est basée sur la méthode de la table de hachage anonyme. L'essence de chaque instance d'objet est une référence pointant vers la table de hachage anonyme. Dans cette table de hachage anonyme, tous les attributs d'instance sont stockés.

La seconde est basée sur la méthode array. Lors de la définition d'une classe, nous créerons un tableau pour chaque attribut d'instance, et l'essence de chaque instance d'objet est une référence pointant vers un index de ligne dans ces tableaux. Dans ces tableaux, toutes les propriétés d'instance sont stockées.

Concepts de base orientés objet

Il existe de nombreux concepts de base en orientation objet, ici nous en acceptons trois : les objets, les classes et les méthodes.

Objet : Un objet est une référence à un élément de données dans une classe. .

Classe : Une classe est un package Perl qui contient des classes qui fournissent des méthodes objet.

Méthode : Une méthode est un sous-programme Perl et le nom de la classe est son premier paramètre.

Perl fournit la fonction bless(). Bless est utilisée pour construire des objets. Bless associe une référence au nom de la classe et construit un objet en renvoyant la référence.

Définition de classe

Une classe n’est qu’un simple package.

Vous pouvez utiliser un package en tant que classe et utiliser les fonctions du package en tant que méthodes de la classe.

Les packages Perl fournissent des espaces de noms indépendants, donc les noms de méthodes et de variables dans différents packages n'entreront pas en conflit.

L'extension de fichier des classes Perl est .pm.

Ensuite, nous créons une classe Person :

 Personne de colis ;

La plage de codes de la classe atteint la dernière ligne du fichier script, ou avant le mot-clé suivant du package.

Créer et utiliser des objets

Pour créer une instance (objet) d'une classe, nous devons définir un constructeur. La plupart des programmes utilisent le nom de la classe comme constructeur, mais n'importe quel nom peut être utilisé en Perl.

Vous pouvez utiliser diverses variables Perl comme objets Perl. La plupart du temps, nous utiliserons des tableaux ou des hachages de référence.

Ensuite, nous créons un constructeur pour la classe Person, en utilisant la référence de hachage de Perl.

Lors de la création d'un objet, vous devez fournir un constructeur, qui est un sous-programme qui renvoie une référence à l'objet.

Les exemples sont les suivants :

Exemple

emballer Personne sous ; nouveau { mon $class = décalage ; mon $soi = { _firstName => shift , _lastName => shift , _ssn => shift , } # Afficher les informations utilisateur ; imprimer " Nom : $self - >{_firstName} n " ; " Nom : $self - >{_lastName} n " ; " Numéro : $self ->{_ssn} n " ; $self , $class retourne ; $soi ; }

Ensuite, nous créons un objet :

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

Définir la méthode

La méthode de la classe Perl n’est qu’un sous-programme Perl, communément appelé fonction membre.

La définition de méthode Perl en Perl orienté objet ne fournit aucune syntaxe spéciale, mais stipule que le premier paramètre de la méthode est un objet ou son package référencé.

Perl ne fournit pas de variables privées, mais nous pouvons gérer les données des objets via des méthodes auxiliaires.

Ensuite, nous définissons une méthode pour obtenir le nom :

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

Vous pouvez également écrire ainsi :

 sub setFirstName { my ( $self, $firstName ) = @_; $self->{_firstName} = $firstName si défini($firstName);

Ensuite nous modifions le code du fichier Person.pm comme suit :

Exemple

#!/usr/bin/perl emballer Personne sous ; nouveau { mon $class = décalage ; mon $soi = { _firstName => shift , _lastName => shift , _ssn => shift , } # Afficher les informations utilisateur ; imprimer " Nom : $self - >{_firstName} n " ; " Nom : $self - >{_lastName} n " ; " Numéro : $self ->{_ssn} n " ; $self , $class retourne ; $soi ; } sous setFirstName { mon ( $ moi , $ prénom ) = @_ $self - > { _firstName } = $firstName si défini ( $ firstName ) ; $soi - > { _firstName } ; sous obtenirPremierNom { mon ( $soi ) = @_ ; retourner $soi - > { _firstName } ; 1 ;

Le code du script employe.pl est le suivant :

Exemple

#!/usr/bin/perl utiliser Personne ; $object = nouveau Personne ( " Xiao Ming " , "王" , 23234345 ) # Obtenir le nom $firstName = $object - > getFirstName ( ) ; " Définissez le nom précédent sur : $firstName n " ; # Utilisez les fonctions auxiliaires pour définir le nom $objet -> setFirstName ( " Xiaoqiang " ) ; # Récupère le nom via la fonction d'assistance $firstName = $object - > getFirstName ( ) ; " Le nom après le paramètre est : $firstName n " ;

Après avoir exécuté le programme ci-dessus, le résultat de sortie est :

 $ perl employe.pl Nom : Xiao Ming Nom de famille : Wang Numéro : 23234345 Le nom avant le réglage est : Xiao Ming Nom après le réglage : Xiao Qiang

hériter

Les méthodes de classe en Perl sont héritées via le tableau @ISA. Ce tableau contient les noms d'autres packages (classes). L'héritage des variables doit être explicitement défini.

L'héritage multiple signifie que le tableau @ISA contient plusieurs noms de classe (package).

Seules les méthodes peuvent être héritées via @ISA, pas les données.

Ensuite, nous créons une classe Employee qui hérite de la classe Person.

Le code du fichier Employee.pm ressemble à ceci :

Exemple

#!/usr/bin/perl emballer Employé ; UtiliserPerson ; Utiliser strict ; @ISA = qw( Personne ) ; #Hérité de Personne

Désormais, la classe Employee contient toutes les méthodes et propriétés de la classe Person. Nous entrons le code suivant dans le fichier main.pl et l'exécutons :

Exemple

#!/usr/bin/perl utiliser Employé ; $object = nouveau Employé ( " Xiao Ming " , "王" , 23234345 ) # Obtenir le nom $firstName = $object - > getFirstName ( ) ; " Définissez le nom précédent sur : $firstName n " ; # Utilisez les fonctions auxiliaires pour définir le nom $objet -> setFirstName ( " Xiaoqiang " ) ; # Récupère le nom via la fonction d'assistance $firstName = $object - > getFirstName ( ) ; " Le nom après le paramètre est : $firstName n " ;

Après avoir exécuté le programme ci-dessus, le résultat de sortie est :

 $ perl main.pl Nom : Xiao Ming Nom de famille : Wang Numéro : 23234345 Le nom avant le réglage est : Xiao Ming Nom après le réglage : Xiao Qiang

Remplacement de méthode

Dans l'exemple ci-dessus, la classe Employee hérite de la classe Person, mais si les méthodes de la classe Person ne peuvent pas répondre aux exigences, ses méthodes doivent être réécrites.

Ensuite, nous ajoutons de nouvelles méthodes à la classe Employee et remplaçons les méthodes de la classe Person :

Exemple

#!/usr/bin/perl emballer Employé ; UtiliserPerson ; Utiliser strict ; @ISA = qw( Personne ) ; #Hérité de Personne # Remplacer le constructeur sous nouveau { mon ( $class ) = @_ ; # Appeler le constructeur de la classe parent mon $self = $class -> SUPER :: nouveau ( $_ [ 1 ] , $_ [ 2 ] , $_ [ 3 ] ) ; # Ajouter plus d'attributs $self -> { _id } = undef ; $self -> { _title } = undef bénir ; $self , $class retourne ; $soi ; } # Remplacer la méthode sous obtenirPremierNom { mon ( $soi ) = @_ ; # Ceci est une fonction de sous-classe imprimer " Ceci est une fonction de sous-classe n " ; $soi - > { _firstName } ; # Ajouter une méthode sous setLastName { mon ( $ moi , $ nom de famille ) = @_ $self - > { _lastName } = $lastName si défini ( $ lastName ) ; $soi - > { _lastName } ; sous getLastName { mon ( $soi ) = @_ ; retourner $soi - > { _lastName } ; 1 ;

Nous entrons le code suivant dans le fichier main.pl et l'exécutons :

Exemple

#!/usr/bin/perl utiliser Employé ; $object = nouveau Employé ( " Xiao Ming " , " Wang " , 23234345 ) # Récupère le nom, utilise le constructeur modifié $firstName = $object - > getFirstName ( ) ; " Définissez le nom précédent sur : $firstName n " ; # Utilisez les fonctions auxiliaires pour définir le nom $objet -> setFirstName ( " Xiaoqiang " ) ; # Récupère le nom via la fonction d'assistance $firstName = $object - > getFirstName ( ) ; " Le nom après le paramètre est : $firstName n " ;

Après avoir exécuté le programme ci-dessus, le résultat de sortie est :

 $ perl main.pl Nom : Xiao Ming Nom de famille : Wang Numéro : 23234345 Ceci est le nom de la fonction de sous-classe avant la définition : Xiao Ming Ceci est le nom de la fonction de sous-classe après la configuration : Xiaoqiang

Chargé par défaut

Si la méthode demandée est introuvable dans la classe actuelle, dans toutes les classes de base de la classe actuelle ou dans la classe UNIVERSAL, une méthode nommée AUTOLOAD() sera à nouveau recherchée. Si AUTOLOAD est trouvé, il est appelé et la variable globale $AUTOLOAD est définie sur le nom complet de la méthode manquante.

Si cela ne fonctionne pas, Perl échoue avec une erreur.

Si vous ne souhaitez pas hériter d’AUTOLOAD de la classe de base, c’est très simple, juste une phrase :

 sous CHARGEMENT AUTOMATIQUE ;

Destructeur et garbage collection

L'objet est automatiquement détruit lorsque la dernière référence à l'objet est libérée.

Si vous souhaitez faire quelque chose pendant la destruction, vous pouvez définir une méthode nommée "DESTROY" dans la classe. Il sera automatiquement appelé au moment opportun et effectuera des actions de nettoyage supplémentaires à votre guise.

 package MyClass;...sub DESTROY{ print "MyClass::DESTROY appelén";}

Perl transmettra la référence de l'objet comme seul paramètre à DESTROY. Notez que cette référence est en lecture seule, ce qui signifie que vous ne pouvez pas la modifier en accédant à $_[0]. (Note du traducteur : voir perlsub) Mais l'objet lui-même (tel que "${$_[0]" ou "@{$_[0]}" et "%{$_[0]}", etc.) peut encore être écrit.

Si vous bénissez une référence d'objet avant le retour du destructeur, Perl appellera la méthode DESTROY de l'objet que vous avez béni après le retour du destructeur. Cela vous donne la possibilité d'appeler le destructeur de la classe de base ou d'autres classes que vous spécifiez. Il convient de noter que DESTROY peut également être appelé manuellement, mais ce n'est généralement pas nécessaire.

Une fois l'objet actuel libéré, les autres objets contenus dans l'objet actuel seront automatiquement libérés.

Exemples Perl orientés objet

Nous pouvons mieux comprendre l'application orientée objet de Perl à travers les exemples suivants :

Exemple

#!/usr/bin/perl #Ce qui suit est une implémentation de classe simple emballer Sous -MaClasse ; nouveau { imprimer " MyClass ::new appelé n " ; $type = shift ; # nom du package mon $self = { } ; # Référence au hachage vide retour bénir $soi , $ type } sous DÉTRUIRE { imprimer " MaClasse:: DESTROY appelée n " } sous Ma méthode { imprimer " MaClasse::MaMéthode appelée ! n " } #Mise en œuvre de l'héritage emballer MaSousClasse ; @ISA = qw ( MaClasse ) ; nouveau { imprimer " MySubClass ::new appelé n " ; $type = shift ; # nom du package mon $self = MyClass -> new ; # Référence au hachage vide retour bénir $soi , $ type } sous DÉTRUIRE { imprimer " MySubClass:: DESTROY appelé n " } sous Ma méthode { mon $self = shift ; $self - > SUPER :: MaMéthode ( ) ; " MySubClass:: MyMethod appelé ! n " } # Appelez le programme principal de la classe ci-dessus emballer principal ; imprimer " Appeler la méthode MyClass n " ; $myObject = MyClass -> new ( ) $ myObject - > MyMethod ( ) ; " Appeler la méthode MySubClass n " ; $myObject2 = MySubClass -> new ( ) $ myObject2 - > MyMethod ( ) ; " Créer un objet scope n " ; { mon $monObjet2 = MaClasse - > nouveau ( ) ; # Appeler automatiquement le destructeur imprimer " Créer un objet n " ; $myObject3 = MyClass -> new ( ) ; $monObjet3 ; imprimer " L'exécution du script se termine... n " ; # Exécuter automatiquement le destructeur

En exécutant le programme ci-dessus, le résultat de sortie est :

 Appelez la méthode MyClass MyClass::new approvedMyClass::MyMethod appelée! Appelez la méthode MySubClass MySubClass::new approvedMyClass::new approvedMyClass::MyMethod appelée MySubClass::MyMethod appelée Créez un objet de portée MyClass::new approvedMyClass::DESTROY ! appelé Créer un objet MyClass :: nouveau appelé MyClass :: DESTROY appelé l'exécution du script se termine... MyClass :: DESTROY appeléMySubClass::DESTROY appelé