设计模型之创建者模式(含UML完整实例)_创建者原则举例

设计模型之创建者模式

1.创建者模式

1.1 定义与特点

  建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示(给对象属性赋值)分离，使同样的构建过程可以创建不同的表示(给对象属性赋值)，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

  该模式的主要优点如下：

• 各个具体的建造者相互独立，有利于系统的扩展。
• 客户端不必知道产品内部组成的细节，便于控制细节风险。

  其缺点如下：

• 产品的组成部分必须相同，这限制了其使用范围。
• 如果产品的内部变化复杂，该模式会增加很多的建造者类。

  建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

1.2 模式的结构

• 建造者（Builder）模式的主要角色如下。
• 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个滅部件。
• 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
• 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
• 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

1.3 UML类图

1.4 问题由来

  在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定
  在现实生活中，大家知道一辆车是很复杂的，有发动机、变速器、轮胎、挡风玻璃、雨刮器、气缸、方向盘等等无数的部件。
  通常用户会和销售谈我需要什么什么样的类型的车，马力要不要强劲、空间是否宽敞，这样销售就会根据用户的需要去推荐一款具体的车，客户的需求总是多种多样的，但是生产组装汽车的步骤是固定的，比如先是车身骨架，在是发动机…

1.5 解决思路

  客户的需求是变化多样的，由于需求的变化，这个车这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定，所以考虑到这一点，用生产者模式实现客户需求，需要抽象汽车产品的各个零件部件的生产机器，这样当客户群需要不同档次的车，只要有实现客户需要的各个零部件的生产机器，就可以生产出满足客户需求的车。因为客户需要的不同类型的车组装零部件步骤都是一样的，所以需要在流水线上指定好组装零部件的步骤，让生产汽车机器按步骤生产。

1.6 解决方案

/**
 * @author 26530
 *     汽车生产组装模型
 */
public abstract class CarProductionAssemblyModel 
{
	    Car car = new Car();

	   /**
		 * 发动机 (1.6t,1.8t,2.0t等)
		*/
		abstract void engine();
		
		
		/**
		  * 车身骨架 (紧凑型，中型，宽敞型 )
		*/
		abstract void bodySkeleton();
		
		
		
		/**
		  * 轮子(防爆，不防爆等)
		*/
		abstract void wheel(); 
		
		/**
		  * 返回产品
		*/
		abstract Car 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

/**
 * @author 26530
 *      汽车类(包含构成汽车的零部件)
 */
public  class Car 
{
     /**
                 * 发动机 (1.6t,1.8t,2.0t等)
     */
     private String engine;
    
    
    /**
              * 车身骨架 (紧凑型，中型，宽敞型 )
     */
     private String bodySkeleton;
    
     
    
    /**
              * 轮子(防爆，不防爆等)
     */
     private String wheel;



	public Car(String engine, String bodySkeleton, String wheel) {
		super();
		this.engine = engine;
		this.bodySkeleton = bodySkeleton;
		this.wheel = wheel;
	}



	public String getEngine() {
		return engine;
	}



	public void setEngine(String engine) {
		this.engine = engine;
	}



	public String getBodySkeleton() {
		return bodySkeleton;
	}



	public void setBodySkeleton(String bodySkeleton) {
		this.bodySkeleton = bodySkeleton;
	}



	public String getWheel() {
		return wheel;
	}



	public void setWheel(String wheel) {
		this.wheel = wheel;
	}



	public Car() {
		super();
		// TODO Auto-generated constructor stub
	}



	@Override
	public String toString() {
		return "Car [engine=" + engine + ", bodySkeleton=" + bodySkeleton + ", wheel=" + wheel + "]";
	}




    

}

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

/**
 * @author 26530
 *    生产流水线(指挥者)
 */
public class CarProductionLine 
{
	public Car produce(CarProductionAssemblyModel carProductionLineModule)
	{
		carProductionLineModule.engine();
		carProductionLineModule.bodySkeleton();
		carProductionLineModule.wheel();
		return carProductionLineModule.getResult();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
 * @author 26530
 *     高档车生产机器
 */
public class HighCarMachine extends CarProductionAssemblyModel{

	@Override
	void  engine() 
	{
		car.setEngine( " 2.0t ");
	}

	@Override
	void bodySkeleton() 
	{
		car.setBodySkeleton(" 宽敞型  ");
	}

	@Override
	void wheel() 
	{
		car.setWheel(" 防爆  ");
	}

	@Override
	Car getResult() 
	{
		return car;
	}
	
	


	

}

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

/**
 * @author 26530
 *     中档车生产机器
 */
public class MidddleCarMachine extends CarProductionAssemblyModel{

	@Override
	void engine() 
	{
		car.setEngine(" 1.8t ");
	}

	@Override
	void bodySkeleton() 
	{
		car.setBodySkeleton(" 中型车  ");
	}

	@Override
	void wheel() 
	{
		car.setWheel(" 防爆  ");
	}

	@Override
	Car getResult() 
	{
		return car;
	}
	
	


	

}
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

/**
 * @author 26530
 *     低档车生产机器
 */
public class BottomCarMachine extends CarProductionAssemblyModel{

	@Override
	void engine() 
	{
		car.setEngine(" 1.6t ");
	}

	@Override
	void bodySkeleton() 
	{
		car.setBodySkeleton(" 紧凑型  ");
	}

	@Override
	void wheel() 
	{
		car.setWheel(" 不防爆  ");
	}

	@Override
	Car getResult() 
	{
		return car;
	}
	
	


	

}
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

public class Test 
{
  
   public static void main(String[] args) 
   {
	   
	   //客户到某个品牌4s店，想买发动机比较好，比较宽敞，车子比较好的车（高档类型）
		//销售通知生产部门生产线准备好客户想要的高档类型车，并告知客户下个月就可以提车了
		CarProductionLine productionDepartment = new CarProductionLine();
		CarProductionAssemblyModel highCarProductionLine = new HighCarMachine();
		Car car = productionDepartment.produce(highCarProductionLine);
		System.out.println(car);//Car [engine= 2.0t , bodySkeleton= 宽敞型  , wheel= 防爆  ]
		//客户买到了他想要的高档车
  }
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16