Приведите примеры порождающих шаблонов проектирования.

Фабричный метод (Factory Method): Определяет интерфейс для создания объекта, но позволяет подклассам решать, какой класс инстанцировать.

// Интерфейс продукта
interface Product {
    void operation();
}

// Конкретный продукт A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("Concrete Product A Operation");
    }
}

// Конкретный продукт B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("Concrete Product B Operation");
    }
}

// Абстрактный создатель
abstract class Creator {
    public abstract Product factoryMethod();

    public void someOperation() {
        Product product = factoryMethod();
        product.operation();
    }
}

// Конкретный создатель A
class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// Конкретный создатель B
class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

Абстрактная фабрика (Abstract Factory): Предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов без указания их конкретных классов.

// Абстрактная фабрика
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// Абстрактные продукты
interface AbstractProductA {
    void usefulFunctionA();
}

interface AbstractProductB {
    void usefulFunctionB();
    void anotherUsefulFunctionB(AbstractProductA collaborator);
}

// Конкретная фабрика 1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// Конкретная фабрика 2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// Конкретные продукты для Фа1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void usefulFunctionA() {
        System.out.println("Product A1");
    }
}

class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void usefulFunctionB() {
        System.out.println("Product B1");
    }

    @Override
    public void anotherUsefulFunctionB(AbstractProductA collaborator) {
        System.out.println("Product B1 collaborating with " + collaborator);
    }
}

// Конкретные продукты для Фа2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void usefulFunctionA() {
        System.out.println("Product A2");
    }
}

class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void usefulFunctionB() {
        System.out.println("Product B2");
    }

    @Override
    public void anotherUsefulFunctionB(AbstractProductA collaborator) {
        System.out.println("Product B2 collaborating with " + collaborator);
    }
}

Строитель (Builder): Позволяет пошагово создавать сложный объект. Он отделяет конструирование сложного объекта от его представления, позволяя использовать один и тот же процесс конструирования для создания различных представлений.

// Продукт
class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) { this.partA = partA; }
    public void setPartB(String partB) { this.partB = partB; }
    public void setPartC(String partC) { this.partC = partC; }

    @Override
    public String toString() {
        return "Product [partA=" + partA + ", partB=" + partB + ", partC=" + partC + "]";
    }
}

// Абстрактный строитель
interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

// Конкретный строитель
class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("Part A Built");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part B Built");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part C Built");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

// Директор (опционально)
class Director {
    private Builder builder;

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

Прототип (Prototype): Указывает виды создаваемых объектов с помощью образца (прототипа) и создает новые объекты путем копирования этого образца.

// Прототип
interface Prototype extends Cloneable {
    Prototype clone();
    void sayHello();
}

// Конкретный Прототип
class ConcretePrototype implements Prototype {
    private String name;

    public ConcretePrototype(String name) {
        this.name = name;
    }

    @Override
    public Prototype clone() {
        try {
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
            // Обычно здесь логируется или обрабатывается ошибка
            throw new RuntimeException(e);
        }
    }

    @Override
    public void sayHello() {
        System.out.println("Hello from " + name);
    }
}

Одиночка (Singleton): Гарантирует, что класс имеет только один экземпляр, и предоставляет глобальную точку доступа к этому экземпляру.

class Singleton {
    private static Singleton instance;

    // Приватный конструктор, чтобы предотвратить создание экземпляров извне
    private Singleton() {
    }

    // Глобальная точка доступа
    public static Singleton getInstance() {
        if (instance == null) {
            // Ленивая инициализация
            instance = new Singleton();
        }
        return instance;
    }

    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}