创造者模式-优快云博客

简单工厂模式：

我的理解：

简单工厂模式的核心思想是将对象创建的复杂逻辑（尤其是多分支的 if/else 判断）进行封装，提取为独立的工厂类。具体做法是：

定义一个公共接口，让多个不同的实现类去实现该接口。
创建一个工厂类，该类根据传入的参数（如 type 或 name）来决定实例化哪个具体的实现类。

优点：

将对象的创建与使用分离，客户端无需关心具体实现类的创建过程。
通过统一入口创建对象，便于集中管理创建逻辑。

存在的问题：

每次新增一个实现类时，都必须修改工厂类中的创建逻辑（增加新的分支判断），这违反了 开闭原则（对扩展开放，对修改关闭），不利于系统的维护和扩展。

适用场景：

适用于产品种类较少、创建逻辑相对固定的情况，例如配置解析器、日志记录器等。

// 1. 定义接口
interface Product {
    void use();
}

// 2. 实现类A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 3. 实现类B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 4. 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("未知产品类型");
    }
}

// 5. 使用示例
public class Demo {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct("A");
        product.use(); // 输出：使用产品A
    }
}

工厂方法模式

图片来自：https://refactoringguru.cn/design-patterns/factory-method

我的理解：

工厂方法模式是针对简单工厂模式缺点的改进。它将工厂也抽象为接口或抽象类，每个具体工厂只负责创建一种具体产品，实现“一个工厂对应一个产品”。

核心改进：

新增产品时，只需增加对应的产品类和工厂类，无需修改已有工厂的代码，符合开闭原则。
系统的可扩展性更强，结构更清晰。

实现方式：

定义产品接口。
定义工厂接口，其中声明一个创建产品的方法。
为每个产品实现一个对应的具体工厂。

适用场景：

适用于产品结构稳定，但可能经常需要新增产品类型的系统，如电商系统中的支付方式、物流公司等。

// 1. 产品接口
interface Vehicle {
    void drive();
}

// 2. 具体产品：汽车
class Car implements Vehicle {
    @Override
    public void drive() {
        System.out.println("驾驶汽车");
    }
}

// 3. 具体产品：自行车
class Bike implements Vehicle {
    @Override
    public void drive() {
        System.out.println("骑自行车");
    }
}

// 4. 抽象工厂
interface VehicleFactory {
    Vehicle createVehicle();
}

// 5. 具体工厂：汽车工厂
class CarFactory implements VehicleFactory {
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
}

// 6. 具体工厂：自行车工厂
class BikeFactory implements VehicleFactory {
    @Override
    public Vehicle createVehicle() {
        return new Bike();
    }
}

// 7. 使用示例
public class Demo {
    public static void main(String[] args) {
        VehicleFactory factory = new CarFactory();
        Vehicle vehicle = factory.createVehicle();
        vehicle.drive(); // 输出：驾驶汽车
    }
}

抽象工厂模式

图片来自：https://refactoringguru.cn/design-patterns/abstract-factory

我的理解：

抽象工厂模式用于创建 一系列相关或相互依赖的对象，这些对象构成一个“产品族”。一个具体工厂不再只创建单一产品，而是负责创建一整组具有关联性的产品。

关键区别：

工厂方法模式：一个工厂创建一个产品（一对一）。
抽象工厂模式：一个工厂创建多个相关产品（一对多）。

例子：

例如 GUI 库中，一个“Windows 工厂”负责创建 Windows 风格的按钮、文本框、窗口；而“Mac 工厂”则创建 Mac 风格的一系列组件。

适用场景：

适用于需要保证一系列产品之间兼容性或风格一致的场景，如跨平台的 UI 组件库、主题系统等。

// 1. 抽象产品：按钮
interface Button {
    void render();
}

// 2. 抽象产品：文本框
interface TextBox {
    void display();
}

// 3. 具体产品：Windows 按钮
class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染 Windows 风格按钮");
    }
}

// 4. 具体产品：Mac 按钮
class MacButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染 Mac 风格按钮");
    }
}

// 5. 抽象工厂接口
interface GUIFactory {
    Button createButton();
    TextBox createTextBox();
}

// 6. 具体工厂：Windows 工厂
class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
    @Override
    public TextBox createTextBox() {
        return new WindowsTextBox();
    }
}

// 7. 使用示例
public class Demo {
    public static void main(String[] args) {
        GUIFactory factory = new WindowsFactory();
        Button button = factory.createButton();
        button.render(); // 输出：渲染 Windows 风格按钮
    }
}

建造者模式

建造者模式，图片来自 refactoringguru.cn

图片来自：https://refactoringguru.cn/design-patterns/builder

我的理解：

建造者模式适用于创建具有复杂内部结构、包含多个组成部分的对象，并且这些部分需要按照一定的顺序或规则进行组装。

常见应用：

例如 Lombok 的 @Builder 注解，可以通过链式调用逐步设置属性，最终构建一个完整对象。

优点：

封装了对象的构造过程，使得创建逻辑清晰、易于维护。
支持分步构建，可以灵活组合不同的部件。

适用场景：

适用于构造复杂对象，且对象的组成部分经常变化的场景，如配置对象、HTTP 请求对象、报表生成等。

// 1. 产品类：电脑
class Computer {
    private String cpu;
    private String memory;
    private String disk;

    // 私有构造方法，只能通过建造者创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.memory = builder.memory;
        this.disk = builder.disk;
    }

    // 建造者静态内部类
    public static class Builder {
        private String cpu;
        private String memory;
        private String disk;

        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder setMemory(String memory) {
            this.memory = memory;
            return this;
        }

        public Builder setDisk(String disk) {
            this.disk = disk;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }

    @Override
    public String toString() {
        return "Computer[cpu=" + cpu + ", memory=" + memory + ", disk=" + disk + "]";
    }
}

// 2. 使用示例
public class Demo {
    public static void main(String[] args) {
        Computer computer = new Computer.Builder()
                .setCpu("Intel i7")
                .setMemory("16GB")
                .setDisk("512GB SSD")
                .build();
        System.out.println(computer);
    }
}

原型模式

原型模式，图片来自 refactoringguru.cn

图片来自：https://refactoringguru.cn/design-patterns/prototype

我的理解：

原型模式通过复制现有对象（原型）来创建新对象，而不是通过 new 关键字进行初始化。Java 中可通过实现 Cloneable 接口并重写 clone() 方法来实现。

适用场景：

当对象的创建过程较为复杂或耗时（如涉及复杂计算、IO 操作等），且新对象与已有对象差异不大时，使用原型模式直接复制会更高效。

注意：

需要区分浅拷贝与深拷贝，特别是当对象包含引用类型成员时，确保复制行为符合预期。

// 1. 实现 Cloneable 接口
class Sheep implements Cloneable {
    private String name;
    private String color;

    public Sheep(String name, String color) {
        this.name = name;
        this.color = color;
    }

    // 重写 clone 方法
    @Override
    public Sheep clone() throws CloneNotSupportedException {
        return (Sheep) super.clone();
    }

    @Override
    public String toString() {
        return "Sheep{name='" + name + "', color='" + color + "'}";
    }
}

// 2. 使用示例
public class Demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep original = new Sheep("Dolly", "白色");
        Sheep cloned = original.clone();

        System.out.println("原羊：" + original);
        System.out.println("克隆羊：" + cloned);
        System.out.println("是否是同一对象：" + (original == cloned)); // false
    }
}