Que tarefas resolveu usando padrões de projeto?

Aplicou vários padrões para melhorar a estrutura e a manutenibilidade do código:

Criacionais:

• Singleton: Para criar uma única instância de objetos, por exemplo, um gestor de configuração ou um pool de conexões à base de dados.

  public final class ConfigManager {
      private static ConfigManager instance;
      private ConfigManager() {} // Construtor privado
      public static synchronized ConfigManager getInstance() {
          if (instance == null) {
              instance = new ConfigManager();
          }
          return instance;
      }
  }
  

• Factory Method: Para criar objetos com propriedades específicas sem indicar explicitamente as classes concretas. Usado ao trabalhar com diferentes tipos de analisadores de ficheiros.
• Abstract Factory: Para criar famílias de objetos relacionados ou dependentes sem indicar as suas classes concretas. Aplicado ao trabalhar com diferentes tipos de fontes de dados (por exemplo, sistema de ficheiros, base de dados) e os seus objetos correspondentes.

Estruturais:

• Adapter: Para adaptar a interface de uma classe a outra que o cliente espera. Usado para integrar bibliotecas externas com interfaces incompatíveis.

  public interface Target {
      void request();
  }
  
  public class Adaptee {
      public void specificRequest() {
          System.out.println("Pedido específico do Adaptee");
      }
  }
  
  public class Adapter implements Target {
      private Adaptee adaptee;
  
      public Adapter(Adaptee adaptee) {
          this.adaptee = adaptee;
      }
  
      @Override
      public void request() {
          adaptee.specificRequest();
      }
  }
  

• Decorator: Para adicionar dinamicamente novas responsabilidades a objetos sem alterar a sua estrutura. Usado para adicionar funcionalidades de registo ou cache a objetos existentes.
• Composite: Para compor objetos em estruturas de árvore para representar hierarquias "parte-todo". Usado ao trabalhar com elementos de interface de utilizador ou estrutura de ficheiros.

Comportamentais:

• Observer: Para definir uma dependência "um-para-muitos" entre objetos de modo que, quando o estado de um mudar, todos os dependentes sejam notificados e atualizados automaticamente. Usado para implementar sistemas de notificação de eventos.

  import java.util.ArrayList;
  import java.util.List;
  
  public class Subject {
      private List<Observer> observers = new ArrayList<>();
      private int state;
  
      public void attach(Observer observer) {
          observers.add(observer);
      }
  
      public void setState(int state) {
          this.state = state;
          notifyObservers();
      }
  
      private void notifyObservers() {
          for (Observer observer : observers) {
              observer.update();
          }
      }
  }
  
  public interface Observer {
      void update();
  }
  

• Strategy: Para definir famílias de algoritmos, encapsulando cada um deles e garantindo sua intercambialidade. Usado para escolher diferentes estratégias de processamento de dados dependendo do contexto.
• Template Method: Para definir a estrutura de um algoritmo na operação, deixando alguns passos para serem definidos por subclasses. Aplicado para padronizar o processo de tratamento de requisições.