Perl orienté objet

Suivant: connexion de base de données Perl

Il y a deux Perl différents pour mettre en œuvre la programmation orientée objet:

Une approche basée sur la table de hachage anonyme, l'essence de chaque instance d'objet est un point de référence à une table de hachage anonyme. Dans cette table de hachage anonyme pour stocker toutes les propriétés de l'instance.
Le second est basé sur un éventail de moyens, dans la définition d'une classe, nous allons créer une propriété pour chaque instance de la matrice, et l'essence de chaque instance d'objet est un pointeur vers le tableau dans une rangée la référence de l'indice. Dans ces tableaux, la mémoire de toutes les propriétés de l'instance.

Les concepts de base de orienté objet

Il y a beaucoup de concepts de base de orienté objet, où nous avons reçu trois: objets, classes et méthodes.

Objet: L'objet est une référence de classe des éléments de données..
Classe: Perl est un paquet qui contient l'objet de fournir une méthode de la classe.
Méthodes: La méthode est un sous - programme Perl, le nom de classe est son premier argument.

Perl fournit une fonction bless (), bénissez est utilisé pour construire l'objet à travers une référence et bénissez le nom associé à cette classe, retourner cette référence pour construire un objet.

définition de classe

Une classe est juste un paquet simple.

Vous pouvez utiliser un package en tant que classe, et mettre le sac en fonction de la méthode de classe à utiliser.

package Perl fournit un espace de noms séparé, méthode de forfaits et les noms de variables ne le font pas de conflit.

fichier Perl classes d'extension pour .pm.

Ensuite, nous créons une classe Person:

package Person;

plage de codes de classe à la dernière ligne du fichier de script, ou à un forfait avant le mot clé suivant.

Création et utilisation d'objets

Créer une instance de classe (objet), nous devons définir un constructeur, la plupart des programmes utilisent le nom de la classe en tant que constructeur, Perl peut utiliser le nom.

Vous pouvez utiliser une variété de variables comme objet Perl Perl. Dans la plupart des cas, nous allons utiliser une référence de tableau ou de hachage.

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

Lorsque vous créez un objet, vous devez fournir un constructeur, qui est un sous-programme qui retourne une référence d'objet.

Des exemples sont les suivants:

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

Ensuite, nous créons un objet:

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

méthode de définition

les méthodes de classe Perl seulement, mais il est un sous-programme Perl, également connu en tant que fonctions membres.

Object-oriented méthode Perl Perl définition ne fournit aucune syntaxe particulière, mais le premier paramètre spécifie la méthode de l'objet ou package référencé.

Perl ne fournit pas des variables privées, mais nous pouvons gérer les données d'objets par la voie auxiliaire.

Ensuite, nous définissons un moyen d'obtenir le nom:

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

La même chose peut également écrire:

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

Ensuite, on modifie le fichier Person.pm de code, comme suit:

#!/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 code de script est la suivante:

#!/usr/bin/perl

use Person;

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

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

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

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

Après l'exécution du programme ci-dessus, dont la sortie est la suivante:

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

hériter

les méthodes de classe Perl successivement par tableau @ISA, le tableau qui contient d'autres packages (classe) nom, hérite de la variable doivent être explicitement définis.

L'héritage multiple est le tableau @ISA comprenant une pluralité de classe (package) nom.

La méthode ne peut être héritée par @ISA, les données ne peuvent être héritées.

Ensuite, nous créons un employé de classe hérite la classe Person.

Code de fichier Employee.pm est la suivante:

#!/usr/bin/perl

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

Maintenant, la classe Employee contient toutes les méthodes et propriétés de la classe Person, nous entrons dans le code suivant dans le fichier main.pl et exécuter:

#!/usr/bin/perl

use Employee;

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

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

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

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

Après l'exécution du programme ci-dessus, dont la sortie est la suivante:

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

remplacements Méthode

L'exemple ci-dessus, la classe des employés étend la classe personne, mais si les méthodes de la classe Personne ne peut répondre à la demande, il est nécessaire de réécrire ses méthodes.

Ensuite, nous ajoutons de nouvelles méthodes dans la classe des employés, et remplacent les méthodes de la classe Personne:

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

Nous entrons dans le fichier main.pl de code suivant et exécuter:

#!/usr/bin/perl

use Employee;

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

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

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

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

Après l'exécution du programme ci-dessus, dont la sortie est la suivante:

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

Chargement par défaut

Si la classe dans le courant, la classe actuelle de toute la classe de base, et les méthodes de la classe UNIVERSAL demandée ne peut pas être trouvée, cherche une méthode nommée AUTOLOAD () à nouveau. Si trouvé AUTOLOAD, il va appeler, tout en mettant le nom complet de la valeur $ AUTOLOAD variable globale des méthodes manquantes.

Dans le cas contraire, il n'a pas Perl et erreur.

Si vous ne voulez pas hériter de la AUTOLOAD de classe de base, très simple, juste une phrase:

sub AUTOLOAD;

Destructeurs et collecte des ordures

Lorsque la dernière référence à un objet est libéré, l'objet est automatiquement détruit.

Si vous voulez faire quelque chose dans le destructeur quand vous pouvez une méthode appelée "destroy" est défini dans la classe. Il appellera automatiquement en temps opportun, et d'effectuer des actions de nettoyage supplémentaires en fonction de ce que vous entendez.

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

Perl référence d'objet sera passé à détruire le seul paramètre. Notez que cette citation est en lecture seule, ce qui signifie que vous ne pouvez pas accéder au $ _ [0] pour le modifier. (Note du traducteur: Voir perlsub), mais l'objet lui-même (comme "$ {$ _ [0]" ou "@ {$ _ [0]}" et "% {$ _ [0]}", etc.) ou peut être écrite.

Si vous re-bénir la référence d'objet avant le retour de destructor, Perl vous appellera ensuite re-bénir DESTROY méthode de cet objet après le retour de destructor. Cela vous permet d'avoir la possibilité d'appeler la classe de base ou vous spécifiez destructor autres classes. Il convient de noter, DETRUIRE peut également être invoqué manuellement, mais est généralement pas nécessaire.

Après la sortie de l'objet courant, d'autres objets contenus dans l'objet en cours est automatiquement libéré.

Des exemples de Perl orienté objet

Nous pouvons en outre être entendu par les exemples Perl applications orientées objet suivantes:

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

Le programme ci-dessus, le résultat est:

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

Précédent: Programmation Perl Socket

Suivant: Perl Database Connectivity

Perl cours

Perl orienté objet

Les concepts de base de orienté objet

définition de classe

Création et utilisation d'objets

méthode de définition

hériter

remplacements Méthode

Chargement par défaut

Destructeurs et collecte des ordures

Des exemples de Perl orienté objet