Ronaldo Ferreira de Lima aka jimmy

Básica Introdução à Programação Orientada a Objeto (POO)
Publicado em 01/09/2010

Básica Introdução à Programação Orientada a Objeto (POO)

Quem começa a dar os primeiros passos na programação, aprendendo lógica, vê-se estudando programação estruturada (ainda que nesse momento esse tipo de coisa ainda não seja clara), ao ser apresentado a uma IDE (Ambiente de Desenvolvimento Integrado), muitas vezes, associa os componentes de construção de interfaces gráficas, como janela, botões etc,como sendo os objetos da POO.

Aqueles componentes, embora, muitas vezes, derivados de POO não tem relação direta com ela. Em POO um objeto é uma abstração para algo do mundo real, bem menos palpável do que o ponteiro do seu mouse sugere. Por exemplo, o ar, que embora não seja palpável, possui algumas características e comportamentos que permite percebê-lo, como composição, temperatura, movimento, direção, velocidade etc, estas características e comportamentos podem ser abstraídos em uma classe.

Em outras palavras, Programação Orientação a Objetos, refere-se ao paradigma de programação onde o desenvolvimento do software é regido pelas definições e relacionamentos entre os objetos que compõem o mesmo. Tem como característica uma maior manutenibilidade em relação a outros métodos de desenvolvimento, e uma maior proximidade entre a análise do problema e a implementação da solução.

Assim como em programação estruturada, onde costuma-se construir o algoritmo por meio de diagramas de blocos e português estruturado (portugol), na POO usa-se a linguagem UML (Linguagem de Modelagem Unificada), para se estruturar as diversas partes que irão compor o software a ser desenvolvido, essa linguagem é composta apenas de diagramas.

O CPAN dispõe de uma grande quantidade de módulos que permitem o manuseio de vários aspectos da UML, inclusive há módulos que permitem criar diagramas UML a partir de projetos já existentes, por exemplo, o http://search.cpan.org/perldoc?UML::Class::Simple.

Conceitos Básicos da POO

No começo do artigo eu mencionei a tal da classe que é concebida por meio de abstração, pois bem, uma classe é formada por atributos e métodos. Os atributos são as características da classe, já os métodos são os comportamentos que a classe possui.

atributos e métodos podem ser arranjados dentro de uma classe afim de permitir que somente ela seja responsável pelo conhecimento daquele objeto (encapsulamento), tornando possível oferecer uma interface mais amigável para se interagir com ela, uma vez que quer fizer uso dessa classe precisa apenas solicitar algo e esperar que ela o faça, sem se preocupar com o "como" a coisa é feita.

Ao se instanciar uma classe, o método construtor da classe é acionado, alocando todos os recursos necessários para utilização desta, nascendo assim o objeto. Que desaparecerá ao ser invocado o método destrutor, que em algumas situações pode ser automático (coletor de lixo ou garbage collector).

Os objetos relacionam-se de diversos modos diferentes, como Associação, Agregação, Composição, Generalização, este último é possível através da herança, ou seja, quando uma subclasse filha herda características e comportamentos de uma classe pai; existem casos em que uma subclasse possui várias classes pai, esse fenômeno é chamado de herança múltiplas.

Estes relacionamentos permitem criar hierarquias de classes extremamente organizadas e reaproveitáveis, por exemplo, eu posso ter uma classe pai chamada Ar com todos os atributos e métodos descritos no início do artigo e criar subclasses derivadas dela, como Furacao, Ventania, Brisa, que possuem características próprias, mas todas possuem coisas em comum com a classe Ar, sem ter que reescrever em cada classe tudo que já está programado dentro da classe pai AR.

Os objetos comunicam-se através da troca de mensagens, essa mensagem é um conjunto de parâmetros reconhecidos pela interface da classe, e que acionam métodos ou mudam estados nela.

Uma classe pode ser implementada de forma responder de formas diferentes caso seja solicitado um mesmo método com parâmetros diferentes, isso recebe o nome de polimorfismo.

POO e Perl

Perl não foi criada para atender a um único paradigma e deixa o programador livre para pensar e buscar formas diferentes para resoluções de problemas. Sua grande versatilidade a torna uma linguagem multiparadigma, e a Orientação a Objetos é um dos paradigmas suportado pela linguagem Perl.

O suporte nativo a OO em Perl é incompleto, e ainda assim, muito interessante. Para usá-lo é necessário um bom conhecimento de sub-rotinas (perlsub), referências (perlref) e módulos/pacotes (perlmod), como recomenda a própria página de manual perlboot (um tutorial para programadores Perl iniciantes OO).

Em Perl as classes são chamadas de módulos ou pacotes e declarados com o comando "package", no método construtor é criado com ajuda do comando "bless", e a herança é se baseia na manipulação do array "@ISA", existe também o método "DESTROY".

Simples Exemplo

Uma implementação simples da classe Ar e uma subclasse derivada dela, Furacao:







    #==============================================================================
    # Declaracao do nome da Classe
    #==============================================================================
    package Ar;

    use strict;
    use warnings;

    #==============================================================================
    # Declaracao do método Construtor
    #==============================================================================
    sub new {
        my $class = shift();

        # declarando os atributos da classe e alguns valores default
        my $self = {
            composicao  => [qw(H20 CO2)],
            temperatura => q(20°C),
            movimento   => q(indefinido),
            direcao     => q(indefinida),
            velocidade  => q(indefinido),
        };

        return ( bless( $self, $class ) );
    }

    #==============================================================================
    # "Geters" and "Seters"
    #==============================================================================
    sub composicao {
        my $self = shift();
        my $var  = shift();
        if ( defined($var) ) {
            $self->{composicao} = $var;
        }
        else {
            return ( $self->{composicao} );
        }
    }

    sub temperatura {
        my $self = shift();
        my $var  = shift();
        if ( defined($var) ) {
            $self->{temperatura} = $var;
        }
        else {
            return ( $self->{temperatura} );
        }
    }

    sub movimento {
        my $self = shift();
        my $var  = shift();
        if ( defined($var) ) {
            $self->{movimento} = $var;
        }
        else {
            return ( $self->{movimento} );
        }
    }

    sub direcao {
        my $self = shift();
        my $var  = shift();
        if ( defined($var) ) {
            $self->{direcao} = $var;
        }
        else {
            return ( $self->{direcao} );
        }
    }

    sub velocidade {
        my $self = shift();
        my $var  = shift();
        if ( defined($var) ) {
            $self->{velocidade} = $var;
        }
        else {
            return ( $self->{velocidade} );
        }
    }

    #==============================================================================
    # Declaracao da SubClasse filha Furacao
    #==============================================================================
    package Furacao;

    #==============================================================================
    # Herdando tudo Classe "Ar"
    #==============================================================================
    use vars qw(@ISA);
    @ISA = qw(Ar);

    #==============================================================================
    # método Construtor
    #==============================================================================
    sub new {
        my $class = shift();
        my $self  = Ar->new();

        # redefinindo valores default
        $self->{velocidade}    = q(200km/h);
        $self->{direcao}       = q(leste);
        $self->{movimento}     = q(circular);
        $self->{classificacao} = 3;

        return ( bless( $self, $class ) );
    }

    #==============================================================================
    # Declarando uma novo método
    #==============================================================================
    sub classificacao {
        my $self = shift();
        my $var  = shift();
        if ( defined($var) ) {
            $self->{classificacao} = $var;
        }
        else {
            return ( $self->{classificacao} );
        }
    }

    1;




Neste exemplo, todos as características programados na classe Ar são herdados na subclasse Furacao, alguns valores padrão são sobrescritos para caracterizar um Furacao, a classe pai, Ar é estendida na subclasse filha Furacao com a adição de um novo método, "classificacao", que de fato só faz sentido para o furacão.

Conclusão

A linguagem Perl evolui a ela mesma, e essa forma de programar OO em Perl já está muito ultrapassada. Hoje existem no CPAN inúmeros módulos que permitem um total aproveitamento da Orientação a Objetos em Perl, de maneira profissional e extremamente produtiva e que requer poucos conhecimentos da linguagem em si, o único pré-requisito real é o conhecimento da língua inglesa para leitura dos manuais.

O exemplo mais famoso é o Moose (http://search.cpan.org/perldoc?Moose) que não poderia deixar de ser citado.

Links Relacionados

Autor

Ronaldo Ferreira de Lima aka jimmy (jimmy dot tty at gmail dot com).

blog comments powered by Disqus