Perl obiektowe

Istnieją dwa różne Perl wdrożyć programowania obiektowego:

Jedno podejście anonimowe tablica mieszająca opartych istotą każdej instancji obiektu jest punktem odniesienia do anonimowej tablicy mieszającej. W tej anonimowej tablicy mieszającej przechowywać wszystkie właściwości instancji.
Drugi opiera się na szeregu sposobów, w definicji klasy, będziemy tworzyć właściwości dla każdej instancji tablicy, a istotą każdej instancji obiektu jest wskaźnikiem do tablicy z rzędu odniesienia indeksu. W tych tablic, pamięć o wszystkich właściwości instancji.

Podstawowe koncepcje zorientowane obiektowo

Istnieje wiele podstawowych pojęć zorientowanym obiektowo, gdzie otrzymaliśmy trzy: Przedmioty, klas i metod.

Obiekt: obiekt jest klasy elementy danych referencyjnych.,
Klasy: Klasa jest pakiet Perl, który zawiera celem jest zapewnienie sposobu klasy.
Metody: metoda jest podprogram Perl, nazwa klasy jest jej pierwszy argument.

Perl posiada funkcję bless (), błogosław służy do skonstruowania obiektu poprzez odniesienie i błogosławić nazwę związaną z tej klasy, zwrot ten odnosi się do skonstruowania obiektu.

definicja klasy

Klasa jest tylko prosty pakiet.

Można użyć pakietu jako klasa, i umieścić worek w zależności od sposobu korzystania z klasy.

Pakiet Perl zapewnia oddzielną przestrzeń nazw, metoda różnych pakietów i nazwach zmiennych nie są sprzeczne.

Perl złożyć zajęcia terenowe dla .pm.

Następnie tworzymy klasy osoba:

package Person;

Zakres kod klasy do ostatniej linii pliku skryptu lub pakietu przed następnym hasła.

Tworzenie i korzystanie z obiektów

Tworzenie instancji klasy (obiektu) musimy zdefiniować konstruktor, większość programów używa nazwy klasy jako konstruktor, Perl można użyć dowolnej nazwy.

Można używać różnych zmiennych jako obiektu Perl Perl. W większości przypadków będziemy używać odwołania do tablicy lub skrótu.

Następnie tworzymy konstruktora dla klasy Person, użyj skrótu odniesienie Perl.

Podczas tworzenia obiektu, trzeba zapewnić konstruktora, który jest podprogram, która zwraca odwołanie do obiektu.

Przykłady są następujące:

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

Następnie tworzymy obiekt:

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

metoda definicja

tylko Perl metody klasy, ale jest to podprogram Perl, znany również jako funkcji składowych.

Perl Perl definicja metody zorientowane obiektowo nie przewiduje żadnej specjalnej składni, ale pierwszy parametr określa metodę odwołania obiektu lub opakowaniu.

Perl nie zapewniają zmiennych prywatnych, ale możemy zarządzać danymi obiektów poprzez sposób pomocniczy.

Następnie zdefiniować sposób, aby uzyskać nazwę:

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

To samo można też napisać:

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

Następnie zmodyfikować plik Person.pm kodu w następujący sposób:

#!/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 kod skryptu jest następująca:

#!/usr/bin/perl

use Person;

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

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

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

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

Po wykonaniu powyższej programu wyjście jest:

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

dziedziczyć

Perl metody klasy kolejno tablicy @ISA, tablicy, która zawiera inne pakiety (klasa) imię, odziedziczyć zmiennej muszą być wyraźnie określone.

Wielokrotne dziedziczenie jest tablica @ISA zawierający liczne klasy (pakiet) nazwy.

Metoda ta może być dziedziczone tylko przez @ISA, dane nie mogą być dziedziczone.

Następnie tworzymy pracownika klasa dziedziczy klasę osoby.

Kod pliku Employee.pm przedstawia się następująco:

#!/usr/bin/perl

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

Teraz class Employee zawiera wszystkie metody i właściwości klasy Person, wchodzimy następujący kod w pliku main.pl i wykonanie:

#!/usr/bin/perl

use Employee;

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

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

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

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

Po wykonaniu powyższej programu wyjście jest:

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

metoda nadpisania

W powyższym przykładzie, klasa Pracownik rozszerza klasę osoby, ale jeśli metody klasy Osoba nie może zaspokoić popyt, konieczne jest, aby przerobić swoje metody.

Następnie dodajemy kilka nowych metod w klasie Employee, i zastąpić metody klasy Person:

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

Mamy wprowadzić kod następujący plik main.pl i wykonanie:

#!/usr/bin/perl

use Employee;

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

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

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

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

Po wykonaniu powyższej programu wyjście jest:

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

domyślnym Ładowanie

Jeśli klasa w prądu, bieżącej klasy całej klasy bazowej i metod klasy UNIVERSAL żądanych nie można znaleźć, a potem szuka metody nazwanej autoLoad () ponownie. Jeśli okaże autoLoad będzie zadzwonić, podczas ustawiania pełną nazwę zmiennej globalnej wartości $ autoLoad brakujących metod.

Jeśli nie, to nie udało Perl i błędów.

Jeśli nie chcesz, aby odziedziczyć autoLoad klasy bazowej, bardzo proste, wystarczy jedno zdanie:

sub AUTOLOAD;

Destruktorów i zbierania śmieci

Kiedy ostatni odniesienie do obiektu zostaje zwolniony, obiekt jest automatycznie zniszczona.

Jeśli chcesz coś zrobić w destructor, kiedy można to metoda nazywa się "zniszczyć" jest zdefiniowane w klasie. Będzie on automatycznie wywołać odpowiedni czas, a do wykonywania dodatkowych czynności oczyszczania według tego, co masz na myśli.

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

Perl odwołanie do obiektu zostaną przekazane do zniszczenia jako jedyny parametr. Zauważ, że ten cytat jest tylko do odczytu, co oznacza, że nie może uzyskać dostępu do $ _ [0], aby go zmodyfikować. (Tłumacza Uwaga: Patrz perlsub), ale sam obiekt (takie jak "$ {$ _ [0]" lub "@ {$ _ [0]}" i "% {$ _ [0]}", etc.) lub może być napisane.

Jeśli ponownie błogosławi odniesienie do obiektu przed powrotem destructor, Perl wtedy zadzwonić ponownie błogosławi DESTROY metoda tego obiektu po powrocie destructor. To pozwala mieć możliwość, aby zadzwonić do klasy bazowej lub określić spalające inne klasy. Należy zauważyć, zniszczyć może być również wywoływany ręcznie, ale zwykle nie jest to konieczne.

Po wydaniu bieżącego obiektu, inne obiekty znajdujące się w bieżącym obiekcie zostaje automatycznie zwolniony.

Przykłady obiektowego Perl

Możemy być ponadto zrozumiałe następujących zastosowań obiektowych przykłady Perl

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

Powyższy program, wyjście jest:

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

Poprzedni: Perl Socket Programowanie

Dalej: Perl Database Connectivity

Perl kurs

Perl obiektowe

Podstawowe koncepcje zorientowane obiektowo

definicja klasy

Tworzenie i korzystanie z obiektów

metoda definicja

dziedziczyć

metoda nadpisania

domyślnym Ładowanie

Destruktorów i zbierania śmieci

Przykłady obiektowego Perl