padrão de design de fábrica

Oi amigo! Hoje vamos continuar a estudar padrões de projeto. Nesta lição, vamos falar sobre fábricas. Discutiremos o problema que esse padrão resolve e veremos um exemplo de como uma fábrica pode ajudá-lo a abrir uma cafeteria. Além disso, darei a você 5 etapas simples para criar uma fábrica. Para ter certeza de que estamos todos no mesmo comprimento de onda e que você entenderá rapidamente esse conceito, você deve estar familiarizado com os seguintes tópicos:

• Herança em Java
• Limitação e ampliação de tipos de referência em Java
• Interação entre diferentes classes e objetos.

O que é uma fábrica?

O padrão de design de fábrica permite controlar a criação de objetos. O processo de criação de um novo objeto não é super simples, mas também não é excessivamente complicado. Todos nós sabemos que precisamos do newoperador para criar um novo objeto. Talvez pareça que não há nada para controlar aqui, mas isso não é verdade. Suponha que nosso aplicativo tenha uma determinada classe com muitos descendentes. Dificuldades podem surgir quando é necessário criar uma instância de uma classe específica dependendo de certas condições. Uma fábrica é um padrão de projeto que ajuda a resolver o problema de criar vários objetos dependendo de certas condições. Como é isso para um conceito abstrato? Isso ficará mais claro e específico quando olharmos para o exemplo abaixo.

Vamos preparar vários tipos de café

Suponha que queremos automatizar uma cafeteria. Precisamos ensinar nosso programa a fazer diferentes tipos de café. Para isso, criaremos uma classe de café e algumas classes derivadas para representar os tipos de café que iremos preparar: Americano, cappuccino, espresso e latte. Vamos começar com uma aula geral de café:

public class Coffee {
    public void grindCoffee(){
        // Grind the coffee
    }
    public void makeCoffee(){
        // Brew the coffee
    }
    public void pourIntoCup(){
        // Pour into a cup
    }
}

Em seguida, criaremos suas classes filhas:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

Nossos clientes podem pedir qualquer tipo de café. Seus pedidos precisam ser passados ​​para o programa. Isso pode ser feito de várias maneiras, por exemplo, usando String. Mas um enumé melhor para isso. Vamos criar enume definir campos enum que correspondem aos tipos de café que podem ser pedidos:

public enum CoffeeType {
    ESPRESSO,
    AMERICANO,
    CAFFE_LATTE,
    CAPPUCCINO
}

Ótimo. Agora vamos escrever o código para nossa cafeteria:

public class CoffeeShop {

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucсino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

O orderCoffeemétodo pode ser dividido em duas partes:

1. Criação de uma instância específica de café em uma switchinstrução. É aqui que uma fábrica faz o que faz - cria um tipo específico dependendo das condições.
2. Preparação - esta é a moagem, fermentação e derramamento em um copo.

Aqui está o que é importante saber se você precisar fazer alterações no método no futuro:

1. As etapas envolvidas na preparação em si (moer, preparar e despejar em um copo) permanecerão inalteradas (pelo menos estamos contando com isso).
2. Mas a variedade de cafés pode mudar. Talvez comecemos a fazer mocha... Frappu... Mochacci... Tanto faz, um novo tipo de café.

Já podemos estar bastante confiantes de que no futuro teremos que fazer alterações na switchinstrução do método. Também é possível que em nossa cafeteria o orderCoffeemétodo não seja o único lugar onde criaremos diferentes tipos de café. Como resultado, mudanças terão que ser feitas em vários lugares. Você provavelmente já entendeu onde quero chegar. Precisamos refatorar. Mova o bloco responsável pela criação do café para uma classe separada por dois motivos:

1. Podemos reutilizar a lógica de fazer café em outros lugares.
2. Se o sortimento mudar, não teremos que editar o código em todos os lugares onde o café é criado. Será o suficiente para alterar nosso código em apenas um lugar.

Em outras palavras, chegou a hora de montar uma fábrica.

Montando nossa primeira fábrica

Para isso, criaremos uma nova classe que será responsável apenas por criar as instâncias necessárias das classes café:

public class SimpleCoffeeFactory {
    public Coffee createCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        return coffee;
    }
}

Parabéns! Acabamos de implementar o padrão de projeto de fábrica em sua forma mais simples (quase). Poderia ter sido ainda mais simples se fizéssemos o createCoffeemétodo estático. Mas então perderíamos duas capacidades:

1. A capacidade de herdar SimpleCoffeeFactorye substituir o createCoffeemétodo.
2. A capacidade de adicionar a implementação de fábrica necessária às nossas aulas.

A propósito, falando em implementação... Precisamos voltar à cafeteria e adicionar nossa fábrica de café.

Adicionando uma fábrica à cafeteria

Vamos reescrever a classe coffee shop usando uma fábrica:

public class CoffeeShop {

    private final SimpleCoffeeFactory coffeeFactory;

    public CoffeeShop(SimpleCoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = coffeeFactory.createCoffee(type);
        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

Excelente. Agora forneceremos uma descrição concisa da estrutura geral do padrão de projeto de fábrica.

5 passos para abrir sua própria fábrica

Passo 1. Seu programa possui uma classe com vários descendentes, conforme o diagrama abaixo: Passo 2. Você cria um enuman com um campo para cada classe filha:

enum CatType {
    LION,
    TIGER,
    FLUFFY
}

Passo 3. Construa sua fábrica. Chame-o CatFactory. Aqui está o código:

class CatFactory {}

Etapa 4. Em sua fábrica, crie um createCatmétodo que receba um CatTypeargumento. Aqui está o código:

class CatFactory {
    public Cat createCat(CatType type) {

    }
}

Etapa 5. No corpo do método, escreva uma switchinstrução que enumera os campos enum e crie uma instância da classe que corresponde ao enumvalor passado:

class CatFactory {
        public Cat createCat(CatType type) {
            Cat cat = null;

            switch (type) {
                case LION:
                    cat =  new Fluffy();
                    break;
                case TIGER:
                    cat = new Tiger();
                    break;
                case FLUFFY:
                    cat =  new Lion();
                    break;
            }

            return cat;
        }
    }

Agora você pode administrar uma fábrica como um chefe. :)

como praticar

Ler é bom, escrever código é ainda melhor. Se o seu nome tiver um número par de letras, tente criar sua própria pizzaria virtual. Se o seu nome tiver um número ímpar de letras, tente criar um sushi bar virtual. Se você não tem nome, você teve sorte. Hoje você pode relaxar.