java设计模式：02-创建型设计模式-概览

创建型模式（Creational Patterns）

定义

创建型模式（Creational Patterns）主要用于处理对象创建的机制，旨在以适当的方式创建对象。这些模式的目的是将对象的创建过程与系统的其他部分分离，以提高系统的灵活性和可扩展性。通过使用创建型模式，可以使系统在创建对象时更加灵活，减少耦合，提高代码的可维护性。

1. 单例模式 (Singleton Pattern)

定义：确保一个类只有一个实例，并提供一个全局访问点。
详细释义：单例模式通过确保某个类只有一个实例存在，避免了在整个应用程序中多次创建该类的实例。这个实例通常通过一个静态方法访问，它负责检查实例是否已存在，如果不存在，则创建一个新的实例。如果已经存在，则返回这个实例。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

2. 原型模式 (Prototype Pattern)

定义：通过复制现有对象来创建新对象。
详细释义：原型模式使用现有的对象作为蓝图，通过复制这些对象来生成新的实例。这种模式适用于创建对象成本高昂或复杂的情况下，通过克隆现有对象可以节省创建新对象的开销。

public class Prototype implements Cloneable {
    private String name;

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

    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    public String getName() {
        return name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. 工厂方法模式 (Factory Method Pattern)

定义：定义一个创建对象的接口，但让子类决定实例化哪个类。
详细释义：工厂方法模式通过定义一个接口来创建对象，由子类决定具体实例化哪个类。这种模式使得类的实例化延迟到子类进行，从而实现了创建对象的灵活性和可扩展性。

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

    public void anOperation() {
        Product product = factoryMethod();
        // 处理产品
    }
}

public class ConcreteCreator extends Creator {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

定义：提供一个接口来创建一系列相关或依赖的对象，而无需指定它们的具体类。
详细释义：抽象工厂模式通过定义一个创建相关对象的接口，来实现一系列相关对象的创建，而不需要知道具体类是什么。这种模式通常用于创建一组相关或依赖的对象，确保它们的一致性。

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

public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }

    public ProductB createProductB() {
        return new ProductB1();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5. 建造者模式 (Builder Pattern)

定义：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
详细释义：建造者模式通过将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。这种模式通常用于构建复杂的对象，如带有多个部分的对象，建造者模式可以分步骤创建对象，并在最后一步返回最终的对象。

public 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 abstract class Builder {
    protected Product product = new Product();

    public abstract void buildPart1();
    public abstract void buildPart2();

    public Product getResult() {
        return product;
    }
}

public class ConcreteBuilder extends Builder {
    public void buildPart1() {
        product.setPart1("Part1");
    }

    public void buildPart2() {
        product.setPart2("Part2");
    }
}

public class Director {
    private Builder builder;

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

    public void construct() {
        builder.buildPart1();
        builder.buildPart2();
    }
}
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

通过使用这些创建型模式，开发者可以更加灵活和高效地管理对象的创建过程，提高系统的可维护性和可扩展性。