Padrão Factory

Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 66 de 87.

O Factory Pattern é um padrão de projeto criacional que delega a criação de objetos a um método ou classe separado. Em vez de usar new diretamente no seu código, você solicita a uma fábrica que crie objetos para você. Isso é especialmente útil quando você tem várias classes relacionadas que compartilham uma interface ou classe-pai comum.

Considere um sistema de notificações que pode enviar e-mails, SMS ou notificações push. Sem uma fábrica, seu código precisaria conhecer cada classe concreta:

// Sem Factory - o cliente deve conhecer todas as classes concretas
Notification notification;
if (type.equals("email")) {
    notification = new EmailNotification();
} else if (type.equals("sms")) {
    notification = new SMSNotification();
}

Com o Padrão Factory, você centraliza esta lógica de criação:

public interface Notification {
    void send(String message);
}

public class EmailNotification implements Notification {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

public class SMSNotification implements Notification {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

public class NotificationFactory {
    public static Notification create(String type) {
        if (type.equals("email")) {
            return new EmailNotification();
        } else if (type.equals("sms")) {
            return new SMSNotification();
        }
        return null;
    }
}

Agora o código do cliente está mais limpo e não depende de classes concretas:

Notification notification = NotificationFactory.create("email");
notification.send("Hello!");  // Saída: Email: Hello!

O principal benefício é que adicionar novos tipos de notificação exige apenas atualizar a fábrica: o código do cliente permanece inalterado. Isso segue o princípio de programar para uma interface, tornando seu sistema mais flexível e fácil de estender.

Desafio

Fácil

Vamos criar um sistema de desenho de formas usando o Factory Pattern! Em vez de criar objetos de formas diretamente em todo o seu código, você centralizará a lógica de criação em uma fábrica que produz diferentes tipos de formas com base em um identificador de string simples.

Você organizará seu código em quatro arquivos:

Shape.java: Defina uma interface chamada Shape que sirva como contrato comum para todas as formas. Sua interface deve declarar um único método draw() que não retorna nada, mas imprime informações sobre a forma que está sendo desenhada.
Shapes.java: Crie três classes que implementem sua interface Shape:
Circle — seu método draw() deve imprimir Drawing a Circle

Rectangle — seu método draw() deve imprimir Drawing a Rectangle

Triangle — seu método draw() deve imprimir Drawing a Triangle
ShapeFactory.java: Crie a classe fábrica que gerencia a criação de formas. Sua ShapeFactory deve ter um método estático createShape(String type) que retorne uma Shape. Com base no parâmetro type:
- Se type for igual a "circle", retorne uma nova Circle
- Se type for igual a "rectangle", retorne uma nova Rectangle
- Se type for igual a "triangle", retorne uma nova Triangle
- Para qualquer outro valor, retorne null
Main.java: Reúna seu sistema de fábrica! Você receberá duas entradas: dois tipos de forma (ambos Strings).
Para cada entrada, use sua ShapeFactory para criar a forma e armazene-a em uma variável Shape. Se a fábrica retornar uma forma válida (não nula), chame seu método draw(). Se retornar null, imprima Unknown shape: [type], em que [type] é a entrada fornecida.

Processe as duas entradas na ordem, cada uma em sua própria linha de saída.

Você receberá duas entradas na ordem: o primeiro tipo de forma (String) e o segundo tipo de forma (String).

Observe como sua classe Main nunca usa new Circle() ou new Rectangle() diretamente. Ela conhece apenas a interface Shape e pede à fábrica que crie os objetos. Esse é o poder do Factory Pattern: o código cliente fica desacoplado das classes concretas!

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lê dois tipos de forma
        String type1 = scanner.nextLine();
        String type2 = scanner.nextLine();
        
        // TODO: Use ShapeFactory para criar a primeira forma
        // Se a forma não for null, chame draw()
        // If the shape is null, print "Unknown shape: [type]"
        
        // TODO: Faça o mesmo para a segunda forma
        
    }
}