Perl orientado a objetos

En Perl existen dos implementaciones diferentes de la programación orientada a objetos:

  • Una se basa en tablas hash anónimas: la esencia de cada instancia de objeto es una referencia a una tabla hash anónima. En esta tabla hash anónima se almacenan todos los atributos de la instancia.

  • La otra se basa en arrays. Al definir una clase, creamos un array para cada atributo de instancia, y la esencia de cada instancia de objeto es una referencia a un índice de estos arrays. En estos arrays se almacenan todos los atributos de la instancia.


Conceptos básicos de la orientación a objetos

La programación orientada a objetos tiene muchos conceptos básicos; aquí trataremos tres: objeto, clase y método.

  • Objeto: Un objeto es una referencia a los elementos de datos de una clase.

  • Clase: Una clase es un paquete de Perl que contiene los métodos que proporciona el objeto.

  • Método: Un método es una subrutina de Perl cuyo primer parámetro es el nombre de la clase.

Perl proporciona la función `bless()`, que se usa para construir objetos. Al asociar una referencia con el nombre de la clase mediante `bless`, se devuelve esa referencia y se construye un objeto.


Definición de clases

Una clase es simplemente un paquete.

Se puede utilizar un paquete como una clase y las funciones del paquete como métodos de la clase.

Los paquetes de Perl proporcionan espacios de nombres independientes, por lo que los métodos y nombres de variables de diferentes paquetes no entran en conflicto.

La extensión de archivo de las clases Perl es `.pm`.

A continuación, crearemos una clase `Person`:

package Person;

El código de la clase se extiende hasta la última línea del archivo de script, o hasta antes de la siguiente palabra clave `package`.


Crear y usar objetos

Para crear una instancia (objeto) de una clase, necesitamos definir un constructor. La mayoría de los programas usan el nombre de la clase como constructor, pero en Perl se puede usar cualquier nombre.

Puedes usar varios tipos de variables de Perl como objetos de Perl. En la mayoría de los casos, usamos referencias a arrays o hashes.

A continuación, creamos un constructor para la clase `Person`, usando una referencia a hash de Perl.

Al crear un objeto, debes proporcionar un constructor, que es una subrutina que devuelve una referencia al objeto.

El ejemplo es el siguiente:

Ejemplo

package Person; sub new { my $class = shift; my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Imprimir información del usuario print "Nombre:$self->{_firstName}\n"; print "Apellido:$self->{_lastName}\n"; print "ID:$self->{_ssn}\n"; bless $self, $class; return $self; }

A continuación, creamos un objeto:

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

Definir métodos

Los métodos de una clase Perl son simplemente subrutinas Perl, es decir, lo que comúnmente se llaman funciones miembro.

En la programación orientada a objetos de Perl, la definición de métodos no proporciona ninguna sintaxis especial, pero estipula que el primer parámetro del método es el objeto o el paquete referenciado.

Perl no proporciona variables privadas, pero podemos gestionar los datos del objeto mediante métodos auxiliares.

A continuación, definimos un método para obtener el nombre:

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

También se puede escribir así:

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

A continuación, modificamos el código del archivo `Person.pm`, como se muestra a continuación:

Ejemplo

#!/usr/bin/perl package Person; sub new { my $class = shift; my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Imprimir información del usuario print "Nombre:$self->{_firstName}\n"; print "Apellido:$self->{_lastName}\n"; print "ID:$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;

El código del script `employee.pl` es el siguiente:

Ejemplo

#!/usr/bin/perl use Person; $object = new Person( "Xiaoming", "Wang", 23234345); # Obtener el nombre $firstName = $object->getFirstName(); print "El nombre antes de la asignación es:$firstName\n"; # Usar la función auxiliar para establecer el nombre $object->setFirstName( "Xiaoqiang" ); # Obtener el nombre mediante la función auxiliar $firstName = $object->getFirstName(); print "El nombre después de la asignación es:$firstName\n";

Después de ejecutar el programa anterior, el resultado es:

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

Herencia

En Perl, los métodos de clase se heredan a través del array `@ISA`, que contiene los nombres de otros paquetes (clases). La herencia de variables debe establecerse explícitamente.

La herencia múltiple consiste en que este array `@ISA` contenga los nombres de varias clases (paquetes).

A través de `@ISA` solo se heredan métodos, no datos.

A continuación, creamos una clase `Employee` que hereda de la clase `Person`.

El código del archivo `Employee.pm` es el siguiente:

Ejemplo

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

Ahora la clase `Employee` contiene todos los métodos y atributos de la clase `Person`. Escribimos el siguiente código en el archivo `main.pl` y lo ejecutamos:

Ejemplo

#!/usr/bin/perl use Employee; $object = new Employee( "Xiaoming", "Wang", 23234345); # Obtener el nombre $firstName = $object->getFirstName(); print "El nombre antes de la asignación es:$firstName\n"; # Usar la función auxiliar para establecer el nombre $object->setFirstName( "Xiaoqiang" ); # Obtener el nombre mediante la función auxiliar $firstName = $object->getFirstName(); print "El nombre después de la asignación es:$firstName\n";

Después de ejecutar el programa anterior, el resultado es:

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

Anulación de métodos

En el ejemplo anterior, la clase `Employee` heredó de la clase `Person`, pero si los métodos de `Person` no satisfacen las necesidades, es necesario anularlos.

A continuación, añadimos algunos métodos nuevos a la clase `Employee` y anulamos los métodos de la clase `Person`:

Ejemplo

#!/usr/bin/perl package Employee; use Person; use strict; our @ISA = qw(Person); # Heredar de Person # Anular el constructor sub new { my ($class) = @_; # Llamar al constructor de la clase padre my $self = $class->SUPER::new( $_[1], $_[2], $_[3] ); # Añadir más atributos $self->{_id} = undef; $self->{_title} = undef; bless $self, $class; return $self; } # Anular método sub getFirstName { my( $self ) = @_; # Esta es la función de la subclase print "Esta es la función de la subclase\n"; return $self->{_firstName}; } # Añadir método sub setLastName{ my ( $self, $lastName ) = @_; $self->{_lastName} = $lastName if defined($lastName); return $self->{_lastName}; } sub getLastName { my( $self ) = @_; return $self->{_lastName}; } 1;

Escribimos el siguiente código en el archivo `main.pl` y lo ejecutamos:

Ejemplo

#!/usr/bin/perl use Employee; $object = new Employee( "Xiaoming", "Wang", 23234345); # Obtener el nombre, usando el constructor modificado $firstName = $object->getFirstName(); print "El nombre antes de la asignación es:$firstName\n"; # Usar la función auxiliar para establecer el nombre $object->setFirstName( "Xiaoqiang" ); # Obtener el nombre mediante la función auxiliar $firstName = $object->getFirstName(); print "El nombre después de la asignación es:$firstName\n";

Después de ejecutar el programa anterior, el resultado es:

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

Autocarga

Si no se encuentra el método solicitado en la clase actual, en todas las clases base de la clase actual, ni en la clase `UNIVERSAL`, se busca de nuevo un método llamado `AUTOLOAD()`. Si se encuentra `AUTOLOAD`, se invoca y, al mismo tiempo, se asigna a la variable global `$AUTOLOAD` el nombre completo (fully qualified) del método faltante.

Si aún así no funciona, Perl declara el fallo y produce un error.

Si no quieres heredar el `AUTOLOAD` de la clase base, es muy simple: solo necesitas una línea:

sub AUTOLOAD;

Destructores y recolección de basura

Cuando se libera la última referencia a un objeto, el objeto se destruye automáticamente.

Si deseas hacer algo durante la destrucción, puedes definir un método llamado `DESTROY` en la clase. Se invocará automáticamente en el momento apropiado y realizará las acciones de limpieza adicionales que indiques.

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

Perl pasa la referencia al objeto como único argumento a `DESTROY`. Ten en cuenta que esta referencia es de solo lectura, es decir, no puedes modificarla accediendo a `$_

Si vuelves a aplicar `bless` a la referencia del objeto antes de que el destructor retorne, Perl llamará al método `DESTROY` del objeto al que se le aplicó nuevamente `bless` después de que el destructor retorne. Esto te da la oportunidad de llamar al destructor de la clase base o de cualquier otra clase que especifiques. Cabe señalar que `DESTROY` también puede llamarse manualmente, pero generalmente no es necesario hacerlo.

Después de liberar el objeto actual, los otros objetos contenidos en el objeto actual se liberarán automáticamente.


Ejemplo de Perl orientado a objetos

Podemos comprender mejor la aplicación de la POO en Perl mediante el siguiente ejemplo:

Ejemplo

#!/usr/bin/perl # A continuación se muestra una implementación de clase simple package MyClass; sub new { print "MyClass::new called\n"; my $type = shift; # Nombre del paquete my $self = {}; # Referencia a un hash vacío return bless $self, $type; } sub DESTROY { print "MyClass::DESTROY called\n"; } sub MyMethod { print "MyClass::MyMethod called!\n"; } # Implementación de herencia package MySubClass; @ISA = qw( MyClass ); sub new { print "MySubClass::new called\n"; my $type = shift; # Nombre del paquete my $self = MyClass->new; # Referencia a un hash vacío return bless $self, $type; } sub DESTROY { print "MySubClass::DESTROY called\n"; } sub MyMethod { my $self = shift; $self->SUPER::MyMethod(); print " MySubClass::MyMethod called!\n"; } # Programa principal que llama a las clases anteriores package main; print "Llamando al método MyClass\n"; $myObject = MyClass->new(); $myObject->MyMethod(); print "Llamando al método MySubClass\n"; $myObject2 = MySubClass->new(); $myObject2->MyMethod(); print "Crear un objeto con ámbito\n"; { my $myObject2 = MyClass->new(); } # Llamada automática al destructor print "Crear objeto\n"; $myObject3 = MyClass->new(); undef $myObject3; print "Ejecución del script finalizada...\n"; # Ejecución automática del destructor

Ejecute el programa anterior, el resultado de salida es:

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