java设计模式 - 建造者模式

建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

建造者模式概括✌️：

1.需要有一个抽象的建造者，统一建造的实体的方法，比如有构建主机，显示器，键盘鼠标方法，有一个建造完毕返回这个物品的方法。构建的具体类 继承抽象构建者，使用该具体的建造者来进行构建。

2.被建造的实体类，开放被构建部分的方法 即开放set方法，也可以另外新增方法。（比如：电脑实体类）

3.指挥者类，指挥者类负责指挥构建类来对某个被建造的实体进行构建，其中指挥者类必须明确知道自己指挥的是哪个构建者 (即 内部有一个构建者的对象属性) 还有任意个构建方法，构建方法中有关于是如何构建的可以灵活的选择，即屏蔽了被构建者的内部细节。

1.指定建造者的抽象类 并创建一个建造者类

package BuilderPattern;

/**
 * @Author Tang
 **/
// 抽象的构建者
public abstract class AbstractBuilder {
   // 创建一个电脑对象
    Computer computer = new Computer();

    // 构建主机
    public abstract void buildMainFrame();

    // 构建显示器
    public abstract void buildDisplay();

    // 构建键盘鼠标
    public abstract void buildKeyboard();

    //返回电脑对象
    public Computer returnComputer(){
        return computer;
    }

}

// 具体的建造者
class Builder extends  AbstractBuilder{

 @Override
 public void buildMainFrame() {
  computer.setMainFrame("建造主机完毕....");
 }

 @Override
 public void buildDisplay() {
  computer.setDisplay("建造显示器完毕...");
 }

 @Override
 public void buildKeyboard() {
computer.setKeyboard("建造键盘鼠标完毕....");
 }
}
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

2.创建一个具体的被创建者类 (电脑)

package BuilderPattern;

/**
 * @Author Tang
 **/

// 具体的被创建类 电脑类
public class Computer {
    private String mainFrame;
    private String display;
    private String keyboard;

    public void setMainFrame(String mainFrame) {
        this.mainFrame = mainFrame;
    }

    public void setDisplay(String display) {
        this.display = display;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }
    public void showMessage(Computer computer){
        System.out.println(computer);
        System.out.println("这是一台电脑.");
    }

    @Override
    public String toString() {
        return "Computer{" +
                "mainFrame='" + mainFrame + '\'' +
                ", display='" + display + '\'' +
                ", keyboard='" + keyboard + '\'' +
                '}';
    }
}
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

3.创建一个指挥者类

package BuilderPattern;

/**
 * @Author Tang
 **/
public class Leader {

    private Builder builder;

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

    // 构建方案一 可以灵活组件
    public Computer build(){
        builder.buildMainFrame();
        builder.buildDisplay();
        builder.buildKeyboard();
        return builder.returnComputer();
    }

    // 构建方案二
    public Computer build2(){
        builder.buildDisplay();;
        builder.buildKeyboard();
        return builder.returnComputer();
    }

}

// 使用者 我们无需知道构建的内部细节，只需要知道我们构建的对象是什么
class  BuilderMain{
    public static void main(String[] args) {
        Builder builder = new Builder();
        Leader leader = new Leader(builder);
        Computer computer = leader.build();
        computer.showMessage(computer);
    }
}
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