Perl Orientado a Objeto Part II
Tags: perl, braziliandevs, opensource, poo
Published: 2022-04-23 13:09:49

---

Como começar a programar em **Perl** da maneira correta. ~~(Diferente de mim)~~

[Perl Orientado a Objeto Part I]
(https://dev.to/victoriabispo/perl-orientado-a-objeto-1bd1/)

[Perl Orientado a Objeto Part II](https://dev.to/victoriabispo/perl-orientado-a-objeto-part-ii-2o54)

[Perl Orientado a Objeto Part III](https://dev.to/victoriabispo/perl-orientado-a-objeto-part-iii-4fe2)

[Moo - Orientação de objeto minimalista](https://dev.to/victoriabispo/moo-orientacao-de-objeto-minimalista-6el)

# Os 4 pilares da Programação Orientada a Objetos

Abstração, encapsulamento, herança e polimorfismo são os quatro pilares de qualquer linguagem orientada a objetos. E como aprendemos no [post passado](https://dev.to/victoriabispo/perl-orientado-a-objeto-1bd1) o Perl é uma linguagem que da suporte a orientação a objeto a partir da sua versão 5. A seguir vou dar exemplos a vocês de como podemos implementar esses pilares.

<aside>
⚠️ Este post não tem como objetivo definir orientação a objeto com Perl, mas sim aprofundar conhecimentos prévios que você tenha baseando-se na linguagem. por tanto ele leva em consideração que você, leitor, tenha conhecimento de lógica e linguagem e programação e saiba algumas definições de orientação a objeto.

</aside>

## Abstração

O primeiro pilar fala sobre como vamos representar os objetos dentro no nosso programa, é o que Moose é uma extensão do sistema de objetos da linguagem de programação Perl . Seu propósito declarado [1] é trazer recursos modernos de linguagem orientada a objetos para o Perl 5 e tornar a programação Perl orientada a objetos mais consistente e menos tediosa.vai também facilitar a leitura do nosso código por terceiro. É importante ter clareza ao dar nome a nossas Classes, Atributos e Métodos. 

## Encapsulamento

O encapsulamento trata da segurança das partes do seu programa. Quem implementa suas classes com seus atributos e usa seus métodos não precisa saber de tudo que se passa dentro da sua construção a não ser o que está na sua API.

## Polimorfismo

O polimorfismo é referente a capacidade que a linguagem tem de identificar e diferenciar entidades, métodos ou atributos com mesmo nome de maneira eficiente.

A seguir irei mostrar os principais polimorfismos em Perl:

### Substituição

```perl
#!/usr/bin/perl
use strict; # Error readability
use warnings;

package controller::Calculation;

use model::Performances;

# We declare entity and assign the value of tragedy with its attributes
my $entity = model::Performances::Tragedy->new('othelo',55); 
# Then we replace entity with the value returned from one of its methods
my $entity = $entity->amount_for();
```

### Sobrecarga

```perl
#!/usr/bin/perl
use strict; # Error readability
use warnings;

package model::Performances::Tragedy; # Child Class

use parent 'Performances';  # Parent Class 

sub new { # writing over the Performances builder
	my $this = shift;
	my $class = ref ($this) || $this;
	my $name = shift;
	my $audience = shift;

	my $self = new Performances($name,$audience,TYPE_PLAY->{tragedy});
	
	return bless $self, $class;

}
```

### Inclusão

Que é o tipo de polimorfismo de herança que veremos a seguir. 

## Herança

E é aqui onde o POO ganha meu coração🥰
É com a herança que podemos aplicar a abstração e o encapsulamento para melhorar nossos códigos. 

- Evitando repetições “herdando” métodos semelhantes ou re-escrevendo os mesmos;
- Utilizando os mesmos atributos para diferentes classes (não tão diferentes assim) para evitar classes de linhas quilométricas;

A herança no Perl pode ser implementada com o uso de pacotes no seu código, que como aprendemos anteriormente, os pacotes serão as classes. Cada pacote em perl tem um array especial chamado *@ISA* que guarda toda a hierarquia de classes pai daquela classe. Veja o código a seguir, continuando a linha de raciocínio anterior:

```perl
#!/usr/bin/perl
use strict; # Error readability
use warnings;
use constant # Creating constants for play types
    TYPE_PLAY => {
        "tragedy" => 40,
    };

package model::Performances::Tragedy; # Child Class
@Performances::Tragedy::ISA = ('Performances'); # Parent Class
```

A atribuição feita na linha “@Performances::Tragedy::ISA = ('Performances');” indica que a classe Tragedy é uma filha da classe Perfomances, por tanto herda todos seus atributos e sub-rotinas.

Entretanto não existe a necessidade de atribuirmos diretamente ao array *@ISA* todas as heranças de nossas classes, dado que em um sistema mais complexo que possa envolver enrança múltipla ou que a arvore de herança fique muito grande, possamos encontrar dificuldades. Mas ainda podemos encontrar essas atribuições em códigos antigos.

Além de atribuir diretamente ao *@ISA*, podemos encontrar o uso de *base* para indicar herança dentro do Perl. Porém esse uso não é mais aconselhado a partir do momento que foi criado o *parent,* que é uma versão do *base* mais limpa. A seguir podemos observar um exemplo de como usar o *parent* na classe Comedy:

```perl
#!/usr/bin/perl
use strict; # Error readability
use warnings;
use constant # Creating constants for play types
    TYPE_PLAY => {
        "tragedy" => 40,
        "comedy" => 60
    };
package model::Performances::Comedy; # Class
use parent 'Performances';    # sets @Performances::Comedy::ISA = ('Performances');
```

###Principais características de *base* e *parent:*

O *[base](http://perldoc.perl.org/base.html)* faz as seguintes coisas:
- Adiciona o pacote nomeado a *@ISA;*
- Carrega o módulo com o mesmo nome do pacote nomeado usando *[require](https://perldoc.perl.org/functions/require)* (a menos que detecte que o pacote já foi carregado);
- Não falhará se um módulo com o mesmo nome do pacote não existir;
- Morre se não houver símbolos no pacote nomeado;
- Inicializa o *[fields]http://perldoc.perl.org/fields.html)* do pacote nomeado se eles existirem;

O *[parent](http://search.cpan.org/dist/parent/lib/parent.pm)* faz as seguintes coisas:

- Adiciona o pacote nomeado a *@ISA;*
- carrega o módulo com o mesmo nome do pacote nomeado usando *[require](https://perldoc.perl.org/functions/require)* (a menos que detecte que o pacote já foi carregado)
- Não chama a função de importação do pacote nomeado;
- A opção norequire diz para não fazer o require (então a classe já deve estar carregada). Isso significa que ele não precisa interceptar erros e decidir se eles devem ser suprimidos ou não.

<aside>
👋🏻 Então pessoal, esses foram os pilares da Programação Orientada a Objetos no perl. Continuem de olho que logo mais farei publicações sobre o Moose e o Moo, suas diferenças e outras aplicações voltadas a essa linguagem de programação tão abrangente. Até a próxima.

</aside>