java设计模式创建篇------建造者模式

发表于 | 分类于

核心思想

将对象的构建与其表示分离，这样通过相同的构建过程可以创建不同的表示。

具体实现

将构建与表示分离，分为产品，建造，生产三个部分。

构建

生产模板

首先我们需要一个生产的模板，这是我们需要的最终产品的抽象，我们以一个抽象类表示，我们的最终产品是这个类的继承实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public abstract class Model {
	private ArrayList<String> queue = new ArrayList<String>();
	protected abstract void deal1();//不同的产品有不同的处理
	protected abstract void deal2();//不同的产品有不同的处理
	//根据处理顺序进行实际生产
	public void run() {
		for(int i=0;i<queue.size();i++){
			String act = queue.get(i);
			if(act.equals("1")){
				deal1(); //处理1
			}else if(act.equals("2")){
				deal2(); //处理2
			}
		}
	}
	//设置处理顺序
	public void setQueue(ArrayList<String> queue){
		this.queue = queue;
	}
}

抽象生产线

除了产品的模板外，我们还需要一个通用的组装生产线。对不同的产品由不同的生产线生产，但是它们拥有相同的生产线抽象。

1
2
3
4
5
6
public abstract class Builder {
	//根据需求设置生产顺序
	public abstract void setQueue(ArrayList<String> queue);
	//按顺序完成生产获取成品
	public abstract Model getModel();
}

表示

具体产品

具体的产品表示，假设有两种产品。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Product1 extends Model {
	protected void deal1() {
		System.out.println("Product1的deal1是这样处理的");
	}
	protected void deal2() {
		System.out.println("Product1的deal2是这样处理的");
	}
}

public class Product2 extends Model {
	protected void deal1() {
		System.out.println("Product2的deal1是这样处理的");
	}
	protected void deal2() {
		System.out.println("Product2的deal2是这样处理的");
	}
}

具体生产线

再根据不同的产品需要生成具体的两条生产线。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//产品1的生产线
public class Product1Builder extends Builder {
	private Product1 p1= new Product1();
	public Model getModel() {
		return p1;
	}
	public void setQueue(ArrayList<String> queue) {
		p1.setQueue(queue);
	}
}
//产品2的生产线
public class Product2Builder extends Builder {
	private Product2 p2= new Product2();
	public Model getModel() {
		return p2;
	}
	public void setQueue(ArrayList<String> queue) {
		p2.setQueue(queue);
	}
}

建造过程

接下来就是具体的生产过程了,我们将其封装到一个类中方便调用。

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
public class Factory{
	private ArrayList<String> queue = new ArrayList<String>();
	private Product1Builder p1=new Product1Builder();
	private Product2Builder p2=new Product2Builder();
	
	//获得第一类产品
	public Product1 getProduct1 (){
		queue.clear();
		//设置的执行顺序
		queue.add("1");
		queue.add("2");
		p1.setQueue(queue);
		Product1 product1 = (Product1)p1.getModel();
		return product1 ;
	}
    //获得第二类产品
	public Product2 getProduct2(){
		queue.clear();
		//设置的执行顺序
		queue.add("2");
		queue.add("1");
		p2.setQueue(queue);
		Product2 product2 = (Product2)p2.getModel();
		return product2 ;
	}
}

简单的体验一下

1
2
3
4
5
6
7
public static void main(String[] args) {
	Factory factory= new Factory ();
	Product1 product1 = factory.getProduct1();
	product1.run();
	Product2 product2 = factory.getProduct2(); 
	product2.run();
}

特点

与工厂模式与抽象工厂相似，这一模式具有很好的封装性，保证我们可以在不知道目标内部细节的情况下建立产品。由于每个具体的生产建造类之间是相互独立的，所以具有很好的外部扩展性，各个模块之间具有独立性，相互之间不会产生影响。除此之外，建造者模式相较于工厂方法突出强调了产品类中函数调用的顺序，这是其比较重要的特点。