Tópico 16 - Revisão Geral para N1

O que são Design Patterns?

• Soluções recorrentes para problemas recorrentes
• Não são código pronto
• Descrevem intenção, estrutura e colaboração
• Ajudam em:
  • comunicação
  • reutilização
  • manutenção

Dicionário

Gamma Categorization

Padrões Criacionais

Singleton

Singleton garante que uma classe tenha apenas uma instância e fornece um ponto global de acesso a ela.

Exemplo de Singleton

public class Logger {
    private static Logger instance;

    private Logger() {
        // Construtor privado para evitar instância externa
    }

    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
}

Uso do Singleton

Builder

Builder separa a construção de um objeto complexo de sua representação, permitindo criar diferentes representações usando o mesmo processo de construção.

Exemplo de Builder

public class UserBuilder {
    private String name;
    private String email;

    public UserBuilder setName(String name) {
        this.name = name;
        return this;
    }

    public UserBuilder setEmail(String email) {
        this.email = email;
        return this;
    }

    public User build() {
        return new User(name, age, email);
    }
}

Uso do Builder

Factory Method

Factory Method define uma interface para criar um objeto, mas permite que as subclasses decidam qual classe instanciar.

Exemplo de Factory Method

public class UserFactory {
  public User createUser(String name) {
    String email = name.toLowerCase() + "@example.com";
    User user = new User(
      name,
      email
    );
  }
}

Uso do Factory Method

Abstract Factory

Abstract Factory fornece uma interface para criar famílias de objetos relacionados ou dependentes sem especificar suas classes concretas.

Exemplo de Abstract Factory

public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

public class AndroidFactory implements GUIFactory {
    public Button createButton() {
        return new AndroidButton();
    }
    public Checkbox createCheckbox() {
        return new AndroidCheckbox();
    }
}

Uso do Abstract Factory

Prototype

Prototype permite criar novos objetos clonando um modelo existente, evitando a necessidade de criar objetos do zero.

Exemplo de Prototype

public class User implements Cloneable {
    private String name;
    private String email;
    private Setor setor;

    public User clone() {
        try {
            User clone = (User) super.clone();
            clone.setor = this.setor.clone(); // Clonagem profunda
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

Uso do Prototype

Padrões Estruturais

Adapter

Adapter permite que classes com interfaces incompatíveis trabalhem juntas, convertendo a interface de uma classe em outra que o cliente espera.

Exemplo de Adapter

public interface API {
    void request();
}

public class APIAdapter implements API {
    private LegacyAPI legacyAPI;

    public APIAdapter(LegacyAPI legacyAPI) {
        this.legacyAPI = legacyAPI;
    }

    public void request() {
        legacyAPI.oldRequest();
    }
}

Uso do Adapter

Bridge

Bridge separa a abstração da implementação, permitindo que ambas variem independentemente.

Exemplo de Bridge

public interface GeradorFotos {
    void gerarFoto();
}

public class GeradorFotosAltaQualidade implements GeradorFotos {
    public void gerarFoto() {
        // implementação para alta qualidade
    }
}

Uso do Bridge

Composite

Composite permite compor objetos em estruturas de árvore para representar hierarquias parte-todo, permitindo que clientes tratem objetos individuais e composições de forma uniforme.

Exemplo de Composite

public interface Pedido {
    void calculaPreco();
}

public class Caixa implements Pedido {
    public void calculaPreco() {
        // calcular preço dos itens
    }
}

public class Container implements Pedido {
    private List<Pedido> caixas;
    public void calculaPreco() {
        for (Caixa caixa : caixas) {
            caixa.calculaPreco();
        }
    }
}

Uso do Composite

Decorator

Decorator permite adicionar responsabilidades a objetos de forma dinâmica, sem alterar sua estrutura.

Exemplo de Decorator

public class PedidoSimples implements Pedido {
    public void calculaPreco() {
        // calcular preço básico
    }
}

public class PedidoComDesconto implements Pedido {
    private Pedido pedido;
    public PedidoComDesconto(Pedido pedido) {
        this.pedido = pedido;
    }
    public void calculaPreco() {
        pedido.calculaPreco();
        // aplicar desconto
    }
}

Uso do Decorator

Facade

Facade fornece uma interface unificada para um conjunto de interfaces em um subsistema, facilitando o uso do subsistema.

Exemplo de Facade

public class SistemaPagamentoFacade {
    public void processarPagamento() {
        banco.conectar();
        banco.autenticar();
        banco.transferir();
        banco.desconectar();
    }
}

Proxy

Proxy fornece um substituto ou representante de outro objeto para controlar o acesso a ele, podendo adicionar lógica adicional antes ou depois de acessar o objeto real.

Exemplo de Proxy

public class UserAPI implements API {
    public void request() {
        // implementação real
    }
}

public class UserAPIProxy implements API {
    private UserAPI userAPI;

    public UserAPIProxy(UserAPI userAPI) {
        this.userAPI = userAPI;
    }

    public void request() {
        // controle de acesso ou lógica adicional
        userAPI.request();
    }
}

Uso do Proxy

Flyweight

Flyweight usa compartilhamento para suportar grandes quantidades de objetos semelhantes de forma eficiente, minimizando o uso de memória.

Exemplo de Flyweight

public class Mesh {
    private String tipo;
    private Texture textura;
}

Uso do Flyweight

Conclusão

• Padrões são repertório, não receita fixa
• Nome do padrão importa menos que a intenção
• Escolha depende do problema real