Programação Orientada a Objetos com PHP


E aí galera, bom neste post eu estarei abordando um tema muito utilizado nos dias de hoje, que é a programação orientada a objetos.

Nessa em especial estarei utilizando a linguagem PHP, que como todos sabem, é uma linguagem livre e gratuita, sem falar que é a mais utilizada em todo o mundo.

Índice

1. Programação Estruturada x Programação Orientada a Objetos

Nos anos 60 uma linguagem de programação chamada SIMULA criada por Kristen N. e Ole-Johan, utilizava uma nova forma de reaproveitamento de código. No lugar de quebrar o código em várias funções e criar pequenos procedimentos, foi adotado o que se chama de classes e subclasses.
Já na década de 70 o Smalltalk foi criado por cientistas da Xerox. Ela foi a primeira linguagem que apresentava de forma completa os conceitos da programação orientada a objetos.
O conceito era completamente novo e que levou certo tempo para as pessoas se acostumarem, e até hoje ainda causa arrepios em alguns desenvolvedores.

1.1. Programação Estruturada

A programação estruturada foi e ainda é bastante utilizada no mundo do desenvolvimento. Ela é baseada no conceito da modularização: o programa é quebrado em pequenos procedimentos, também conhecidos como funções. Assim é possível manter um aproveitamento razoável de código e criar funções genéricas que podem ser reaproveitadas entre projetos diferentes como, por exemplo, uma função que gera planilhas eletrônicas.
Embora isso seja possível, criar algo muito genérico é bastante difícil. O número de parâmetros que essa função pode receber e o número de procedimentos executados repetidamente é muito grande e isso dificulta a manutenção do código.
Com todos esses problemas o desenvolvimento é demorado, ou então, ele é rápido mas sua manutenção é bastante difícil, levando várias horas ou até mesmo dias para realizar uma pequena mudança. Como o reaproveitamento é pequeno, uma simples mudança precisa ser replicada em várias outras partes do código.

1.2. Programação Orientada a Objetos

A programação orientada a objetos traz o mundo real para dentro do desenvolvimento. Se utilizada corretamente, seu programa pode simular a compra de um produto da foma como ela realmente é: Um produto é posto dentro de um carrinho de compras. Então esse carrinho segue até um caixa onde é calculado o valor da compra, dos juros, retirado os descontos e por último efetuando a compra.
Simular o mundo real dentro do computador não é uma tarefa difícil utilizando essa “nova” técnica. Se considerarmos que tudo ao nosso redor é um objeto (um produto, um carro, uma pessoa, um banco, uma conta corrente) é possível fazer com que esses objetos interajam entre si.
Então no lugar de nosso código ser:

<?php
$produto1_codigo = 1;
$produto1_nome = "CD Nine Inch Nails – With Teeth";
$produto1_quantidade = 4;

$produto2_codigo = 2;
$produto2_nome = "CD A Perfect Circle – Mer De Noms";
$produto2_quantidade = 3;

echo "Nome: " . $produto1_codigo . " :: " . $produto1_nome . "<br />";
echo ‘Quantidade: ’ . $produto1_quantidade;

echo "Nome: " . $produto2_codigo . " :: " . $produto2_nome . "<br />";
echo "Quantidade: " . $produto2_quantidade . "<br />";
?>

Ele passa a ser:

<?php
$produto1 = new Produto( 1, 'CD Nine Inch Nails – With Teeth', 4 );
$produto2 = new Produto( 2, 'CD A Perfect Circle – Mer De Noms', 3 );

echo "Nome: " . $produto1->codigo . " :: " . $produto->nome . "<br />";
echo ‘Quantidade: ’ . $produto1->quantidade;

echo "Nome: " . $produto2->codigo . " :: " . $produto2->nome . "<br />";
echo "Quantidade: " . $produto2->quantidade . "<br />";
?>

2. Classes e Objetos

Para que um objeto seja criado é necessário definirmos sua estrutura. A estrutura de um objeto são todas as suas características e possíveis ações que também são baseadas na vida real. Por exemplo, um carro possui como características: Cor, ano, modelo, marca, etc, e possui como ações: andar, parar, dar ré, ligar e desligar.

2.1. Classe

Para definirmos essa estrutura criamos algo que chamamos de Classe. Ela é a estrutura fundamental para a criação de objetos. É como se fosse um template para os objetos, onde todas as suas características e ações são especificadas e com isso ser possível criar N objetos diferentes. Diferente no sentido de dados e informações armazenadas, mas sua estrutura (definida na classe) é sempre igual.
Dentro de uma classe todas as suas características são chamadas de propriedades, enquanto suas ações são chamadas de métodos.
Para se definir uma classe é preciso basicamente utilizar a seguinte estrutura:

<?php
class Produto
{
      // propriedades
      public $codigo;
      public $nome;

      public $preco;

      // métodos
      public function calculaDezporcento()
      {
             return $this->preco * 0.10;
      }
}
?>

Note que dentro de uma classe as propriedades são como variáveis e os métodos são como funções. A palavra chave public é utilizada para definir o tipo de acesso das propriedades e dos métodos (Veja o capitulo 5, Encapsulamento).

Usamos também a palavra chave $this, que serve para dentro de um método chamar uma propriedade da classe.
Para acessarmos as propriedades e os métodos dessa classe é simples. É só seguir o exemplo:

<?php
$produto = new Produto();
$produto->preco = 1200;
echo $produto->calculaDezPorcento(); // imprime 120
?>

2.2. Objeto

Uma vez que a classe é definida podemos então criar infinitos objetos baseados na estrutura de uma mesma classe. Dentro da nossa aplicação podemos ter 100 objetos Produto que possuem a mesma estrutura, mas com informações diferentes.
A criação de um objeto a partir de uma classe é chamada de instanciação, então todo objeto é uma instancia de alguma classe. Para criar um objeto utilizamos o operador new.

<?php
 $produto = new Produto();
 $produto2 = new Produto();
 $produto3 = new Produto();
 ?>

Isso informa ao interpretador do PHP que um novo objeto está sendo criado. Então internamente o PHP reserva um espaço na memória onde aquele objeto vai ser armazenado. Por causa disso quando trabalhamos com objetos (a partir do PHP 5) todos os valores são passados por referencia, ou seja:

<?php
$produto = new Produto();
$produto->preco = 1;
echo $produto->preco; //imprime 1

$produto_copia = $produto;
$produto_copia->preco = 3;

echo $produto->preco; // imprime 3
?>

Explicando todo o processo por trás: quando instanciamos a classe Produto dentro da variável $produto, é criado um espaço na memória onde o objeto fica armazenado e a variável $produto guarda a referência para aquele espaço, ou seja a variável aponta diretamente para a memória. Quando dizemos que $produto_copia é igual a $produto, $produto_copia irá copiar a referência para a memória e não o objeto. Assim qualquer alteração feita em $produto_copia afetará $produto, pois ambos apontam para o mesmo objeto na memória.
É possível que seu navegador não suporte a exibição desta imagem.

2.3. Construtores e destruidores

Em certos momentos precisamos executar algo no momento em que uma classe é instanciada. Às vezes é necessário setar valores padrões a algumas propriedades, realizar cálculos, etc.
Para isso existe o método construtor, que no PHP é chamado através da palavra chave __construct. Toda vida que uma classe é instanciada o PHP busca pelo método __construct e o chama caso seja encontrado. O método construtor não é obrigatório, por tanto sua classe instanciará normalmente se você não declará-lo.
Ao instanciar classes é possível passar para ela parâmetros. Esses parâmetros são repassados para o construtor. Veja o exemplo:

<?php
class Produto
{
      public $codigo;
      public $nome;
      public $quantidade;
      /**
           * Construtor
           */
      public function __construct( $codigo, $nome, $quantidade)
      {
             $this->codigo = $codigo;
             $this->nome = $nome;
             $this->quantidade = $quantidade;
      }
}
$produto1 = new Produto( 1, "CD Nine Inch Nails – With Teeth", 4 );
$produto2 = new Produto( 2, "CD A Perfect Circle – Mer De Noms", 3 );
?>

Também temos os destrutores que no PHP são chamados através da palavra chave __destruct. Ao contrario dos construtores, os destrutores são chamados quando um objeto é destruído, por exemplo:

<?php
class MinhaClasse
{
      public function __destruct()
      {
             trigger_error('Por favor, não me destrua!!!!');
      }
}

$objetoMinhaClasse = new MinhaClasse();

unset( $objetoMinhaClasse ); // dispara o erro
?>

3. Herança e polimorfismo

Como dito anteriormente, uma classe é uma estrutura básica para a criação de objetos. Sendo assim vários objetos podem ser criados seguindo a mesma estrutura, porém com dados diferentes.
Porém há casos em que é necessário ter objetos idênticos com algumas funcionalidades a mais ou então com as mesmas funcionalidades, mas com comportamentos diferentes.

3.1. Herança

Herança é a característica de um filho obter algumas características do pai. Na programação orientada a objetos isso também pode ocorrer.
Se prestarmos atenção um carro e uma moto possuem características bem parecidas. Ambos possuem rodas ou até mesmo marchas, que são características semelhantes de qualquer veículo. Sendo assim podemos dizer que carro é um veículo. Assim como uma moto também é um veículo. Portanto ambos – carro e moto – herdam características do objeto veículo.
Na programação uma herança é caracterizada pela palavra chave extends. Assim nosso exemplo seria codificado da seguinte forma:

<?php
class Veiculo
{
      public $marcha;

      public $quantidadeRodas;

      public function passarMarcha()
      {
             // código
      }

      public function andar()
      {
             // código
      }
}

class Carro extends Veiculo
{
      public function __construct()
      {
             $this->quantidadeRodas = 4;
      }
}

$carro = new Carro();
$carro->andar();
?>

3.2. Polimorfismo
Polimorfismo é um termo grego que significa muitas formas ( poli: muitas, morphos: formas). Na programação é o mesmo que dizer que várias classes podem possuir a mesma estrutura e comportamentos diferentes.
Ao utilizar herança não apenas podemos reutilizar métodos da classe pai, como também podemos sobrescrever os métodos da classe pai, fazendo assim com que algumas características sejam modificadas.
Vamos supor que um banco possui dois tipos de cheques: o Cheque Comum e o Cheque Especial. Ambos os cheques possuem a mesma estrutura, o que diferencia um do outro é a forma de cobrança de juros. O Cheque Comum cobra 25% em cima do valor, então a classe será assim:

<?php
class ChequeComum
{
      private $valor;
      // ... outros métodos da classe
      public function setValor( $valor )
      {
             $this->valor = $valor;
      }
      public function getValor()
      {
             return $this->valor;
      }
   public function calculaJuros()
   {
         return $this->valor * 1.25; // soma 25% em cima do valor
   }
}
?>

O método calculaJuros() irá naturalmente retornar o valor que deverá ser cobrado do Cheque Comum com juros. O problema é que no Cheque Especial o valor dos juros cai para 10%. A classe seria algo como:

<?php
class ChequeEspecial extends ChequeComum
{
      public function calculaJuros()
      {
             return $this->valor * 1.10; // soma 10% em cima do valor
      }
}
?>

Assim reaproveitamos a estrutura dos objetos mudando apenas o que for preciso. Mas às vezes é preciso que mesmo sobrescrevendo um método, o código na classe pai seja executado. Para isso basta você chamar o nome do método, mudando onde tem $this para parent.

4. Abstração

Quando vamos desenvolver um programa, o certo não é pensar no projeto como um todo. A melhor forma de desenvolver é pensando e desenvolvendo em partes. Além de manter a sanidade do desenvolvedor, a estrutura do código fica bem organizada. Para criar uma estrutura bem feita é necessário abstrair seu desenvolvimento.
Abstrair significa separar mentalmente, considerar isoladamente, simplificar. Assim nosso sistema deve ser separado de forma lógica com o objetivo de simplificar.

4.1. Classes abstratas

Sendo assim existem classes que chamamos de classes estruturais. Elas são responsáveis por manter uma estrutura padrão para seus filhos, independente do seu número. Ou seja, essas classes nunca serão instanciadas, pois somente seus filhos serão usados.
Com isso nosso exemplo anterior, deveríamos ter criado uma classe chamada Cheque, que seria a estrutura padrão para as classes ChequeComum e ChequeEspecial, onde essas duas ultimas herdariam Cheque e adicionariam ou sobrescreveriam apenas o que fosse relevante e a classe Cheque seria abstrata.
Para dizermos que uma classe é abstrata basta informarmos a palavra chave abstract.

<?php
abstract class Cheque
{
      private $valor;
      // ... outros métodos da classe
      public function setValor( $valor )
      {
             $this->valor = $valor;
      }
      public function getValor()
      {
             return $this->valor;
      }
      public function calculaJuros()
      {
             return $this->valor; // não há juros
      }
}
class ChequeComum extends Cheque
{
      public function calculaJuros()
      {
             return $this->valor * 1.25; // calcula 25% em cima do valor;
      }
}
class ChequeEspecial extends Cheque
{
      public function calculaJuros()
      {
             return $this->valor * 1.10; // calcula 10% em cima do valor;
      }
}
/*
* Tentando instanciar a classe Cheque.
* Isto vai causar um Fatal Error, pois ela é abstrata e não pode ser instanciada.
*/
$cheque = new Cheque();
?>

4.2. Classes finais

Há também casos em que não queremos que uma classe seja estendida por mais nenhuma outra. Para fazermos isso definimos a classe como final utilizando a palavra chave com o mesmo nome, final. Vamos supor que a classe ContaEspecial não pode ser estendida, porém alguém tentou de qualquer forma fazer isso:

<?php
final class ChequeEspecial extends Cheque
{
      public function calculaJuros()
      {
             return $this->valor * 1.10; // calcula 10% em cima do valor;
      }
}
/**
       * Ao ver que estamos tentando herdar uma classe final,
       * o PHP lança um Fatal Error e para a execução do código
       */
class ChequeContaUniversitaria extends ChequeEspecial
{
      public function calculaJuros()
      {
             return $this->valor * 1.01; // calcula 1% em cima do valor;
      }
}
// Este código não chega a ser executado
$cheque = new ChequeContaUniversitaria();
?>

4.3. Métodos abstratos

Assim como classes, os métodos abstratos também são criados apenas para estruturação das classes filhas. Às vezes queremos que as classes derivadas de uma classe pai tenham obrigatoriamente um método específico, para garantir que não haja conflito em outros métodos que dependem desse primeiro.

<?php
abstract class Cheque
{
      // outros métodos
      abstract function calculaJuros();
}
class ChequeContaUniversitaria extends Cheque
{
      /**
           * Esta classe não precisa de calculo de juros.
           * Mas se este método não for definido o PHP dispara um Fatal Error,
           * pois na classe pai esse método está como abstrato.
           */
      public function calculaJuros()
      {
             return $this->valor; // não há juros;
      }
}
?>

Note que na classe Cheque o método calculaJuros() não é escrito, ele possui apenas sua assinatura. Isso é perfeitamente possível no caso de métodos abstratos.

4.4. Métodos finais

Quando um método é dito como final ele não pode ser sobrescrito ou seja, a classe filha continua tento acesso a ele, mas não pode mudá-lo.

<?php
abstract class Cheque
{
      final function calculaTotal()
      {
             // ...
      }
}
class ChequeContaUniversitaria extends Cheque
{
      /**
           * Isto retorna um Fatal Error
           */
      public function calculaTotal()
      {
             return 0.0;
      }
}
?>

5. Encapsulamento

O encapsulamento é um dos recursos mais interessantes da programação orientada a objetos. Encapsular significa, na programação, esconder os dados contidos nas propriedades de uma classe. Qualquer classe é completamente responsável pelos dados que ela transporta e necessita que os mesmos se mantenham íntegros, ou seja, sem alterações não previstas durando o fluxo da aplicação.
Por exemplo, não é necessário conhecer todo o funcionamento interno de um carro para poder dirigi-lo. Para isso é escondido por baixo da lataria tudo que faz com que o carro funcione, deixando apenas para o usuário o que é realmente necessário para se dirigir. Assim é garantido que o usuário leigo, ou que não saiba completamente do funcionamento do carro faça mexa na peça errada, corte o fio errado ou faça qualquer outra besteira.
Na programação orientada a objetos é possível utilizar do encapsulamento dando permissões de acessos aos atributos das classes. Assim podemos dizer quem pode acessar seus atributos diretamente ou não. São eles:

5.1. Public

A palavra chave public informa que a propriedade ou o método são públicos, ou seja, qualquer um pode acessar (desde subclasses como outras classes que estão a instanciando).

5.2. Private

Já a palavra chave private informa que a propriedade ou método só podem ser acessados internamente na classe. Nem seus filhos podem acessá-lo.

5.3. Protected

Enquanto isso protected indica que subclasses podem acessar, mas outras classes ou funções não têm essa permissão. Um exemplo de tudo isso junto:

<?php
class Pessoa
{
      private $id;

      protected $nome;

      public function setId( $id )
      {
             $this->id = $id;
      }

      public function getId()
      {
             return $this->id;
      }

      public function getNome()
      {
             return $this->nome;
      }
}

class PessoaFisica extends Pessoa
{
      public function setId( $id )
      {
             $this->id = $id;
      }

      public function setNome( $nome )
      {
             $this->nome = $nome;
      }
}

$pessoa = new Pessoa();
$pessoaFisica = new PessoaFisica();

/**
       * Isto causa um Fatal Error,
       * pois esta propriedade está como private
       */
$pessoa->id = 1;
$pessoa->setId(1); // já isto, funciona normalmente
$pessoaJuridica->setId(1); // isto causa outro Fatal Error

/**
       * Isto causa um Fatal Error,
       * pois esta propriedade está como protected
       */
$pessoaFisica->nome = 'Bruno Viana';

$pessoaFisica->setNome( 'Bruno Viana' ); // já isto, funciona
?>

6. Membros da classe

6.1. Constantes

Constantes já existem no PHP a muito tempo atrás. Elas são bem conhecidas por suas características de serem definidas e não poderem ser alteradas.
Na programação orientada a objetos elas podem ser criadas também dentro de classes, por exemplo:

<?php
class PessoaJuridica
{
      const TIPO = 'juridica';
}
class PessoaFisica extends Pessoa
{
      const TIPO = 'fisica';
}
echo PessoaFisica::TIPO;
echo PessoaJuridica::TIPO;
PessoaFisica::TIPO = 1; // Fatal Error
?>

6.2. Propriedades e métodos estáticos

Propriedades e métodos com a palavra chave static são iguais aos outros, possuem as mesmas regras, mas com uma pequena diferença: para acessá-los não é necessário instanciar a classe.

<?php
class Math
{
      public static function soma( $a, $b )
      {
             return $a + $b;
      }
}
Math::soma( 1, 2 );
?>

7. Intercepções

O PHP inseriu a partir da sua versão 5 o conceito de Intercepções. As intercepções são realizadas através de métodos conhecidos como Métodos Mágicos (Magic Methods).

7.1. Os métodos mágicos

São métodos opcionais que podemos por em nossas classes para executarem em momentos específicos e realizar ações especiais. Os principais são:

7.1.1. Método __set()

O método __set é chamado toda vez quem tentamos dar um valor a alguma propriedade da classe, independente dela ter sido declarada ou não.
No exemplo queremos que qualquer propriedade que o usuário tentar adicionar seja armazenada em um array:

<?php
class Pessoa
{
      private $_dados;
      public function __set( $chave, $valor )
      {
             $this->dados[ $chave ] = $valor
      }
}
$pessoa = new Pessoa();
$pessoa->nome = 'Bruno Viana';
?>

O método __set recebe dois parâmetros. Um é o nome da propriedade que estamos tentando inserir e o outro é o valor que estamos atribuindo.

7.1.2. Método __get()

Continuando com o exemplo passado, agora queremos recuperar esses valores armazenados. Atualmente não é possível pois o array $_dados é privado e não é possível acessar de fora da classe.
Para isso usamos o método __get, que intercepta toda vez que tentamos resgatar uma propriedade:

<?php
class Pessoa
{
      private $_dados;
      public function __set( $chave, $valor )
      {
             $this->dados[ $chave ] = $valor
      }
      public function __get( $chave )
      {
             return $this->{$chave};
      }
}
$pessoa = new Pessoa();
$pessoa->nome = 'Bruno Viana';
echo $pessoa->nome;
?>
7.1.3. Método __call()

O método __call é chamado toda vez que um método é chamado em uma classe e o PHP não o encontra. Com isso é possível definir comportamento padrão caso um método seja chamado.

<?php
class Pessoa
{
      private $_dados;
      public function __set( $chave, $valor )
      {
             $this->dados[ $chave ] = $valor
      }
      public function __get( $chave )
      {
             return $this->{$chave};
      }
      public function __call( $nomeDoMetodo, $argumentos )
      {
             LogManager::logar( "Foi chamado o método '$nomeDoMetodo' na classe Pessoa
e ele não existe." );
      }
}
$pessoa = new Pessoa();
/**
       * Isso guarda um log com a mensagem:
       * Foi chamado o método 'andar' na classe Pessoa e ele não existe
       */
$pessoa->andar();
?>

O método __call recebe dois parâmetros. Um é uma string com o nome do método que tentarão chamar e o outro é um array com os argumentos declarados. Se o método __call não for encontrado, o PHP continua com seu fluxo normal e dispara um Fatal Error.

8. Tratamento de erros

8.1. Exceções

Quando o programa não é executado de forma esperada é necessário informar o que está acontecendo ao desenvolvedor. Algumas vezes o programa pode parar de executar por conta desses erros e o desenvolvedor não tem ideia do que está acontecendo. E o pior de tudo isso, é que às vezes o programa para por conta de uma simples divisão por zero vinda do usuário.
Exceções são objetos derivados da classe Exception, que tem por objetivo enviar informações essenciais ao desenvolvedor para que o mesmo possa tratar esses erros sem que o programa pare. Com o PHP disparando esses objetos, é possível interceptá-los e tratá-los de forma correta.
Quando se desenvolve API’s para distribuir para terceiros utilizarem isso é mais do que preciso.

8.1.1. Disparando Exceções

Quando queremos disparar exceções utilizamos a palavra chave throw e em seguida passamos o objeto a ser disparado.
Abaixo estamos criando uma classe que lê arquivos para distribuir para que outros desenvolvedores possam usá-la, e queremos que caso esse arquivo não uma exceção seja disparada:

<?php
class LeitorArquivo
{
      public function abrir( $arquivo )
      {
             if( !file_exists( $arquivo ) ){
                    throw new Exception( 'O arquivo não existe.' );
             }
      }
}
$leitor = new LeitorArquivo();
$leitor->abrir( 'inexistente.txt' );
?>
8.1.2. Capturando Exceções

Agora somos o desenvolvedor que está utilizando está classe. E percebi que quando informo um arquivo que não existe o sistema está mostrando um erro estranho:

Fatal error: Uncaught exception ‘Exception’ with message ‘O arquivo não existe.’ in varwwwindex.php:10 Stack trace: #0 varwwwindex.php(16): LeitorArquivo->abrir(‘inexistente.txt’) #1 {main} thrown in varwwwindex.php on line 10

Isso ocorre por causa da exceção que a classe dispara quando não encontra um arquivo. Porém eu não posso deixar isso ser mostrado para o usuário do meu sistema, mas eu quero que ele guarde um log dessa mensagem de erro.
Para isso utilizamos o bloco try onde ficará todo o código que tem a possibilidade de disparar uma exceção, e abaixo do try criaremos um catch, que será responsável por capturar qualquer exceção disparada no bloco try.

<?php
try{
      $leitor = new LeitorArquivo();
      $leitor->abrir( 'inexistente.txt' );
}
catch( Exception $e ){
      LogManager:log( $e->getMessage() );
}
?>

No exemplo o bloco catch está recebendo uma variável $e do tipo Exception. Ela é exatamente o objeto da exceção disparada. Qualquer objeto derivado da classe Exception possui métodos que informam ao desenvolvedor um relado do que aconteceu. Esses métodos são:

  • getMessage: Retorna a mensagem de erro;
  • getCode: Retorna o código de erro;
  • getFile: Retorna o arquivo do qual ocorreu o erro;
  • getLine: Retorna a linha na qual ocorreu o erro;
  • getTrace: Retorna um array com todos os métodos e arquivos chamados até o erro ocorrer;
  • getTraceAsString: Retorna o array usado em getTrace como uma string.

9. Padrões de projetos

9.1. O que são e pra que servem?

Padrões de projeto, também conhecido como Design Patterns, descrevem problemas recorrentes no desenvolvimento de software e da suas soluções. Os padrões de projeto visão manter um catálogo para que se possa haver uma reutilização de soluções e com isso facilitar a comunicação, documentação e aprendizado dos sistemas.

9.2. Os mais conhecidos

Atualmente há inúmeros padrões de projetos catalogados e muitos frameworks hoje usam vários deles. Temos atualmente os seguintes padrões como os mais utilizados:

  • Factory method;
  • Singleton;
  • Front Controller;
  • MVC;
  • Adapter.

Hoje há vários livros catalogando e ensinando a utilizar esses padrões de projeto, um dos principais é o Design Patterns: Elements of Reusable Object-Oriented Software, publicado pelo grupo conhecido por GoF (Gang of Four) que é composto por Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides. Também há um bastante difundido que é o Patterns of Enterprise Applications Architecture publicado por Martin Fowler, que fala de padrões de projetos voltados para aplicações corporativas.

Conte-nos o que achou...

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: