1. 单例模式（Singleton Pattern）

1.1 定义

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

1.2 侧重点

控制类实例只有一个，节省系统资源。
提供对唯一实例的全局访问点。
复制

1.3 使用场景

全局唯一对象： 当需要确保一个类只有一个实例，并提供全局访问点时，比如配置管理器、日志管理器等。
资源共享情况下的节约资源： 某类只应该拥有一个实例，避免创建多个实例占用过多内存，比如线程池、数据库连接池等。
复制

1.4 示例代码（Java）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Private constructor to prevent instantiation from outside.
    }

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

    public void showMessage() {
        System.out.println("Singleton instance is created.");
    }
}
复制

2. 工厂模式（Factory Pattern）

2.1 定义

工厂模式定义了一个创建对象的接口，但由子类决定实例化的类是哪一个。

2.2 侧重点

将对象的实例化过程封装，使客户端与具体的类解耦。
提供一个创建对象的通用接口，便于扩展和维护。
复制

2.3 使用场景

类不知道要创建的对象类： 当一个类无法预知要创建的对象的类时，将对象的创建延迟到子类中实现，比如GUI组件的创建、日志记录器等。
复制

2.4 示例代码（Java）

interface Product {
    void create();
}

class ConcreteProduct1 implements Product {
    @Override
    public void create() {
        System.out.println("Product 1 is created.");
    }
}

class ConcreteProduct2 implements Product {
    @Override
    public void create() {
        System.out.println("Product 2 is created.");
    }
}

class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("Product1")) {
            return new ConcreteProduct1();
        } else if (type.equals("Product2")) {
            return new ConcreteProduct2();
        }
        return null;
    }
}
复制

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

3.1 定义

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

3.2 侧重点

创建一组相关的产品对象，便于替换整个产品族。
保持产品间的一致性，确保创建的产品是相互兼容的。
复制

3.3 使用场景

产品族概念的应用： 当需要创建一组相关或相互依赖的对象时，可以使用抽象工厂模式，比如创建不同操作系统下的界面组件。
系统需要独立于其产品的创建、组合和表示时： 可以使用抽象工厂模式将系统与具体类的实现分离。
复制

3.4 示例代码（Java）

interface AbstractProductA {
    void create();
}

class ProductA1 implements AbstractProductA {
    @Override
    public void create() {
        System.out.println("Product A1 is created.");
    }
}

class ProductA2 implements AbstractProductA {
    @Override
    public void create() {
        System.out.println("Product A2 is created.");
    }
}

interface AbstractProductB {
    void create();
}

class ProductB1 implements AbstractProductB {
    @Override
    public void create() {
        System.out.println("Product B1 is created.");
    }
}

class ProductB2 implements AbstractProductB {
    @Override
    public void create() {
        System.out.println("Product B2 is created.");
    }
}

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

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

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

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}
复制

4. 建造者模式（Builder Pattern）

4.1 定义

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

4.2 侧重点

将对象的构建过程拆分成多个步骤，便于灵活组合和构建不同的对象。
隐藏对象的构建细节，使客户端只需关心配置和组装顺序。
复制

4.3 使用场景

创建对象的构建过程比较复杂： 当对象的构建过程较为复杂，需要将构建过程拆分成多个步骤，并且可以灵活组装不同的部分时，可以使用建造者模式，比如创建复杂的数据结构、报表等。
复制

4.4 示例代码（Java）

class Product {
    private String part1;
    private String part2;

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public void show() {
        System.out.println("Product parts: " + part1 + " and " + part2);
    }
}

interface Builder {
    void buildPart1();
    void buildPart2();
    Product getResult();
}

class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPart1() {
        product.setPart1("Part 1");
    }

    @Override
    public void buildPart2() {
        product.setPart2("Part 2");
    }

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

class Director {
    private Builder builder;

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

    public void construct() {
        builder.buildPart1();
        builder.buildPart2();
    }
}
复制

5. 原型模式（Prototype Pattern）

5.1 定义

原型模式通过复制现有实例来创建新实例。

5.2 侧重点

通过复制现有对象来创建新对象，避免了重复的初始化和构造过程。
提供一种简洁的创建对象的方式，适用于对象的创建成本较高的情况。
复制

5.3 使用场景

创建成本较高，但复制比较简单： 当对象的创建过程较为复杂或创建成本较高，但对象的复制比较简单时，可以使用原型模式，通过复制现有实例来创建新实例，提高效率。

5.4 示例代码（Java）

class ConcretePrototype implements Cloneable {
    @Override
    public ConcretePrototype clone() {
        try {
            return (ConcretePrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class PrototypeExample {
    public static void main(String[] args) {
        ConcretePrototype prototype = new ConcretePrototype();

        ConcretePrototype clonedPrototype1 = prototype.clone();
        System.out.println("Cloned Prototype 1: " + clonedPrototype1);

        ConcretePrototype clonedPrototype2 = prototype.clone();
        System.out.println("Cloned Prototype 2: " + clonedPrototype2);
    }
}
复制

以上是创建型模式的详解和示例代码。每种模式都有其特定的用途和适用场景，根据具体的开发需求选择合适的模式来提高代码质量