Provide examples of creational design patterns.

Factory Method: Defines an interface for creating an object, but lets subclasses decide which class to instantiate.

// Product interface
interface Product {
    void operation();
}

// Concrete Product A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("Concrete Product A Operation");
    }
}

// Concrete Product B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("Concrete Product B Operation");
    }
}

// Creator
abstract class Creator {
    public abstract Product factoryMethod();

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

// Concrete Creator A
class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// Concrete Creator B
class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

Abstract Factory: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

// Abstract Factory
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// Abstract Products
interface AbstractProductA {
    void usefulFunctionA();
}

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

// Concrete Factory 1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

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

// Concrete Factory 2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

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

// Concrete Products for Factory 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);
    }
}

// Concrete Products for Factory 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: Allows step-by-step construction of complex objects. It separates the construction of a complex object from its representation, enabling the same construction process to create various representations.

// Product
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 + "]";
    }
}

// Builder interface
interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

// Concrete Builder
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;
    }
}

// Director (optional)
class Director {
    private Builder builder;

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

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

Prototype: Specifies the kinds of objects to create using a prototypical instance, and creates new objects by copying this prototype.

// Prototype
interface Prototype extends Cloneable {
    Prototype clone();
    void sayHello();
}

// Concrete Prototype
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: Ensures a class has only one instance, and provides a global point of access to it.

class Singleton {
    private static Singleton instance;

    // Private constructor to prevent external instantiation
    private Singleton() {
    }

    // Global access point
    public static Singleton getInstance() {
        if (instance == null) {
            // Lazy initialization
            instance = new Singleton();
        }
        return instance;
    }

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