设计模式-创建型模式

1. 单例模式 (Singleton Pattern)

1.1 单例模式的概念和作用

单例模式是一种创建型设计模式，其主要目的是确保类只有一个实例，并提供一个全局访问点。这在需要严格控制某个类只能有一个实例时非常有用，例如线程池、配置管理和日志记录器等。

1.2 实现单例模式的方式

实现单例模式有多种方式，常见的包括懒汉式、饿汉式、双重检查锁等。以下是一个基于双重检查锁的线程安全单例模式的示例代码：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.3 单例模式的优缺点

优点：

• 提供了对唯一实例的受控访问。
• 节省了系统资源，避免了多次创建相同对象。

缺点：

• 可能会引入全局状态，影响代码的可测试性。
• 使用不当可能导致内存泄漏或性能问题。

1.4 单例模式在实际项目中的应用场景

单例模式在实际项目中有许多应用场景，例如：

• 数据库连接池：确保系统中只有一个数据库连接池实例，避免资源浪费。
• 日志记录器：确保系统中只有一个日志记录器实例，统一管理日志输出。
• 配置管理器：确保系统中只有一个配置管理器实例，统一管理配置信息。

在以上场景中，单例模式可以有效地管理资源和状态，提高系统的性能和可维护性。

2. 工厂模式 (Factory Pattern)

2.1 工厂模式的概念和作用

工厂模式是一种创建型设计模式，其主要目的是封装对象的创建过程，并根据需求动态返回对象实例。工厂模式可以根据不同的条件创建不同类型的对象，从而提高代码的灵活性和可扩展性。

2.2 简单工厂模式 (Simple Factory Pattern)

简单工厂模式是工厂模式的一种简单形式，其通过一个工厂类负责创建对象实例，客户端无需直接创建对象。以下是一个简单工厂模式的示例代码：

public 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("Invalid product type: " + type);
    }
}

interface Product {
    void operation();
}

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

class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

工厂方法模式是一种将对象的创建延迟到子类的模式，其定义了一个创建对象的接口，由子类决定要实例化的类。工厂方法模式可以在不修改现有代码的情况下引入新的产品类。

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

抽象工厂模式是一种提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类的模式。抽象工厂模式可以在不修改现有代码的情况下引入新的产品族。

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

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

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

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.5 工厂模式的优缺点

优点：

• 封装了对象的创建过程，客户端无需直接创建对象，降低了耦合度。
• 可以根据需求动态返回对象实例，提高了代码的灵活性和可扩展性。

缺点：

• 如果产品类过多，增加了系统的复杂度。
• 工厂类集中了所有产品的创建逻辑，一旦出现问题，整个系统将受到影响。

3. 抽象工厂模式 (Abstract Factory Pattern)

抽象工厂模式是一种创建型设计模式，它提供了一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂模式通过工厂接口和具体工厂类来实现对象的创建，客户端可以通过工厂接口获取所需的产品对象，而无需关心具体的实现细节。

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

抽象工厂模式是工厂方法模式的扩展，它提供了一种方式来创建一系列相关或相互依赖的对象。通过定义一组工厂接口和具体的工厂实现类，抽象工厂模式可以使得系统更加灵活，并且符合开闭原则，即对扩展开放，对修改关闭。

3.2 抽象工厂模式的结构和实现

抽象工厂模式由以下几个要素组成：

• 抽象工厂接口 (Abstract Factory Interface)：定义了创建产品对象的方法。
• 具体工厂类 (Concrete Factory Classes)：实现了工厂接口，负责创建一组相关的产品对象。
• 抽象产品接口 (Abstract Product Interface)：定义了产品对象的接口。
• 具体产品类 (Concrete Product Classes)：实现了产品接口，具体描述了产品对象的特性和行为。

// 抽象工厂接口
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

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

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

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

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3.3 抽象工厂模式的优缺点

• 优点：

  • 符合开闭原则，增加新产品类型时，无需修改已有代码，只需添加新的产品类和对应的工厂类。
  • 提供了一种简单的方式来创建一系列相关或相互依赖的对象，使得系统更加灵活。

• 缺点：

  • 类的数量增加，增加了系统的复杂度。
  • 一旦出现问题，整个系统将受到影响。

  4. 建造者模式 (Builder Pattern)

建造者模式是一种创建型设计模式，它可以将一个复杂对象的构建过程和表示分离，使得同样的构建过程可以创建不同的表示。通过建造者模式，客户端可以更加灵活地创建复杂对象，同时也可以隐藏对象的构建细节。

4.1 建造者模式的概念和作用

建造者模式的核心思想是将一个复杂对象的构建过程分解为多个简单的步骤，然后由指挥者按照一定的顺序组合这些步骤来构建对象。建造者模式可以在不同的构建过程中使用相同的建造者接口，从而创建不同的表示形式。

4.2 建造者模式的结构和实现

建造者模式由以下几个要素组成：

• 产品类 (Product Class)：表示被构建的复杂对象。
• 建造者接口 (Builder Interface)：定义了构建产品对象的方法。
• 具体建造者类 (Concrete Builder Classes)：实现了建造者接口，负责构建产品的各个部分。
• 指挥者类 (Director Class)：负责按照一定的构建步骤调用具体建造者来构建产品对象。

// 产品类
public class Product {
    private String partA;
    private String partB;
    private String partC;

    // 省略getter和setter方法
}

// 建造者接口
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("Part A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part B");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part C");
    }

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

// 指挥者类
public class Director {
    private Builder builder;

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

    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

4.3 建造者模式的优缺点

• 优点：
  • 将对象的构建过程和表示分离，使得客户端无需关心对象的构建细节。
  • 可以更加灵活地构建复杂对象，同一个构建过程可以创建不同的表示形式。
  • 可以更好地控制对象的构建过程，符合单一职责原则。
• 缺点：
  • 增加了系统的复杂度，引入了多个类和接口。

5. 原型模式 (Prototype Pattern)

原型模式是一种创建型设计模式，旨在通过复制现有对象来创建新对象，而无需知道其具体类型。该模式通过克隆现有对象的属性和状态来创建新对象，避免了直接使用构造函数创建对象时的重复性工作。

5.1 原型模式的概念和作用

原型模式适用于需要创建大量相似对象的场景，通过复制现有对象来创建新对象，可以提高对象的创建效率，并且避免了因为重复构造对象导致的性能损耗。同时，原型模式也可以保护对象的状态，因为新对象是从现有对象的副本中创建的，不会影响原始对象的状态。

5.2 原型模式的结构和实现

原型模式包括以下几个要素：

• 抽象原型类 (Prototype)：声明了克隆方法，用于复制当前对象并返回一个新对象。
• 具体原型类 (Concrete Prototype)：实现了抽象原型类的克隆方法，负责创建自身的副本。
• 客户端 (Client)：通过调用原型对象的克隆方法来创建新对象。

// 抽象原型类
public interface Prototype {
    Prototype clone();
}

// 具体原型类
public class ConcretePrototype implements Prototype {
    private String property;

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

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

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建原型对象
        ConcretePrototype prototype = new ConcretePrototype("Initial Property");

        // 克隆原型对象
        ConcretePrototype clone = (ConcretePrototype) prototype.clone();

        // 输出克隆对象的属性
        System.out.println("Cloned Property: " + clone.getProperty());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

5.3 原型模式的优缺点

• 优点：
  • 提高了对象的创建效率，避免了重复构造对象的开销。
  • 通过复制现有对象来创建新对象，可以保护对象的状态。
• 缺点：
  • 如果对象的创建过程比较复杂，克隆方法的实现可能会比较困难。
  • 如果对象的状态发生改变，需要手动更新所有克隆对象的状态，可能会导致一致性问题。