PADRÕES

1- O que é um padrão?
   Cada padrão descreve um problema que ocorre frequentemente, apresentando a
   estrutura da sua resolução de tal forma que possa ser reutilizado em
   situações semelhantes.

2- Um padrão tem quatro elementos essenciais:
   a) O nome do padrão: facilita a identificação do padrão e comunicação do
      problema e solução.
   b) O problema: descreve quando aplicar o padrão, incluíndo o contexto de
      utilização e as pré-condições para a sua aplicação.
   c) A solução: descreve os elementos que constituem a solução, o seu
      relacionamento, responsabilidades e colaborações. A descrição é abstracta
      e genérica, não se aplicando apenas a uma situação mas a um conjunto de
      casos semelhantes.
   d) Consequências: são os resultados de aplicar o padrão incluindo os seus
      benefícios, custos (memória, tempo de execução, etc.) e limitações
      (consequências indirectas da aplicação).

3- Os padrões mais comuns: Abstract Factory, Adapter, Composite, Decorator,
   Factory Method, Observer, Strategy, Template Method.

4- Os padrões dividem-se em três grupos:
   a) Padrões de criação (de instâncias):
      * Abstract Factory:
        Oferece uma interface para a criação de famílias de objectos
	relacionados ou dependentes, sem especificar as suas classes concretas.
        (Ex. Sistemas de janelas, janelas, scroll-bars, etc.)
      * Builder:
        Separa a construção de objectos complexos da sua representação de tal
	forma que o mesmo processo de construção possa criar representações
	distintas.
      * Factory Method:
        Define uma interface abstracta para criar um objecto, permitindo que
	sejam as sub-classes a decidir qual o a classe a instanciar, ou seja,
	relega a instanciação para as sub-classes.
      * Prototype:
        Especifica os tipos de objectos a criar usando uma instância como
	protótipo, criando novos objecto através da copia do protótipo.
      * Singleton:
        Assegura que existe apenas uma instância da classe, fornecendo um
	ponto global para aceder à instância.
   b) Padrões estruturais:
      * Adapter:
        Converte a interface de uma classe numa interface acessível ao cliente.
	Permite que classes previamente incompatível possam funcionar em
	conjunto.
      * Bridge:
        Separa a abstracção da realização de tal forma que possam variar
	independentemente.
      * Composite:
        Organiza objectos de tal forma que grupos de objectos relacionados
	possam ser manipulados como objectos individuais. Permite tratar
	uniformemente tanto objectos individuais como agrupamentos destes.
	(Ex. ficheiros e directórios)
      * Decorator:
        Associa diamicamente responsabilidades a um objecto, oferecendo uma
	forma flexível de extender a funcionalidade sem usar herança.
      * Façade:
        Oferece uma interface unificada para um conjunto de interfaces num
	sub-sistema, tornando a utilização do sub-sistema mais simples
	através de uma interface de mais alto-nível.
      * Flyweight:
        Utiliza a partilha para suportar eficientemente um elevado número de
	pequenos objectos.
      * Proxy:
        Oferece um imagem ou referência para aceder indirectamente a um
	objecto.
   c) Padrões de comportamento:
      * Chain of Responsability:
        Evita a associação entre o emissor e o receptor de uma mensagem,
	permitindo que mais de um objecto manipulem a mensagem. Encadeia os
	objectos receptores a transporta a mensagem ao longo da cadeia até
	que um objecto a aceite.
      * Command:
        Permite encapsular um pedido como um objecto, consentindo a
	parametrização de clientes com pedidos distintos.
	(Ex. Menu e respectivas opções ou Commands)
      * Interpreter:
        Dada uma linguagem, define uma representação para a sua gramática em
	conjunto com um interpretador que processa as frases da linguagem.
      * Iterator:
        Oferece uma forma simples de aceder aos elementos de um conjunto sem
	expor a representação interna do conjunto.
	(Ex. Iterator de List, Set, Collection, etc.)
      * Mediator:
        Define um objecto que encapsula a forma como um conjunto de objectos
	interage, impedindo que os objectos se refiram mutuamente de uma forma
	explícita e permitindo que a sua interacção varie independentemente.
      * Memento:
        Captura e apresenta o estado interior de um objecto sem violar o seu
        encapsulamento, de tal forma que o estado do objecto possa ser reposto
	mais tarde.
      * Observer:
        Define uma dependência entre um objecto e um conjunto de outros
	objectos, os observadores, permitindo a notificação automática dos
	observadores sempre que o objecto muda de estado.
      * State:
        Permite que um objecto altere o seu comportamento sempre que o seu
	estado interno é alterado, fazendo parecer que o objecto muda de
	classe.
	(Ex. TCP on/off)
      * Strategy:
        Define uma família de algoritmos, tornando-os intermutáveis através do
	seu encapsulamento, permitindo que o algoritmo se altere
	independentemente dos seus clientes.
	(Ex. utilização de List como ArrayList e LinkedList)
      * Template Method:
        Define o esqueleto de um algoritmo, sendo alguns dos passos relagados
	para sub-classes. As sub-classes podem, assim, redefinir alguns
	passos do algoritmos sem alterar a sua estrutura de funcoinamento.
      * Visitor:
        Representa a execução de uma operação sobre uma estrutura de objectos,
	permitindo definir uma nova operação sem alterar as classes dos
	objectos visitados.
	(Ex. Compilador e árvore sintáctica)