Design Patterns - Padrões Comportamentais - Delegation Pattern

O Delegation Pattern (Padrão de Delegação) é um padrão de projeto comportamental que permite que um objeto deixe outra classe manipular uma solicitação em seu nome. Ele envolve dois objetos: um objeto delegador e um objeto de serviço. O objeto delegador encaminha solicitações para o objeto de serviço, mas ainda mantém o controle sobre quando e como a solicitação é realizada.

Componentes do Padrão de Delegação:

1. Delegador (Delegator): É o objeto que delega a responsabilidade de executar uma tarefa para outro objeto. Ele mantém uma referência ao objeto de serviço e encaminha as solicitações para ele.

2. Objeto de Serviço (Service Object): É o objeto que executa a tarefa delegada pelo delegador. Ele contém a lógica real para realizar a operação.

Vantagens do Padrão de Delegação:

1. Encapsulamento: Permite que o objeto delegador mantenha o controle sobre a solicitação e os detalhes de implementação, isolando o cliente do objeto de serviço.

2. Flexibilidade: Permite que o objeto delegador altere dinamicamente o objeto de serviço em tempo de execução, sem afetar o cliente.

3. Reusabilidade: Permite reutilizar o objeto de serviço em diferentes contextos, pois ele pode ser compartilhado por vários objetos delegadores.

Design Patterns - Padrões Comportamentais - Null Object

O padrão de projeto Null Object é um padrão comportamental que visa fornecer um objeto substituto para a ausência de um objeto de serviço ou para tratar valores nulos de forma mais segura. Em vez de retornar um valor nulo quando um objeto não existe, você retorna uma instância de uma classe especial, conhecida como objeto nulo, que implementa a mesma interface ou classe base que o objeto real. Esse objeto nulo contém implementações vazias ou padrão para os métodos, permitindo que o código cliente chame esses métodos sem se preocupar com a possibilidade de encontrar um valor nulo.

Componentes do Padrão Null Object:

1. NullObject (Objeto Nulo): É uma classe concreta que implementa a mesma interface ou classe base que os objetos reais. Os métodos do objeto nulo geralmente não fazem nada ou retornam valores padrão.

2. RealObject (Objeto Real): É uma classe concreta que implementa a mesma interface ou classe base que os objetos reais. Contém a lógica real de implementação dos métodos.

3. Client (Cliente): É o código que interage com os objetos, sem precisar distinguir entre objetos nulos e objetos reais. O cliente chama métodos nos objetos sem se preocupar se eles são objetos reais ou nulos.

Vantagens do Padrão Null Object:

1. Evita Verificações por Nulo: Elimina a necessidade de verificar se um objeto é nulo antes de chamar seus métodos, melhorando a segurança e a legibilidade do código.

2. Simplifica a Lógica do Cliente: O cliente pode chamar métodos em qualquer objeto, sem a necessidade de tratamento especial para valores nulos.

3. Melhora a Manutenção do Código: Facilita a introdução de novos tipos de objetos sem modificar o código do cliente existente.

Design Patterns - Padrões Comportamentais - Visitor

O padrão de projeto Visitor é um padrão comportamental que permite adicionar novas operações a uma estrutura de objetos existente sem modificar esses objetos. Ele é útil quando você tem uma estrutura de objetos complexa e deseja realizar operações diferentes em cada objeto, mas sem alterar suas classes.

 Componentes do Padrão Visitor:

1. Visitor (Visitante): É uma interface ou classe abstrata que declara métodos de visitação para cada tipo de elemento na estrutura de objetos.

2. Element (Elemento): É uma interface ou classe abstrata que define um método accept(visitor) que aceita um objeto visitante como argumento. Este método é implementado por cada elemento na estrutura de objetos.

3. ConcreteElement (Elemento Concreto): São classes concretas que implementam a interface Element. Cada classe concreta define sua própria implementação do método accept(visitor).

4. ConcreteVisitor (Visitante Concreto): São classes concretas que implementam a interface Visitor. Cada classe concreta de visitante fornece uma implementação específica para cada operação definida na interface Visitor.

Vantagens do Padrão Visitor:

1. Separação de Operações: Permite separar as operações dos objetos da sua estrutura, facilitando a adição de novas operações sem modificar as classes dos objetos.

2. Acoplamento Reduzido: O padrão Visitor reduz o acoplamento entre as classes do objeto e as operações que podem ser realizadas nesses objetos.

3. Fácil Adição de Novas Operações: Adicionar novas operações à estrutura de objetos é tão simples quanto criar uma nova classe de visitante.

 

Design Patterns - Padrões Comportamentais - Template Method

O padrão de projeto Template Method é um padrão comportamental que define o esqueleto de um algoritmo em uma operação, mas permite que as subclasses alterem certos passos desse algoritmo sem alterar sua estrutura geral. Em outras palavras, ele fornece um modelo para um algoritmo e deixa algumas etapas específicas para serem implementadas pelas subclasses. O Template Method é útil quando você quer evitar a duplicação de código em várias classes que compartilham uma estrutura semelhante, mas têm diferenças nos detalhes da implementação.

Componentes do Padrão Template Method:

1. Classe Abstrata (Abstract Class): Define o Template Method, que é o esqueleto do algoritmo. Pode conter métodos abstratos ou concretos que são chamados pelo Template Method.

2. Método Template (Template Method): É o método na classe abstrata que define o esqueleto do algoritmo. Ele consiste em uma série de chamadas a métodos, alguns dos quais são implementados na classe abstrata e outros que devem ser implementados pelas subclasses.

3. Métodos Concretos (Concrete Methods): São métodos implementados na classe abstrata que são chamados pelo Template Method. Eles fornecem as etapas específicas que são comuns a todas as subclasses.

4. Métodos Abstratos (Abstract Methods): São métodos declarados na classe abstrata, mas não implementados. Eles devem ser implementados pelas subclasses para fornecer a implementação específica das etapas variáveis do algoritmo.

Design Patterns - Padrões Comportamentais - State

O padrão de projeto State (Estado) é um padrão comportamental que permite que um objeto altere seu comportamento quando seu estado interno muda. O padrão State permite que um objeto pareça alterar sua classe, alterando o objeto que está associado a ele quando seu estado interno muda.

Componentes do Padrão State:

1. Contexto (Context): É o objeto que possui uma instância de um estado concreto e mantém uma referência para a interface do estado. O contexto permite que o estado atual seja alterado para outro estado.

2. Estado (State): É uma interface ou classe abstrata que representa um estado específico do contexto. Contém métodos que refletem as transições possíveis entre estados.

3. Estado Concreto (Concrete State): São implementações concretas da interface de estado. Cada estado concreto implementa o comportamento associado a um estado específico do contexto.

Vantagens do Padrão State:

1. Flexibilidade: Permite que um objeto altere seu comportamento quando seu estado interno muda, sem alterar sua classe.

2. Separação de Responsabilidades: Separa o código relacionado ao estado em classes separadas, facilitando a manutenção e a compreensão do código.

3. Adição de Novos Estados: É fácil adicionar novos estados, pois você só precisa criar uma nova classe de estado e implementar a interface de estado.

4. Encapsulamento: Encapsula o código associado a cada estado em classes separadas, promovendo o princípio de encapsulamento.

Design Patterns - Padrões Comportamentais - Memento

O padrão de design Memento (Memorando) é um padrão comportamental que permite capturar e armazenar o estado interno de um objeto sem violar sua encapsulação, de modo que o objeto possa ser restaurado para esse estado posteriormente. O padrão Memento é útil quando é necessário implementar a funcionalidade de desfazer (undo) ou restaurar o estado de um objeto a um ponto anterior em sua história.

O padrão Memento é composto pelos seguintes elementos:

1. Originator (Originador): É o objeto cujo estado interno precisa ser salvo e restaurado. Ele cria um memento para representar o estado atual do objeto e pode restaurar seu estado a partir de um memento.

2. Memento: É um objeto que armazena o estado interno do originador de forma opaca para o resto do sistema. Ele tem métodos para recuperar o estado do originador (para permitir que o originador seja restaurado para esse estado) e, geralmente, não possui métodos para modificar seu estado interno.

3. Caretaker (Cuidador): É responsável por manter os mementos. O cuidador não deve modificar ou examinar o conteúdo de um memento, mas pode guardar e devolver mementos para o originador, se necessário.

Em termos simples, o padrão Memento funciona da seguinte maneira:

1. O Originador cria um Memento para representar seu estado atual e o passa para o Cuidador para armazenamento.

2. O Originador pode solicitar ao Cuidador um Memento anterior para restaurar seu estado a um ponto anterior no tempo.

3. O Cuidador apenas armazena e devolve os Mementos quando solicitado pelo Originador.

O padrão Memento é particularmente útil quando você precisa implementar funcionalidades de desfazer/refazer em aplicativos ou quando precisa fornecer um mecanismo para salvar e restaurar o estado de um objeto em diferentes pontos no tempo, por exemplo, em editores de texto, softwares de design gráfico, sistemas de gerenciamento de documentos, etc.

Em resumo, o padrão Memento ajuda a preservar o encapsulamento, permitindo que os objetos restaurem seus estados anteriores sem revelar detalhes de sua implementação interna.

Design Patterns - Padrões Comportamentais - Mediator

O padrão de design Mediator (Mediador) é um padrão comportamental que define um objeto (o mediador) que centraliza as comunicações entre vários objetos em um sistema. Ele promove o baixo acoplamento, pois os objetos não precisam conhecer uns aos outros para interagir; em vez disso, eles se comunicam indiretamente por meio do mediador.

O padrão Mediator é composto pelos seguintes elementos:

1. Mediador (Mediator): Define uma interface para comunicação entre objetos colegas. O mediador conhece todos os objetos colegas e facilita a comunicação entre eles.

2. Colega (Colleague): Define uma interface para os objetos que se comunicam entre si por meio do mediador. Cada colega conhece seu mediador, mas não precisa conhecer os outros colegas.

3. Colega Concreto (Concrete Colleague): Implementa a interface de colega e se comunica com outros colegas por meio do mediador.

4. Mediador Concreto (Concrete Mediator): Implementa a interface do mediador e coordena a comunicação entre os objetos colegas. Ele conhece todos os colegas e facilita suas interações.

O padrão Mediator é útil em situações onde um conjunto de objetos se comunica de maneira complexa, levando a um alto grau de acoplamento entre esses objetos. Ao introduzir um mediador, cada objeto se comunica apenas com o mediador, reduzindo assim o acoplamento direto entre os objetos. Isso facilita a manutenção e a extensão do sistema, pois as mudanças em um objeto não afetam diretamente os outros objetos, apenas o mediador precisa ser modificado se as regras de comunicação mudarem.

Um exemplo comum de uso do padrão Mediator é em interfaces gráficas de usuário, onde diferentes componentes, como botões, caixas de texto e listas, precisam interagir entre si. Em vez de cada componente conhecer os detalhes de implementação dos outros, eles se comunicam por meio de um mediador central que coordena suas ações.

Em resumo, o padrão Mediator promove a reutilização, a manutenção fácil e a redução do acoplamento em sistemas complexos, tornando a comunicação entre objetos mais flexível e organizada.

Design Patterns - Padrões Comportamentais - Iterator

O padrão de design Iterator (Iterador) é um padrão comportamental que fornece uma maneira eficiente de acessar sequencialmente os elementos de uma coleção sem expor a complexidade subjacente da estrutura de dados. Ele permite que você percorra uma coleção de objetos sem precisar entender como essa coleção é realmente implementada.

O padrão Iterator é composto por vários elementos:

1. Iterador (Iterator): Define uma interface para acessar e percorrer os elementos de uma coleção. O iterador mantém uma posição na coleção e fornece métodos como next(), hasNext(), first(), etc.

2. Coleção (Collection): Define uma interface para criar um objeto iterador. Qualquer classe que implementa essa interface deve fornecer um método para criar um objeto iterador que percorrerá os elementos da coleção.

3. Iterador Concreto (Concrete Iterator): Implementa a interface do iterador e é responsável por rastrear a posição atual dentro da coleção e implementar operações de navegação, como next(), hasNext(), etc.

4. Coleção Concreta (Concrete Collection): Implementa a interface da coleção e cria um objeto iterador que pode ser usado para percorrer os elementos da coleção.

Ao utilizar o padrão Iterator, os clientes podem percorrer uma coleção de objetos sem precisar conhecer a estrutura interna dessa coleção. Isso promove o princípio de encapsulamento, já que a coleção pode alterar sua estrutura interna sem afetar o código do cliente que a percorre.

Além disso, o padrão Iterator permite que várias iterações ocorram simultaneamente sobre a mesma coleção, já que cada iterador mantém seu próprio estado de iteração. Isso proporciona uma maneira eficiente de trabalhar com coleções de dados grandes ou complexas.

Em resumo, o padrão Iterator oferece uma maneira flexível e padronizada de acessar elementos de uma coleção sem expor sua estrutura interna, melhorando assim a modularidade e a flexibilidade do código.

Design Patterns - Padrões Comportamentais - Interpreter

O padrão de design Interpreter, ou Intérprete em português, é um padrão comportamental que define uma gramática para uma linguagem e fornece um interprete para interpretar sentenças dessa linguagem. Ele é útil quando você precisa interpretar expressões complexas ou realizar operações em uma linguagem específica. O padrão Interpreter é composto por alguns elementos principais:

1. Context (Contexto): Mantém as informações globais que são compartilhadas por todas as expressões da linguagem.

2. AbstractExpression (Expressão Abstrata): É uma interface ou uma classe abstrata que define uma operação interpret() que é comum a todas as classes concretas de expressões.

3. TerminalExpression (Expressão Terminal): Implementa a interface AbstractExpression e representa um terminal na gramática da linguagem. Um terminal é um elemento indivisível na expressão. Por exemplo, em uma linguagem que interpreta expressões matemáticas, um número ou uma variável pode ser um terminal.

4. NonterminalExpression (Expressão Não Terminal): Também implementa a interface AbstractExpression e representa uma expressão composta por subexpressões. Um não terminal é uma expressão que pode ter subexpressões. Por exemplo, em uma expressão matemática, uma operação de adição pode ser uma expressão não terminal que tem duas subexpressões, uma para o operando da esquerda e outra para o operando da direita.

5. Client (Cliente): Constrói a árvore de sintaxe abstrata (AST) usando objetos TerminalExpression e NonterminalExpression e chama a operação interpret() para realizar a interpretação.

O padrão Interpreter é útil em situações onde você precisa interpretar uma linguagem ou expressões complexas, como interpretadores de linguagens de programação, sistemas de consulta de banco de dados, compiladores, etc. Ele encapsula a lógica de interpretação em classes específicas, tornando mais fácil adicionar novas regras ou expressões à linguagem sem alterar o código do cliente.

Design Patterns - Padrões Comportamentais - Command Pattern

O Command Pattern (Padrão Comando) é um padrão de design comportamental que transforma solicitações ou operações em objetos independentes. Ele encapsula uma solicitação como um objeto, permitindo parametrizar clientes com operações, enfileirar solicitações, além de suportar operações que podem ser desfeitas.

Componentes Chave:

1. Command (Comando): Define uma interface para executar uma ação específica. Geralmente, contém um método execute() que é chamado para realizar a operação associada.

2. ConcreteCommand (Comando Concreto): Implementa a interface de comando e define a relação entre um objeto receptor e uma ação. Ele invoca métodos do objeto receptor para realizar a ação.

3. Invoker (Invocador): Solicita que um comando seja executado. Geralmente, mantém uma lista de comandos e pode executar ou enfileirá-los.

4. Receiver (Receptor): Sabe como realizar a operação associada ao comando. É o objeto que recebe a solicitação do comando.

5. Client (Cliente): Cria um objeto de comando e associa-o com seu objeto receptor. O cliente também pode configurar o invocador com o comando.

Benefícios:

1. Desacoplamento: O remetente não precisa conhecer os detalhes do receptor ou da operação sendo executada, promovendo baixo acoplamento.

2. Enfileiramento e Log: Os comandos podem ser enfileirados, desfeitos e até mesmo registrados para fins de log, fornecendo um controle preciso sobre as ações do sistema.

3. Flexibilidade: Novos comandos podem ser adicionados sem modificar o código existente, tornando o sistema mais flexível e fácil de estender.

Exemplo Prático:

Considere um controle remoto. Cada botão do controle remoto é um comando que executa uma operação específica em um dispositivo eletrônico (como ligar/desligar uma TV ou ajustar o volume). Cada botão é configurado com um comando específico (ConcreteCommand), que, quando pressionado, executa a operação apropriada no dispositivo (Receptor). O Invocador (o controle remoto) simplesmente aciona o comando associado ao botão pressionado.

Em resumo, o padrão Command é útil quando você precisa desacoplar remetentes de receptores, enfileirar solicitações, ou fornecer suporte a operações que podem ser desfeitas. Ele facilita a manipulação de ações complexas, adicionando uma camada de abstração entre os objetos do sistema.