建造者模式：实现了构建和装配的解耦，即对象的各个子组件单独构建，再进行装配，从而建造完整对象。
该模式适用于构建较为复杂的对象（多个子组件）。
不同的构建者，使用相同的装配者，可以建造不同的对象实例。相同的构建者，不同的装配顺序，也可能建造出不同的对象实例。
举例：
汽车对象，子组件包括引擎、轮子和车体。
Audi汽车构建者，负责制造Audi牌各个子组件。BMW汽车构建者，负责制造BMW牌各个子组件。然后将子组件统一送至汽车装配者的生产线中进行组装，最后会建造出Audi牌汽车和BMW汽车。
以下代码实现：
首先，定义汽车类，及其子组件类。
1 package com.corey.builder;
2
3 /**
4 * 汽车类---产品类
5 * @author Corey
6 *
7 */
8 public class Car {
9 private Engine engine;
10 private Wheel wheel;
11 private CarBody body;
12
13 public Engine getEngine() {
14 return engine;
15 }
16 public void setEngine(Engine engine) {
17 this.engine = engine;
18 }
19 public Wheel getWheel() {
20 return wheel;
21 }
22 public void setWheel(Wheel wheel) {
23 this.wheel = wheel;
24 }
25 public CarBody getBody() {
26 return body;
27 }
28 public void setBody(CarBody body) {
29 this.body = body;
30 }
31
32 public void Run(){
33 System.out.println("启动汽车，开始行程！");
34 }
35
36
37 }
38
39 /**
40 * 发动机类
41 * @author Corey
42 *
43 */
44 class Engine {
45 private String name;
46
47 public Engine(String name) {
48 super();
49 this.name = name;
50 }
51
52 public String getName() {
53 return name;
54 }
55
56 public void setName(String name) {
57 this.name = name;
58 }
59
60 }
61
62 /**
63 * 车轮类
64 * @author Corey
65 *
66 */
67 class Wheel {
68 private String name;
69
70 public Wheel(String name) {
71 super();
72 this.name = name;
73 }
74
75 public String getName() {
76 return name;
77 }
78
79 public void setName(String name) {
80 this.name = name;
81 }
82
83 }
84
85 /**
86 * 车体类
87 * @author Corey
88 *
89 */
90 class CarBody {
91 private String name;
92
93 public CarBody(String name) {
94 super();
95 this.name = name;
96 }
97
98 public String getName() {
99 return name;
100 }
101
102 public void setName(String name) {
103 this.name = name;
104 }
105
106 }
然后，定义汽车制造者接口。
1 package com.corey.builder;
2
3 /**
4 * 汽车制造者接口
5 * @author Corey
6 *
7 */
8 public interface CarBuilder {
9
10 String getBrand();
11 Engine buildEngine();
12 Wheel buildWheel();
13 CarBody buildCarBody();
14
15
16 }
分别实现Audi汽车制造者类和BMW汽车制造者类。
1 package com.corey.builder;
2
3 /**
4 * 奥迪汽车建造者---接口实现类
5 * @author Corey
6 *
7 */
8 public class AudiCarBuidler implements CarBuilder{
9
10
11
12 @Override
13 public Engine buildEngine() {
14 System.out.println("建造奥迪发动机！");
15 return new Engine("Audi发动机");
16 }
17
18 @Override
19 public Wheel buildWheel() {
20 System.out.println("建造奥迪车轮！");
21 return new Wheel("Audi车轮");
22 }
23
24 @Override
25 public CarBody buildCarBody() {
26 System.out.println("建造奥迪车体！");
27 return new CarBody("Audi车体");
28 }
29
30 @Override
31 public String getBrand() {
32 return "Audi";
33 }
34
35 }
1 package com.corey.builder;
2
3 public class BMWCarBuilder implements CarBuilder{
4
5 @Override
6 public String getBrand() {
7 return "BMW";
8 }
9
10 @Override
11 public Engine buildEngine() {
12 System.out.println("建造宝马发动机！");
13 return new Engine("BMW发动机");
14 }
15
16 @Override
17 public Wheel buildWheel() {
18 System.out.println("建造宝马车轮！");
19 return new Wheel("BMW车轮");
20 }
21
22 @Override
23 public CarBody buildCarBody() {
24 System.out.println("建造宝马车体！");
25 return new CarBody("BMW车体");
26 }
27
28 }
定义汽车装配者类。
package com.corey.builder;
/**
* 奥迪汽车组装者--接口实现类
* @author Corey
*
*/
public class CarDirector{
private CarBuilder builder;
public CarDirector(CarBuilder builder) {
super();
this.builder = builder;
}
public Car directCar() {
Car car = new Car();
car.setEngine(builder.buildEngine());
car.setWheel(builder.buildWheel());
car.setBody(builder.buildCarBody());
String brand = builder.getBrand();
System.out.println("组装" + brand + "汽车完成！");
return car;
}
}
由此，我们可以进行汽车生产了。
指定汽车制造商，送入汽车装配厂，生产汽车，上路。以下是测试代码：
1 package com.corey.builder;
2
3 public class Test {
4
5 public static void main(String[] args) {
6
7 CarBuilder builder = new AudiCarBuidler();
8 CarDirector director = new CarDirector(builder);
9 Car car = director.directCar();
10 System.out.println(car.getEngine().getName());
11 car.Run();
12
13 System.out.println("----------------------------------");
14
15 CarBuilder builder1 = new BMWCarBuilder();
16 CarDirector director1 = new CarDirector(builder1);
17 Car bmwCar = director1.directCar();
18 System.out.println(bmwCar.getEngine().getName());
19 bmwCar.Run();
20 }
21 }
运行结果：
建造奥迪发动机！ 建造奥迪车轮！ 建造奥迪车体！ 组装Audi汽车完成！ Audi发动机 启动汽车，开始行程！ ---------------------------------- 建造宝马发动机！ 建造宝马车轮！ 建造宝马车体！ 组装BMW汽车完成！ BMW发动机 启动汽车，开始行程！
至此，建造者模式完成。
Java框架中很多都是用建造者模式写的，一般都会以Builder结尾，常见的如StringBuilder。
时间： 2024-12-11 15:54:53