创建型模式全景回顾

嘿，程序猿朋友们！在过去的几篇文章中，我们一起探讨并实现了多种创建型设计模式。今天，让我们来一个大总结，回顾这些模式的核心思想、实现方式及其应用场景；无论你是设计模式的新手还是老手，这篇总结都能帮你全面掌握创建型模式的精髓。

创建型模式简介

创建型模式关注于对象的创建过程，它们提供了一种方式来创建对象，而不是直接使用类的构造函数。这不仅可以提高代码的灵活性和可维护性，还可以优化性能，创建型模式主要包括以下几种：

1. 单例模式（Singleton Pattern）
2. 简单工厂模式（Simple Factory Pattern）
3. 工厂方法模式（Factory Method Pattern）
4. 抽象工厂模式（Abstract Factory Pattern）
5. 建造者模式（Builder Pattern）
6. 原型模式（Prototype Pattern）

一、单例模式

核心思想

单例模式确保一个类只有一个实例，并提供一个全局访问点来访问这个实例：

实现方式

Python实现

class Singleton:
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

Java实现

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

应用场景

• 需要确保一个类只有一个实例时；
• 需要提供一个全局访问点时。

二、简单工厂模式

核心思想

简单工厂模式通过一个工厂类根据传入的参数决定创建哪一种产品类的实例：

实现方式

Python实现

class Product:
    pass

class ConcreteProductA(Product):
    pass

class ConcreteProductB(Product):
    pass

class SimpleFactory:
    @staticmethod
    def create_product(type):
        if type == 'A':
            return ConcreteProductA()
        elif type == 'B':
            return ConcreteProductB()

Java实现

public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

public class Product {}

public class ConcreteProductA extends Product {}

public class ConcreteProductB extends Product {}

应用场景

• 需要根据条件动态创建不同类型对象时；
• 需要对创建过程进行封装时。

三、工厂方法模式

核心思想

工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类：

实现方式

Python实现

class Product:
    pass

class ConcreteProductA(Product):
    pass

class ConcreteProductB(Product):
    pass

class Creator:
    def factory_method(self):
        return Product()

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

Java实现

在工厂方法模式中，我们定义一个工厂接口，并提供一个抽象的创建方法，具体的子类实现这个创建方法来生成具体的对象：

public interface Product {}

public class ConcreteProductA implements Product {}

public class ConcreteProductB implements Product {}

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

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

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

应用场景

• 需要将对象的创建和使用分离时；
• 需要灵活地增加或更改产品类型时。

四、抽象工厂模式

核心思想

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类：

实现方式

Python实现

class AbstractProductA:
    pass

class AbstractProductB:
    pass

class ConcreteProductA1(AbstractProductA):
    pass

class ConcreteProductB1(AbstractProductB):
    pass

class AbstractFactory:
    def create_product_a(self):
        pass
    def create_product_b(self):
        pass

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA1()
    def create_product_b(self):
        return ConcreteProductB1()

Java实现

public interface AbstractProductA {}

public interface AbstractProductB {}

public class ConcreteProductA1 implements AbstractProductA {}

public class ConcreteProductB1 implements AbstractProductB {}

public interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

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

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

应用场景

• 需要创建一系列相关或相互依赖的对象时；
• 需要提供一个产品族的多种变体时。

五、建造者模式

核心思想

建造者模式将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示：

实现方式

Python实现

class Product:
    def __init__(self):
        self.parts = []

    def add(self, part):
        self.parts.append(part)

    def show(self):
        print('Product Parts:', ', '.join(self.parts))

class Builder:
    def build_part_a(self):
        pass

    def build_part_b(self):
        pass

class ConcreteBuilder1(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("PartA1")

    def build_part_b(self):
        self.product.add("PartB1")

    def get_result(self):
        return self.product

class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct(self):
        self.builder.build_part_a()
        self.builder.build_part_b()

Java实现

public class Product {
    private List<String> parts = new ArrayList<>();

    public void add(String part) {
        parts.add(part);
    }

    public void show() {
        System.out.println("Product Parts: " + String.join(", ", parts));
    }
}

public abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}

public class ConcreteBuilder1 extends Builder {
    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.add("PartA1");
    }

    @Override
    public void buildPartB() {
        product.add("PartB1");
    }

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

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

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

应用场景

• 需要创建复杂对象时；
• 需要将对象的创建过程与表示分离时。

六、原型模式

核心思想

原型模式通过复制现有的实例来创建新的对象，而不是通过实例化类来创建对象：

实现方式

Python实现

import copy

class Prototype:
    def clone(self):
        return copy.deepcopy(self)

class ConcretePrototype(Prototype):
    def __init__(self, field):
        self.field = field

    def __str__(self):
        return f"ConcretePrototype(field={self.field})"

Java实现

public interface Prototype {
    Prototype clone();
}

public class ConcretePrototype implements Prototype {
    private String field;

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

    @Override
    public Prototype clone() {
        return new ConcretePrototype(this.field);
    }

    @Override
    public String toString() {
        return "ConcretePrototype(field=" + field + ")";
    }
}

应用场景

• 需要创建复杂对象时；
• 需要动态创建对象时。

总结

通过学习创建型模式，我们可以更好地控制对象的创建过程，提高代码的灵活性和可维护性；不同的创建型模式适用于不同的场景，理解它们的核心思想和实现方式，可以帮助我们在实际开发中选择合适的模式。

希望通过这篇总结，大家能更清晰地了解创建型模式，并在实际工作中熟练运用。如果你有任何疑问或想法，欢迎在下方留言！别忘了关注我们的公众号，获取更多有趣的编程知识和实用的代码技巧，我们期待与你的交流与分享！