Aplicando Design Patterns como Factory e Builder em Java

Quando se trata de desenvolvimento de software, a utilização de design patterns pode ajudar a tornar o código mais flexível, escalável e fácil de manter. Entre os padrões mais usados em Java, o Factory e o Builder se destacam por resolverem problemas comuns de criação de objetos de forma eficiente. Vamos explorar como implementá-los e entender suas diferenças e vantagens.

Factory Pattern

O Factory Pattern é um padrão criacional que define uma interface para a criação de objetos, mas permite que subclasses decidam qual classe instanciar. Ele permite desacoplar o código que utiliza objetos de sua implementação, facilitando a extensão e a manutenção.

Exemplo de Factory Pattern em Java

abstract class Animal {
    public abstract void speak();
}

class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("Meow!");
    }
}

class AnimalFactory {
    public static Animal createAnimal(String type) {
        if (type.equals("dog")) {
            return new Dog();
        } else if (type.equals("cat")) {
            return new Cat();
        }
        throw new IllegalArgumentException("Unknown animal type");
    }
}

Builder Pattern

O Builder Pattern é um padrão criacional que permite a construção de um objeto complexo passo a passo. Ao invés de criar um objeto diretamente, você usa um construtor para montar o objeto com os parâmetros desejados, oferecendo flexibilidade para a criação de instâncias complexas.

Exemplo de Builder Pattern em Java

class Computer {
    private String CPU;
    private String RAM;
    private String storage;

    public static class Builder {
        private String CPU;
        private String RAM;
        private String storage;

        public Builder setCPU(String CPU) {
            this.CPU = CPU;
            return this;
        }

        public Builder setRAM(String RAM) {
            this.RAM = RAM;
            return this;
        }

        public Builder setStorage(String storage) {
            this.storage = storage;
            return this;
        }

        public Computer build() {
            Computer computer = new Computer();
            computer.CPU = this.CPU;
            computer.RAM = this.RAM;
            computer.storage = this.storage;
            return computer;
        }
    }

    @Override
    public String toString() {
        return "Computer [CPU=" + CPU + ", RAM=" + RAM + ", Storage=" + storage + "]";
    }
}

Diferenças entre Factory e Builder

• Factory: Focado na criação de objetos de diferentes tipos, oferecendo um método centralizado para instanciá-los.
• Builder: Focado na criação de objetos complexos, permitindo a configuração flexível e gradual de atributos.

Vantagens

• Factory: Simplifica a criação de objetos e centraliza a lógica de instância, facilitando a adição de novos tipos.
• Builder: Ideal para objetos com muitos parâmetros ou que possuem combinações de configurações complexas, promovendo legibilidade.

Ambos os padrões são poderosos e podem ser usados em conjunto para criar sistemas flexíveis e fáceis de manter.

Incorporar o uso desses padrões pode melhorar significativamente a arquitetura de suas aplicações Java, promovendo melhores práticas de design de software e mantendo seu código limpo e organizado.