23种设计模式中的创建型设计模式

设计模式的概念       

        设计模式是软件开发中常见的最佳实践，旨在解决特定问题或优化系统设计。在23种设计模式中，创建型设计模式专注于处理对象的创建过程。这类模式主要涉及如何动态创建对象，同时保持系统的高灵活性和可扩展性。

        在开发过程中，创建型设计模式的应用场景非常广泛。例如，我们可能需要创建一个对象，但对象的初始化过程依赖于一些动态配置或环境因素。这时，我们可以使用工厂模式（Factory Pattern）来封装对象的创建过程，降低代码耦合度，并使得系统更易于扩展。

        再比如，有时候我们需要创建一些复杂的对象，这些对象的创建过程可能涉及到多个子对象的创建和组装。这时候，我们可以使用构建者模式（Builder Pattern）来简化对象的创建过程，同时使得代码更具可读性和可维护性。下面介绍一下五种创建型设计模式：

        单例模式(Singleton Pattern):

        单例模式是一种常用的创建型模式，它可以保证一个类只有一个实例，并提供一个全局访问点，使得其他对象可以通过这个访问点来获取这个唯一的实例。它的具体实现方式包括懒汉式和饿汉式等。

示例代码：

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // 私有构造方法
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

测试代码：

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        
        System.out.println(instance1 == instance2);  // 输出true，表示获取的是同一个实例
    }
}

        工厂方法模式(Factory Method Pattern):

        工厂方法模式是一种创建型模式，它定义了一个用于创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到其子类。它的实现方式包括简单工厂、工厂方法和抽象工厂等。

示例代码：

public interface Product {
    void operation();
}

public class ConcreteProduct implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProduct operation");
    }
}

public interface Creator {
    Product createProduct();
}

public class ConcreteCreator implements Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

测试代码：

public class FactoryMethodTest {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct();
        
        product.operation();  // 输出"ConcreteProduct operation"
    }
}

        抽象工厂模式(Abstract Factory Pattern):

        抽象工厂模式也是一种创建型模式，它提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。它的具体实现方式为接口构建多个工厂类，每个工厂类针对不同的产品类簇而进行对象的创建。

示例代码：

public interface AbstractProductA {
    void operationA();
}

public class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1 operationA");
    }
}

public class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operationA");
    }
}

public interface AbstractProductB {
    void operationB();
}

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

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

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

public class ConcreteFactory implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

测试代码：

public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory();
        
        AbstractProductA productA = factory.createProductA();
        AbstractProductB productB = factory.createProductB();
        
        productA.operationA();  // 输出"ConcreteProductA1 operationA"
        productB.operationB();  // 输出"ConcreteProductB1 operationB"
    }
}

        建造者模式(Builder Pattern):

        建造者模式是一种创建型模式，它将一个复杂对象的构建与它的表示分离，同样的构建过程可以创建不同的表示。它的主要作用是在于抽象出一个构建过程，使得实现部分和抽象部分分离，从而可以创建出更加复杂的对象。

示例代码：

public class Product {
    private String partA;
    private String partB;
    private String partC;
    
    // 省略构造方法和getter、setter
    
    public void show() {
        System.out.println("Product: partA=" + partA + ", partB=" + partB + ", partC=" + partC);
    }
}

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

public class ConcreteBuilder implements Builder {
    private Product product = new Product();
    
    @Override
    public void buildPartA() {
        product.setPartA("partA");
    }
    
    @Override
    public void buildPartB() {
        product.setPartB("partB");
    }
    
    @Override
    public void buildPartC() {
        product.setPartC("partC");
    }
    
    @Override
    public Product getResult() {
        return product;
    }
}

public class Director {
    public Product construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

测试代码：

public class BuilderTest {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director();
        
        Product product = director.construct(builder);
        product.show();  // 输出"Product: partA=partA, partB=partB, partC=partC"
    }
}

        原型模式(Prototype Pattern):

        原型模式是一种创建型模式，它通过给出一个原型对象来指明所需创建对象的类型，然后通过复制这个原型来创建新对象。它的实现方法有深复制和浅复制等。

示例代码：

public abstract class Prototype implements Cloneable {
    @Override
    public abstract Prototype clone();
}

public class ConcretePrototype extends Prototype {
    private int field;
    
    public void setField(int field) {
        this.field = field;
    }
    
    public int getField() {
        return field;
    }
    
    @Override
    public Prototype clone() {
        ConcretePrototype cloneObj = new ConcretePrototype();
        cloneObj.setField(this.field);
        return cloneObj;
    }
}

测试代码：

public class PrototypeTest {
    public static void main(String[] args) {
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setField(10);
        
        ConcretePrototype cloneObj = (ConcretePrototype) prototype.clone();
        System.out.println(cloneObj.getField());  // 输出10
    }
}

优点：

灵活性：

创建型设计模式允许我们在运行时动态地创建对象，而无需在代码中硬编码对象的具体类型。这使得系统更加灵活，可以轻松地适应变化和扩展。

可维护性：

通过将对象的创建逻辑封装在单独的模式中，我们可以降低代码的耦合度，使得代码更容易理解和维护。

易于使用：

一些创建型设计模式（如工厂模式和构建者模式）提供了简单的接口，使得创建对象变得更加简单和直观。

缺点：

复杂性：

创建型设计模式通常比简单的对象创建语句更复杂，这可能会增加理解和使用模式的难度。

开销：

虽然这些模式可以使代码更加灵活和可维护，但它们也会引入额外的开销。例如，工厂模式的实现需要额外的内存来存储工厂对象，这可能会导致性能下降。

过度使用：

如果滥用创建型设计模式，可能会导致代码过于复杂和难以理解。在简单的场景中，简单的对象创建语句可能更适合。

应用建议：

考虑需求：

在决定是否使用创建型设计模式时，首先要明确需求。如果需要在运行时动态地创建对象，同时保持高度的灵活性和可扩展性，那么创建型设计模式可能是一个不错的选择。

选择合适的模式：

在应用创建型设计模式时，要根据具体的需求选择最合适的模式。例如，如果需要创建一个复杂的对象，那么构建者模式可能更适合。如果对象的选择依赖于配置或环境因素，那么工厂模式可能更合适。

考虑性能：

虽然创建型设计模式的性能开销相对较小，但在决定是否使用时，还是需要考虑到性能因素。如果对象的创建非常频繁，那么简单的对象创建语句可能更高效。

保持简洁性：

在使用创建型设计模式时，要保持代码的简洁性。模式的实现应该尽可能地简单明了，避免过度设计和复杂性。

总结：

        创建型设计模式是解决特定对象创建问题的有效工具。通过将这些模式应用于开发中，我们可以实现更加灵活、可维护和易于扩展的系统。然而，也要注意避免过度使用和滥用这些模式，以保持代码的简洁性和可读性。在选择是否使用和如何使用这些模式时，要充分考虑到实际需求、性能和代码的复杂性。本篇博客只是介绍了一下设计模式中的创建型设计模式，还有结构型设计模式和行为型设计模式没有讲到，在之后的博客会相继介绍。