Desvendando o Abstract Factory Pattern em Java

O Abstract Factory Pattern é um padrão de design criacional que fornece uma maneira de encapsular um grupo de fábricas individuais que têm um tema comum sem especificar suas classes concretas. Em termos mais simples, o Abstract Factory é um super-factory que cria outros factories.

Vamos usar o exemplo de uma loja de móveis para ilustrar o Abstract Factory Pattern. Suponha que existam duas fábricas principais, a 'Fábrica de Móveis Modernos' e a 'Fábrica de Móveis Vitorianos'. Ambas as fábricas produzem os mesmos tipos de móveis (cadeira, sofá, mesa), mas em estilos diferentes.

Primeiro, criamos uma interface para nossos produtos:

public interface Cadeira {
    void temPernas();
    void sentar();
}

public interface Sofa {
    void temPernas();
    void deitar();
}

public interface Mesa {
    void temPernas();
    void usar();
}

Em seguida, criamos classes concretas de produtos para os diferentes estilos de móveis:

public class CadeiraModerna implements Cadeira {
    @Override
    public void temPernas() {
        System.out.println("A cadeira moderna tem quatro pernas de metal.");
    }
    @Override
    public void sentar() {
        System.out.println("A cadeira moderna é muito confortável!");
    }
}
// Faça o mesmo para SofaModerno e MesaModerna

public class CadeiraVitoriana implements Cadeira {
    @Override
    public void temPernas() {
        System.out.println("A cadeira vitoriana tem quatro pernas ornamentadas.");
    }
    @Override
    public void sentar() {
        System.out.println("A cadeira vitoriana é muito elegante!");
    }
}
// Faça o mesmo para SofaVitoriano e MesaVitoriana

Agora, vamos ao Abstract Factory:

public interface MovelFactory {
    Cadeira criarCadeira();
    Sofa criarSofa();
    Mesa criarMesa();
}

Agora, vamos ao Abstract Factory:

public class ModernoFactory implements MovelFactory {
    @Override
    public Cadeira criarCadeira() {
        return new CadeiraModerna();
    }
    @Override
    public Sofa criarSofa() {
        return new SofaModerno();
    }
    @Override
    public Mesa criarMesa() {
        return new MesaModerna();
    }
}

public class VitorianoFactory implements MovelFactory {
    @Override
    public Cadeira criarCadeira() {
        return new CadeiraVitoriana();
    }
    @Override
    public Sofa criarSofa() {
        return new SofaVitoriano();
    }
    @Override
    public Mesa criarMesa() {
        return new MesaVitoriana();
    }
}

Conclusão

O Abstract Factory Pattern nos permite abstrair a criação de um conjunto de produtos relacionados, permitindo fácil substituição de fábricas, cumprindo o princípio da substituição de Liskov. Assim, podemos mudar facilmente o estilo dos móveis da nossa loja sem mudar o código que os utiliza. Essa abstração e flexibilidade tornam o Abstract Factory Pattern uma escolha popular para muitos desenvolvedores Java.

Espero que este artigo tenha esclarecido o padrão de design da Abstract Factory em Java para você. Fique à vontade para deixar seus comentários ou perguntas, e estou ansioso para continuar esta discussão!