Programação Orientada a Objeto

Conceito de POO

     A programação tradicional (estruturada) leva o programador a pensar no fluxo do programa da primeira linha de código até a ultima, fixando o foco nos programas (procedimento e funções). Já os dados são colocados em segundo plano, sendo seu manuseio de forma passível e em alguns casos retirando sua importância do contexto.

  O paradigma da programação orientada a objetos (POO) muda esse conceito, pois em vez do programador ficar pensando no fluxo do programa, ele deve analisar quais objetos estão relacionados a uma tarefa especifica e quais dados e métodos os torna único.

  Na prótica a POO proporciona inúmeros benefícios ao desenvolvimento de sistemas, tais como uma maneira eficiente de representar elementos do mundo real para a construção desses sistemas, usando-se para isso classes e objetos. Dessa maneira a reutilização de classes e objetos, alúm da sua manutenibilidade, diminuem os efeitos causados pelas manutenções dos sistemas.

  Mas sé com o real conhecimento dos conceitos da orientação a objetos e sua utilização eficiente poderemos obter os benefícios propostos pela POO.

  - Classe: É a representação de elementos do mundo real, sendo formado, basicamente, por atributos e métodos. Um atributo é o local onde de armazenamento dos dados, enquanto um método é responsável por realizar ações sobre um ou mais atributos, tais como obter ou modificar os seus valores.

  - Objeto: É uma instância de uma classe. Para melhor entender tenha em mente uma analogia com uma variável e seu tipo, onde substituímos a variível pelo objeto e o tipo pela classe.

  - Método: É uma sub-rotina interna de uma classe, ela é responsável por executar eventos na classe, estando, dessa maneira, ligadas a mesma.

  - Evento: É uma ação, direta ou indireta, sofrida por uma classe. Um exemplo já bastante utilizado nesse curso é o evento OnClick, esse evento chama um método que tem sua funcionalidade implementada pelo programador.

  - Abstração: É a capacidade de recriar os objetos do mundo real em um programa, mas levando em consideração somente o relevante ao mesmo. Um exemplo disso seria a utilização de um objeto cliente que é baseado na idéia de uma pessoa, que por sua vez é um ser humano. Não precisamos recriar todas as características de um ser humano, mas somente o relevante ao cliente e que é de interesse do programa.

  - Encapsulamento: É a capacidade de tornar atributos e métodos de um objeto ocultos a outros objetos. Evidentemente que devem existir alguns métodos que permitam sua utilização, bastando somente saber quais são e como utilizá-los. Imagine que você está dirigindo um carro, para fazer isso você não precisa conhecer o funcionamento interno do motor, só precisa saber como e quando passa as marchas, entre outras funções.

  - Herança: É a capacidade de uma classe definida como filha receber características já existentes de outra classe definida como pai ou mãe, em outras palavras, é a classificação hierárquica existente entre classes. Para entender melhor vamos analisar o exemplo da figura 3, nele temos a classe Mamíferos que dá origem as classes Cachorros e Humanos, essas duas novas classes herdam características da classe Mamíferos mas também têm características distintas entre si. Em seguida a classe Humanos dá origem a outras duas classes, Homens e Mulheres, que herdarão caracteríticas jí definidas na classe Humanas além de terem suas próprias características. Dessa maneira cada nova classe (subclasse) tem características mais especificas do que a classe de origem (superclasse).

  - Polimorfismo: É a capacidade de classes diferentes responderem a mesma ordem, mas de maneira diferente. Ainda usando a figura 3 como exemplo, podemos ver que Homens e Cachorros são classes diferentes, mas ambos são capazes de correr, embora que o cachorro corra com as quatro patas, já o homem corre sobre os dois pés.

Exemplo de POO na Linguagem Delphi

  Crie um novo projeto, renome o Form para FPrincipal, salve a Unit com o nome de UPrincipal e o projeto com o nome de AplicacaoPOO. Selecione o menu File > New > Unit – Delphi for Win32 para cria uma nova Unit sem um formulário anexo e salve essa com o nome de UClasses.

  Na seção interface entre com o cédigo abaixo;

  Nesse código estamos usando o conceito de Abstração para criarmos uma nova classe. Como toda classe é um tipo comeéamos digitando a palavra reservada type.

  Na linha 02 iniciamos a criação da nossa classe que é finalizado com a palavra reservada end; que se encontra na linha 08.

  Nas linhas 03 e 04 declaramos dois campos (atributos) do tipo string.

  Na linha 05 foi declarado o método Avaliação e nas linhas 06 e 07 são declarados dois outros métodos extremamente importantes. O mótodo constructor cria a instância do objeto, fazendo as alocações em memória e disponibilizando o objeto para uso, dessa maneira sempre que precisarmos instanciar um objeto devemos chamar esse método. Já o método destructor faz o inverso do constructor, ele destrói o objeto instanciado liberando a memória.

  Com o prompot dentro da declaração da classe pressione Ctrl+Shift+C e entre com o seguinte código:

  Esse código é bem simples e praticamente dispensa explicações, o único detalhe novo que temos aqui é a palavra reservada Self, poderíamos ter atribuído valores aos campos Nome e Fone sem utilizá-la, mas para evitar ambigüidade utilizamos o Self para fazer uma referência implícita própria classe.

  Volte para o FPrincipal, declare UClasses na cláusula uses da seção implementation, coloque um componente TButton e em seu evento OnClick entre com o código abaixo, compile e teste:

  Na linha 03 estamos declarando o objeto Aluno do tipo TPessoa. A linha 05 estamos instanciando o objeto Aluno. A linha 06 nos mostra o valor dos campos após o objeto ter sido instanciado. Nas linhas 07 e 08 estamos atribuindo novos valores nos campos do objeto. A linha 09 executa o método Avaliação, enquanto na linha 10 é mostrado os novos valores atribuídos aos campos.

  Vó para a UClasses e abaixo da declaração da classe TPessoa crie duas classes descendentes da mesma como mostrado no código:

  Nesse momento aplicamos o conceito de Herança, um vez que as classes TAluno e TProf são descendentes da classe TPessoa. Em seguida use o Ctrl+Shift+C nas classes e entre com o código em negrito:

     Novamente volte para o FPrincipal, mude o evento OnClick do TButton, compile e teste:

  Note que mesmo sem termos declarado os campos Nome e Fone nas subclasses, elas herdaram esses campos da superclasse, dessa maneira a cada novo nível criada mais específico vai ficando a subclasse. O mesmo acontece com métodos que são declarados na superclasse e não o são na subclasse, mas no nosso exemplo redefinimos os métodos da superclasse, aplicando assim o conceito de Polimorfismo. Linguagem Delphi garante o funcionamento correto do método desejado através do uso das palavras reservadas mostrada a tabela.

  Vamos tornar os métodos da nossa superclasse em métodos virtuais:

  Vemos uma das vantagens da POO, mudamos as classes mas não precisamos mudar nada no FPrincipal, para as alterações entrarem em vigor apenas compile e teste.

  O código a seguir transforma a superclasse TPessoa em uma classe abstrata, obrigando as subclasses TAluno e TProf a implementar o método abstrato:

  Pressione Crtl+Shift+C dentro das classes TAluno e TProf, em seguida entre com código mostrado:

     Mude o evento OnClick do TButton que está FPrincipal, compile, teste e verifique o erro que dá:

     A classe TPessoa não poderia ter sido instanciado pois ela é uma classe abstrata, mas caso se deseje utilizá-la e desprezar a regra de náo poder instanciar uma classe abstrata, basta comentar a linha 14 com a barra dupla.

     Iremos agora implementar o conceito de Encapsulamento nas nossas classes, em outras palavras, vamos deixar as nossas classes com o mínimo de funcionalidade visível, mas elas devem ter fácil acoplamento e uma interface acessível. Para os puristas de POO, todos os campos e alguns métodos não podem ser acessados diretamente do meio da classe. Classes e objetos distintos só terão acesso a alguns métodos que permitam a interação com os mesmos. Para isso a Linguagem Delphi implementa níveis de visibilidade dentro da classe.

     Modifique as classes para podemos incorporar os níveis de visibilidade recomendada pela Encapsulamento.

  Implementamos os níveis de acesso private, public e published nas três classes, note que os campos mudaram de nome (foi incluída letra F no seu inicio), além da inclusão de um novo campo na classe TProf. Isso obriga a alteração dos nomes dos campos em todas as partes das classes, mas essas alteraçães só devem ser feitas dentro da UClasses, no momento não mude nada na UPrincipal.

  Todos os campos foram implementados com visibilidade private, dessa maneira foi atendido uma exigência do encapsulamento que diz "nenhum campo pode ser acessado diretamente".

  Os métodos foram colocados com visibilidade public, pois todos os métodos apresentados são usados como ponto de acoplamento entre a classe e outras classes e objetos. Foram criados novos métodos do tipo Get e Set, esses métodos servem para ler e escrever, respectivamente, dados de um campo dentro da classe.

  Na visibilidade published temos outra forma de manipulação de campo que pode ser usada na Linguagem Delphi, as propriedades. Uma propriedade pode realizar leitura e escrita num campo de forma "indireta". Declaramos nas linhas 14 e 15 a propriedade Nome que ler(write) e escreve(get) dados no campo FNome da classes TPessoa. Foram declaradas propriedades mesclando o uso dos Gets e Sets.

     Segue as mudanças acontecidas na seção implementation da UClasses:

     Para finalizar vamos muda o código do evento OnClick do TButton que está no FPrincipal, em seguida compile e teste: