🏗️ Padrão Facade - Design de Software

Implementação prática do Padrão Facade (Fachada) como parte do estudo dos Gang of Four Design Patterns. Este projeto demonstra como simplificar interfaces complexas através de uma camada de abstração unificada.

📋 Sobre o Padrão Facade

O Padrão Facade é um padrão estrutural que fornece uma interface simplificada para um subsistema complexo. Ele atua como uma "fachada" que oculta a complexidade interna do sistema, oferecendo apenas os métodos essenciais para o cliente.

🎯 Objetivo Principal

• Simplificar interfaces complexas
• Reduzir dependências entre cliente e subsistemas
• Centralizar operações comuns em uma única interface
• Facilitar o uso e manutenção do sistema

🏛️ Estrutura do Padrão

┌─────────────────┐
│     CLIENTE     │
└─────────┬───────┘
          │
          ▼
┌─────────────────┐       ┌──────────────────┐
│    FACADE       │ ────► │   Subsistema A   │
│                 │       └──────────────────┘
│ + operacao1()   │       ┌──────────────────┐
│ + operacao2()   │ ────► │   Subsistema B   │
│ + operacao3()   │       └──────────────────┘
└─────────────────┘       ┌──────────────────┐
                    ────► │   Subsistema C   │
                          └──────────────────┘

📁 Estrutura do Projeto

Facade/
├── src/
│   ├── facade/
│   │   └── SistemaFacade.java        # Classe Facade principal
│   ├── subsistemas/
│   │   ├── SubsistemaA.java          # Primeiro subsistema
│   │   ├── SubsistemaB.java          # Segundo subsistema
│   │   └── SubsistemaC.java          # Terceiro subsistema
│   ├── cliente/
│   │   └── Cliente.java              # Classe cliente
│   └── Main.java                     # Demonstração do padrão
├── docs/
│   ├── diagrama-uml.png              # Diagrama UML do padrão
│   └── explicacao.md                 # Documentação detalhada
└── README.md                         # Este arquivo

💻 Implementação

Exemplo Prático: Sistema de Home Theater

Este projeto implementa um sistema de Home Theater como exemplo do padrão Facade, onde diferentes subsistemas (TV, Som, Luzes, etc.) são controlados através de uma interface simplificada.

Subsistemas Complexos:

// SubsistemaA.java - Sistema de Som
public class SistemaSom {
    public void ligar() {
        System.out.println("Sistema de som ligado");
    }
    
    public void definirVolume(int volume) {
        System.out.println("Volume ajustado para: " + volume);
    }
    
    public void definirEntrada(String entrada) {
        System.out.println("Entrada definida para: " + entrada);
    }
    
    public void desligar() {
        System.out.println("Sistema de som desligado");
    }
}

// SubsistemaB.java - Sistema de Projeção
public class SistemaProjecao {
    public void ligar() {
        System.out.println("Projetor ligado");
    }
    
    public void definirEntrada(String entrada) {
        System.out.println("Projetor configurado para: " + entrada);
    }
    
    public void modoTela() {
        System.out.println("Modo tela ativado");
    }
    
    public void desligar() {
        System.out.println("Projetor desligado");
    }
}

// SubsistemaC.java - Sistema de Iluminação
public class SistemaIluminacao {
    public void diminuirLuzes(int nivel) {
        System.out.println("Luzes diminuídas para " + nivel + "%");
    }
    
    public void aumentarLuzes() {
        System.out.println("Luzes aumentadas");
    }
}

Classe Facade:

// SistemaFacade.java
public class HomeTheaterFacade {
    private SistemaSom som;
    private SistemaProjecao projetor;
    private SistemaIluminacao luzes;
    
    public HomeTheaterFacade(SistemaSom som, SistemaProjecao projetor, 
                            SistemaIluminacao luzes) {
        this.som = som;
        this.projetor = projetor;
        this.luzes = luzes;
    }
    
    // Interface simplificada para o cliente
    public void assistirFilme(String filme) {
        System.out.println("Preparando para assistir " + filme + "...\n");
        
        // Coordena todos os subsistemas
        luzes.diminuirLuzes(10);
        projetor.ligar();
        projetor.definirEntrada("DVD");
        projetor.modoTela();
        som.ligar();
        som.definirVolume(70);
        som.definirEntrada("DVD");
        
        System.out.println("\nTudo pronto! Aproveite o filme!");
    }
    
    public void finalizarSessao() {
        System.out.println("Finalizando sessão de cinema...\n");
        
        som.desligar();
        projetor.desligar();
        luzes.aumentarLuzes();
        
        System.out.println("\nSistema desligado!");
    }
}

Cliente Simplificado:

// Cliente.java
public class Cliente {
    public static void main(String[] args) {
        // Instância dos subsistemas
        SistemaSom som = new SistemaSom();
        SistemaProjecao projetor = new SistemaProjecao();
        SistemaIluminacao luzes = new SistemaIluminacao();
        
        // Facade simplifica o uso
        HomeTheaterFacade homeTheater = 
            new HomeTheaterFacade(som, projetor, luzes);
        
        // Interface simples para operações complexas
        homeTheater.assistirFilme("Matrix");
        
        System.out.println("\n" + "=".repeat(40) + "\n");
        
        homeTheater.finalizarSessao();
    }
}

🚀 Como Executar

Pré-requisitos

• Java JDK 8 ou superior
• IDE Java (IntelliJ, Eclipse, VS Code)

Executar o projeto:

# Clone o repositório
git clone https://github.com/RGPaix/Fa-ade.git
cd Fa-ade/Facade

# Compile as classes Java
javac -d bin src/**/*.java

# Execute a demonstração
java -cp bin Main

Saída esperada:

Preparando para assistir Matrix...

Luzes diminuídas para 10%
Projetor ligado
Projetor configurado para: DVD
Modo tela ativado
Sistema de som ligado
Volume ajustado para: 70
Entrada definida para: DVD

Tudo pronto! Aproveite o filme!

========================================

Finalizando sessão de cinema...

Sistema de som desligado
Projetor desligado
Luzes aumentadas

Sistema desligado!

✅ Vantagens do Padrão Facade

🎯 Simplicidade

• Interface única e fácil de usar
• Reduz a curva de aprendizado
• Diminui a complexidade para o cliente

🔧 Manutenibilidade

• Mudanças nos subsistemas não afetam o cliente
• Centralização da lógica de coordenação
• Facilita refatorações futuras

🔗 Baixo Acoplamento

• Cliente depende apenas da Facade
• Subsistemas podem evoluir independentemente
• Maior flexibilidade arquitetural

📦 Organização

• Agrupa funcionalidades relacionadas
• Define pontos de entrada claros
• Melhora a estrutura do código

📊 Quando Usar o Padrão Facade

✅ Use quando:

• Sistema tem muitos subsistemas complexos
• Quer simplificar uma API complexa
• Precisa de pontos de entrada bem definidos
• Quer reduzir dependências entre camadas

❌ Evite quando:

• Sistema já é simples o suficiente
• Clientes precisam de controle granular
• Performance é crítica (evitar camadas extras)
• Há apenas um subsistema envolvido

🔍 Outros Exemplos de Uso

1. Sistema Bancário

public class ContaBancariaFacade {
    public void transferir(String origem, String destino, double valor) {
        // Coordena: validação, débito, crédito, log, notificação
    }
}

2. E-commerce

public class CheckoutFacade {
    public void finalizarCompra(Pedido pedido) {
        // Coordena: pagamento, estoque, entrega, nota fiscal
    }
}

3. Sistema de Relatórios

public class RelatorioFacade {
    public void gerarRelatorioVendas(Date inicio, Date fim) {
        // Coordena: consulta BD, processamento, formatação, envio
    }
}

🧪 Exercícios Propostos

1. Adicione um novo subsistema Iluminacao.java no pacote modelos
2. Implemente um método ajustarConfiguracoes() na classe HomeTheatre
3. Crie validações nos parâmetros de entrada dos métodos
4. Adicione tratamento de exceções para operações que podem falhar
5. Implemente um método statusSistema() que mostra o estado atual de todos os equipamentos

📚 Conceitos Relacionados

• Adapter Pattern: Adapta interfaces incompatíveis
• Composite Pattern: Trata objetos únicos e compostos uniformemente
• Decorator Pattern: Adiciona funcionalidades dinamicamente
• Proxy Pattern: Controla acesso a objetos

🎓 Aprendizados

O que o padrão Facade ensina:

• Abstração: Ocultar complexidade desnecessária
• Responsabilidade única: Facade tem papel bem definido
• Composição: Usar objetos ao invés de herança
• API Design: Como criar interfaces intuitivas

👨‍💻 Autor

Desenvolvido por: @RGPaix
Disciplina: Design de Software
Padrão: Facade (Gang of Four)
Categoria: Padrão Estrutural

📚 Referências

• Gang of Four: Design Patterns - Elements of Reusable Object-Oriented Software
• Head First Design Patterns - Freeman, Freeman, Bates, Sierra
• Refactoring Guru: Facade Pattern
• Oracle Java Docs: Best Practices

📞 Contato

• GitHub: @RGPaix
• Issues: Reportar problemas

---

🏗️ "A simplicidade é a sofisticação máxima" - Leonardo da Vinci

Este projeto demonstra como o padrão Facade torna sistemas complexos mais simples e elegantes.