Java设计模式之创建型模式详解

# 1. 引言

#### 1.1 设计模式概述
设计模式是对软件设计中一种常见问题的解决方案的描述，它提供了一套经过验证的、可复用的设计解决方案，可以帮助开发人员更加高效地编写可维护和可扩展的代码。设计模式为软件开发提供了一种标准的方法和术语，使得团队成员之间的沟通更加容易，同时也提供了一种共享和复用的知识库。

#### 1.2 创建型模式简介
创建型模式是设计模式的一种分类，它关注对象的创建方式，提供了一种实例化对象的方法。创建型模式通过隐藏对象的具体实现方式，使得对象的创建过程与使用过程分离，从而降低了系统的耦合度，增强了系统的灵活性和可扩展性。

#### 1.3 本文内容概要
本文将介绍几种常用的创建型模式，包括单例模式、工厂方法模式、建造者模式、原型模式和抽象工厂模式。我们将详细解释每种模式的定义、适用场景和实现方式，并通过示例代码演示其具体用法。通过学习这些模式，读者可以更好地理解和运用设计模式，提高代码质量和开发效率。

# 2. 单例模式

### 2.1 单例模式的定义及适用场景

单例模式是一种创建型设计模式，它保证某个类只有一个实例，并提供一个全局访问点来获取这个实例。

适用场景：
- 当一个类只能有一个实例，并且该实例需要被全局访问时，可以使用单例模式。
- 当多个并发线程需要共享一些数据时，可以使用单例模式保证数据的一致性。
- 当资源的创建和销毁需要花费较大代价时，可以使用单例模式延迟初始化。

### 2.2 饿汉式单例模式

饿汉式单例模式在类加载时就创建了单例对象，因此在使用时无需考虑线程安全问题。

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

### 2.3 懒汉式单例模式

懒汉式单例模式在第一次使用时才进行实例化，实现了延迟加载的效果，但需要考虑线程安全问题。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

### 2.4 双重检查锁定单例模式

双重检查锁定单例模式在懒汉式的基础上进行了改进，通过加锁的方式解决了线程安全问题，并且在实例已经创建的情况下无需加锁。

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

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

以上是单例模式的几种常见实现方式，根据实际需求和对线程安全的要求，选择合适的方式来实现单例模式。

# 3. 工厂方法模式

工厂方法模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂方法模式中，我们不再由一个单一的工厂类来创建全部的对象，而是由实现了工厂接口的多个工厂类来创建不同类型的对象。

工厂方法模式主要包括了简单工厂模式、工厂方法模式和抽象工厂模式三种形式。每种形式都有其特定的应用场景和优缺点，下面将一一介绍这三种工厂方法模式的概念和实现方式。

### 3.1 工厂方法模式的基本概念

工厂方法模式的核心思想是定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。这样，工厂方法模式让一个类的实例化延迟到其子类。这样，在不改变其结构的情况下，可以通过增加具体的工厂来创建新的产品对象，而客户端代码会完全保持不变。

### 3.2 简单工厂模式

简单工厂模式并不属于 23 种经典设计模式之一，它的作用是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的实例。简单工厂模式不符合"开闭原则"，因为在工厂类中添加新产品，需要修改工厂类的判断逻辑，不利于后期的维护和扩展。

### 3.3 工厂方法模式

工厂方法模式是对简单工厂模式的进一步抽象和推广，它是一种常用的工厂模式。在工厂方法模式中，我们定义一个创建对象的接口，但让子类来决定实例化哪个类。这样，工厂方法模式让一个类的实例化延迟到其子类。

### 3.4 抽象工厂模式

抽象工厂模式是最复杂的工厂模式之一，它提供了一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。抽象工厂模式是工厂方法模式的升级版本，它的最大好处是可以创建多个产品家族，而不需要修改已有代码。

希望以上内容能够为您对工厂方法模式有个整体的了解。

# 4. 建造者模式

#### 4.1 建造者模式的作用和特点
建造者模式是一种对象创建型模式，其主要作用是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。它将构建过程封装在指挥者类中，而实际的构建细节则由具体的建造者类负责实现。建造者模式的特点包括以下几点：
- 将一个复杂对象的构建过程和它的部件的表示分离，从而可以构造出不同的产品
- 可以对构建过程进行精细化控制，使得构建过程更加灵活
- 具体的建造者类之间相互独立，易于扩展和维护
- 客户端不需要关心产品的构建细节，只需要关心指挥者类和具体建造者类即可

#### 4.2 建造者模式的角色分析
建造者模式涉及到以下几个角色：
- 产品角色：包含多个组成部件的复杂对象
- 抽象建造者：定义了创建产品各个部件的抽象接口，一般包括建造方法和返回方法
- 具体建造者：实现抽象建造者接口，负责具体部件的创建
- 指挥者：负责调用具体建造者，控制产品的创建过程

#### 4.3 建造者模式的实例代码解析

// 产品角色
class Product {
    private String partA;
    private String partB;
    private String partC;
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
    // other operations
}

// 抽象建造者
interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

// 具体建造者
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;
    }
}

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

// 客户端调用
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director();
        Product product = director.construct(builder);
        // do something with the product
    }
}

**代码总结：**
在建造者模式中，产品角色包含了多个组成部件的复杂对象，抽象建造者定义了创建产品各个部件的抽象接口，具体建造者则实现了抽象建造者接口，负责具体部件的创建，而指挥者负责调用具体建造者，控制产品的创建过程。通过以上代码，我们可以清晰地看到建造者模式的结构和各个角色之间的关系。

**结果说明：**
通过建造者模式，我们可以将一个复杂对象的创建过程和表示分离，使得同样的构建过程可以创建不同的表示。客户端只需关心指挥者和具体建造者即可，而具体的产品构建细节由具体建造者来负责，实现了构建过程的灵活性。

# 5. 原型模式
原型模式是创建型模式的一种，它的主要作用是通过复制已有对象来创建新对象，而不是通过实例化新对象的方式。原型模式在某些场景下可以提高对象创建的效率，避免重复初始化和构造过程，同时也可以避免对现有对象进行修改。在本章中，我们将介绍原型模式的定义和使用场景，以及不同语言中的具体实现方法。

### 5.1 原型模式的定义和使用场景
原型模式的定义是通过复制现有对象来创建新对象。它主要由一个原型对象和一个克隆函数组成。原型对象是我们要创建的对象，克隆函数则负责创建新对象并复制原型对象的属性。

原型模式适用于以下场景：
- 当对象的初始化过程比较复杂且耗时时，通过复制已有对象可以提高创建新对象的效率。
- 当需要创建大量相似的对象时，通过复制原型对象可以避免重复的初始化和构造过程。

### 5.2 原型模式的实现方式
在许多编程语言中，原型模式都是通过实现克隆函数来实现的。下面是在不同语言中实现原型模式的示例代码：

#### Python

import copy

class Prototype:
    def __init__(self, name):
        self.name = name
    def clone(self):
        return copy.deepcopy(self)

# 创建原型对象
prototype = Prototype("Prototype")

# 复制原型对象创建新对象
new_object = prototype.clone()

print(new_object.name)  # 输出：Prototype

#### Java

public class Prototype implements Cloneable {
    private String name;

    public Prototype(String name) {
        this.name = name;
    }

    @Override
    public Prototype clone() {
        try {
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        // 创建原型对象
        Prototype prototype = new Prototype("Prototype");

        // 复制原型对象创建新对象
        Prototype newObject = prototype.clone();

        System.out.println(newObject.name);  // 输出：Prototype
    }
}

#### Go

type Prototype struct {
    name string
}

func (p *Prototype) Clone() *Prototype {
    return &Prototype{name: p.name}
}

func main() {
    // 创建原型对象
    prototype := &Prototype{name: "Prototype"}

    // 复制原型对象创建新对象
    newObject := prototype.Clone()

    fmt.Println(newObject.name)  // 输出：Prototype
}

#### JavaScript

class Prototype {
    constructor(name) {
        this.name = name;
    }

    clone() {
        return new Prototype(this.name);
    }
}

// 创建原型对象
const prototype = new Prototype("Prototype");

// 复制原型对象创建新对象
const newObject = prototype.clone();

console.log(newObject.name);  // 输出：Prototype

### 5.3 原型模式的优缺点比较
原型模式的优点：
- 可以提高对象的创建效率，避免重复的初始化和构造过程，特别是当对象的初始化过程比较复杂时。
- 可以避免对现有对象进行修改，保持对象的稳定性和一致性。

原型模式的缺点：
- 在某些编程语言中，原型模式的实现可能相对复杂。
- 原型模式要求对象必须实现克隆函数，这增加了对象的依赖性。

在实际开发中，我们应根据具体的情况来判断是否使用原型模式。在需要大量创建相似对象的场景下，原型模式可以提高对象创建的效率，减少不必要的资源消耗。

# 6. 抽象工厂模式

### 6.1 抽象工厂模式的概念和作用

抽象工厂模式是一种创建型设计模式，它提供了一个接口来创建一系列相关或相互依赖的对象，而无需指定具体类。该模式通过将具体类的创建交给子类或工厂实现类来完成，实现了客户端与具体类之间的解耦。

抽象工厂模式主要包含两个关键角色：抽象工厂和具体工厂。抽象工厂定义了用于创建一系列产品的接口，具体工厂实现了该接口，并负责实际创建产品的过程。

该模式适用于以下情况：
- 需要创建一系列相关或相互依赖的产品对象。
- 要求一个系统只能使用其中一种产品组合，不允许与其他产品组合混合使用。
- 需要提供一个产品类的库，而无需暴露产品的具体实现细节。

### 6.2 抽象工厂模式的实现方式

抽象工厂模式的实现主要涉及以下几个要素：
- 抽象工厂（Abstract Factory）：定义了用于创建产品的接口。通常包含一组创建不同产品的方法。
- 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责具体产品的创建。每个具体工厂对应一组具体产品。
- 抽象产品（Abstract Product）：定义了产品的抽象属性和方法。
- 具体产品（Concrete Product）：实现了抽象产品接口，具体定义产品的属性和方法。

以下是抽象工厂模式的示例代码（使用Java语言）：

// 抽象产品A
interface AbstractProductA {
    void operationA();
}

// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("具体产品A1的操作");
    }
}

// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("具体产品A2的操作");
    }
}

// 抽象产品B
interface AbstractProductB {
    void operationB();
}

// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("具体产品B1的操作");
    }
}

// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("具体产品B2的操作");
    }
}

// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

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

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.operationA();
        productB1.operationB();

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.operationA();
        productB2.operationB();
    }
}

### 6.3 抽象工厂模式与工厂方法模式的异同点分析

抽象工厂模式与工厂方法模式都属于创建型设计模式，它们都关注于对象的创建。它们之间的主要区别在于角色和侧重点的不同。

工厂方法模式中，我们将具体产品的创建延迟到具体工厂类中，不同的具体工厂类对应不同的具体产品类。工厂方法模式注重的是产品等级结构的扩展。

抽象工厂模式中，我们使用抽象工厂接口来定义一系列产品的创建方法，不同的具体工厂类对应不同的产品族。抽象工厂模式注重的是产品族的扩展。

总结起来，工厂方法模式强调的是产品等级结构的扩展，而抽象工厂模式则强调的是产品族的扩展。

通过合理地选择不同的创建型设计模式，可以使得系统更易扩展和维护，并且能够更好地适应日后的变化。