Perl orientada a objetos

Siguiente: Conectividad de base de datos Perl

Hay dos diferentes Perl para poner en práctica la programación orientada a objetos:

Un enfoque basado en la tabla hash en el anonimato, la esencia de cada instancia de objeto es un punto de referencia a una tabla hash anónimo. En esta tabla hash anónimo para almacenar todas las propiedades de la instancia.
El segundo se basa en una serie de formas, en la definición de una clase, vamos a crear una propiedad para cada instancia de la matriz, y la esencia de cada instancia de objeto es un puntero a la matriz en una fila de la referencia del índice. En estas matrices, la memoria de todas las propiedades de la instancia.

Conceptos básicos de orientado a objetos

Hay muchos conceptos básicos de orientado a objetos, donde recibimos tres: objetos, clases y métodos.

Objeto: El objeto es un elementos de datos de referencia de clase..
Clase: clase es un paquete de Perl, que contiene el objeto de proporcionar un método de la clase.
Métodos: El método es una subrutina Perl, el nombre de clase es su primer argumento.

Perl proporciona una función de bendecir (), bendiga se utiliza para construir el objeto a través de una referencia y bendecir el nombre asociado a esta clase, devuelva esta referencia para la construcción de un objeto.

definición de clase

Una clase es sólo un paquete simple.

Puede utilizar un paquete como una clase, y poner la bolsa en función del método de la clase de usar.

paquete Perl ofrece un espacio de nombres separado, el método de diferentes paquetes y los nombres de variables no contradigan.

el archivo Perl clases de extensión para .pm.

A continuación, creamos una clase Persona:

package Person;

rango de código de la clase a la última línea del archivo de comandos, o para un paquete antes de la próxima palabra clave.

Creación y uso de objetos

Crear una instancia de clase (objeto) es necesario definir un constructor, la mayoría de los programas utilizan el nombre de clase como un constructor, Perl puede utilizar cualquier nombre.

Se puede utilizar una variedad de variables como objeto Perl Perl. En la mayoría de los casos vamos a utilizar un array o hash de referencia.

A continuación, creamos un constructor para la clase de persona, utilizamos una referencia a un hash de Perl.

Cuando se crea un objeto, es necesario proporcionar un constructor, que es una subrutina que devuelve una referencia de objeto.

Ejemplos son los siguientes:

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

A continuación, creamos un objeto:

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

método de definición

solamente métodos de clase de Perl, pero es una subrutina Perl, también conocido como funciones miembro.

orientado a objetos definición del método de Perl Perl no proporciona ninguna sintaxis especial, pero el primer parámetro especifica el método para el objeto o paquete se hace referencia.

Perl no proporciona variables privadas, pero podemos gestionar datos de objeto a través del camino auxiliar.

A continuación se define una manera de obtener el nombre de:

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

Lo mismo se puede escribir también:

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

A continuación, modificamos el archivo Person.pm código, de la siguiente manera:

#!/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 código de script es el siguiente:

#!/usr/bin/perl

use Person;

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

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

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

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

Después de ejecutar el programa anterior, la salida es:

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

heredar

Perl en los métodos de clase heredados por @ISA matriz, la matriz que contiene otros paquetes (como) el nombre de la variable se debe establecer de manera explícita a la herencia.

La herencia múltiple es la matriz @ISA que comprende una pluralidad de clase nombre (paquete).

El método sólo puede ser heredada a través @ISA, los datos no pueden ser heredados.

A continuación, creamos un empleado de la clase hereda la clase Persona.

código de archivo Employee.pm es el siguiente:

#!/usr/bin/perl

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

Ahora clase Employee contiene todos los métodos y propiedades de la clase Persona, entramos en el siguiente código en el archivo main.pl y ejecutar:

#!/usr/bin/perl

use Employee;

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

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

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

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

Después de ejecutar el programa anterior, la salida es:

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

sustituye el método

El ejemplo anterior, la clase Empleado extiende la clase persona, pero si los métodos de la clase persona no puede satisfacer la demanda, es necesario volver a escribir sus métodos.

A continuación, añadimos algunos nuevos métodos en la clase de empleado, y anular los métodos de la clase Persona:

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

Entramos en el siguiente archivo main.pl código y ejecutar:

#!/usr/bin/perl

use Employee;

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

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

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

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

Después de ejecutar el programa anterior, la salida es:

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

Cargando predeterminado

Si la clase en la actual, la clase actual de toda la clase base, y métodos de la clase UNIVERSAL solicitada no se encuentra, entonces busca un método llamado AUTOLOAD () de nuevo. Si lo encuentra AUTOLOAD, se llamará, al configurar el nombre completo del valor $ AUTOLOAD variable global de los métodos que faltan.

Si no, entonces no Perl y error.

Si no desea heredar la AUTOLOAD clase base, muy sencillo, basta con una sola frase:

sub AUTOLOAD;

Los destructores y recolección de basura

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

Si usted quiere hacer algo en el destructor cuando puede un método llamado de "destruir" se define en la clase. Se llamará automáticamente al momento apropiado, y para llevar a cabo acciones de limpieza adicionales de acuerdo a lo que quiere decir.

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

se pasará Perl referencia a un objeto de destruir el único parámetro. Tenga en cuenta que esta cita es de sólo lectura, lo que significa que no puede acceder a los $ _ [0] para modificarlo. (Nota del traductor: Ver perlsub), pero el objeto en sí (como "$ {$ _ [0]" o "@ {$ _ [0]}" y "% {$ _ [0]}", etc.) o puede ser escrito.

Si vuelve a bendecir a la referencia del objeto antes de que vuelva destructor, Perl le llamará para volver a bendecir DESTRUIR método de dicho objeto después de que los rendimientos destructor. Esto le permite tener la oportunidad de llamar a la clase base o especifica destructor otras clases. Cabe señalar, destruir también puede ser invocado de forma manual, pero por lo general no es necesario.

Después del lanzamiento del objeto actual, otros objetos contenidos en el objeto actual se liberan automáticamente.

Ejemplos de Perl orientado a objetos

Podemos ser entendido, además, por las siguientes aplicaciones orientadas a objetos de Perl ejemplos:

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

El programa anterior, la 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

Anterior: La programación Perl Socket

Siguiente: Conectividad de base de datos Perl

Perl curso

Perl orientada a objetos

Conceptos básicos de orientado a objetos

definición de clase

Creación y uso de objetos

método de definición

heredar

sustituye el método

Cargando predeterminado

Los destructores y recolección de basura

Ejemplos de Perl orientado a objetos