Java基础教程（204）设计模式之创建型模式：Java设计模式基石：深度剖析创建型模式与实战示例-优快云博客

1. 单例模式（Singleton Pattern）

单例模式确保一个类仅有一个实例，并提供全局访问点。适用于需要频繁创建和销毁的对象，或避免多个实例产生冲突的场景。

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂方法模式（Factory Method Pattern）

定义一个创建对象的接口，但让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类，完美遵循开闭原则。

public interface Logger {
    void log(String message);
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 记录日志到文件
    }
}

public abstract class LoggerFactory {
    public abstract Logger createLogger();
    
    public void writeLog() {
        Logger logger = createLogger();
        logger.log("日志消息");
    }
}

3. 抽象工厂模式（Abstract Factory Pattern）

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用于产品族的创建，支持系统切换产品系列。

public interface Button {
    void render();
}

public interface TextField {
    void display();
}

public interface GUIFactory {
    Button createButton();
    TextField createTextField();
}

// 具体工厂实现
public class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
    
    @Override
    public TextField createTextField() {
        return new WindowsTextField();
    }
}

4. 建造者模式（Builder Pattern）

将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。特别适用于具有多个构造参数且需要灵活组合的场景。

public class Computer {
    private final String CPU;
    private final String RAM;
    private final String storage;
    
    private Computer(Builder builder) {
        this.CPU = builder.CPU;
        this.RAM = builder.RAM;
        this.storage = builder.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() {
            return new Computer(this);
        }
    }
}

5. 原型模式（Prototype Pattern）

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。适用于创建成本较高的对象，或需要动态配置系统的场景。

public abstract class Shape implements Cloneable {
    private String id;
    protected String type;
    
    abstract void draw();
    
    public String getType() {
        return type;
    }
    
    public String getId() {
        return id;
    }
    
    public void setId(String id) {
        this.id = id;
    }
    
    @Override
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

// 具体原型类
public class Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }
    
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}