设计模式之建造者模式

接上文，建造者模式比较简单，也属于创建型模式

适用类型：个人理解，（1）创建对象的操作比较复杂时，在建造者里面创建好对象

（2）在建造者里面组合好方法。类似于第一点，前者是创建对象，后者是组合方法

建造者 最关键的一点就是在建造者里面产生最终的建造结果！

例1:

abstract class BuildPerson {
    abstract void buildHead();
    abstract void buildBody();
    abstract void buildFoot();
    abstract Person buildPerson();
}

public class BuildMan extends BuildPerson{
    Person person = new Person();
	@Override
	void buildHead() {
		person.setHead("build man head");
	}

	@Override
	void buildBody() {
		person.setBody("build man body");
	}

	@Override
	void buildFoot() {
		person.setFoot("build man foot");
	}

	@Override
	Person buildPerson() {
		return this.person;
	}

	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}
    
}

public class Person{
    private String head;
    private String body;
    private String foot;
	public String getHead() {
		return head;
	}
	public void setHead(String head) {
		this.head = head;
	}
	public String getBody() {
		return body;
	}
	public void setBody(String body) {
		this.body = body;
	}
	public String getFoot() {
		return foot;
	}
	public void setFoot(String foot) {
		this.foot = foot;
	}
    
}

public class ManBuild {//建造者
     public Person getBuildMan(BuildMan bm){
         bm.buildHead();
         bm.buildBody();
         bm.buildFoot();
         return bm.buildPerson();
     }
}

public class Client {
    public static void main(String[] args){
        /*Director director = new Director();
        director.getDriveBmw().start();*/
        ManBuild mb = new ManBuild();
        Person person = mb.getBuildMan(new BuildMan());
        System.out.println(person.getBody());
    }
}

例二：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

abstract class DriveCar {
	protected List list = new ArrayList();
    abstract void openDoor();
    abstract void startEngine();
    protected void start(){
    	if(list!=null){
    		for(Iterator iterator = list.iterator();iterator.hasNext();){
    			String str = (String) iterator.next();
    			if(str.equalsIgnoreCase("open")){
    				openDoor();
    			}else{
    				startEngine();
    			}
    		}
    	}
    }
}

import java.util.List;

public class DriveBmw extends DriveCar{

	@Override
	void openDoor() {
		System.out.println("please open door");
	}

	@Override
	void startEngine() {
		System.out.println("please start engine");
	}
    
	public void setSEQ(List mylist){
		list = mylist;
	}
}

import java.util.ArrayList;
import java.util.List;

public class Client {
    public static void main(String[] args){
    	DriveBmw dr = new DriveBmw();
    	List list = new ArrayList();
    	  list.add("open");
    	  list.add("stop");
    	dr.setSEQ(list);
    	dr.start();
    }
}

这不是建造者模式，这样可以实现开车，开不同的车，开的顺序，但是有明显的弊端，比如让另一个人来开车，岂不是要重写一个list，再set进去，这样很麻烦

这时候，我们需要用到建造者模式，建造者负责建造顺序及最终的建造结果，用于整合这些逻辑

import java.util.List;

abstract class CarBuild {
    abstract DriveCar getCarModel();
    abstract void setSequence(List<String> sequence);
}


public class BmwCarBuild extends CarBuild{
    DriveBmw db = new DriveBmw();
	@Override
	DriveCar getCarModel() {
		return db;
	}
	@Override
	void setSequence(List<String> sequence) {
		db.setSEQ(sequence);
	}

}


import java.util.ArrayList;
import java.util.List;

public class Client {
    public static void main(String[] args){
    	List list = new ArrayList();
  	    list.add("open");
  	    list.add("stop");
    	BmwCarBuild bcb = new BmwCarBuild();
    	bcb.setSequence(list);
    	DriveBmw dr = (DriveBmw) bcb.getCarModel();
    	dr.start();
    	//DriveBmw dr_new = (DriveBmw) bcb.getCarModel();
    	//dr.start();
    }
}

加入建造者是为了解决谁来开车的问题，实现了开车与谁来开功能的分离，仔细体会

我们可以看到，客户端里面仍然不够简洁，所以可以加个导演类，setlist 和生成DriveBmw还可以封装

import java.util.ArrayList;
import java.util.List;

public class Director {
    private BmwCarBuild bcb;
    public DriveBmw getDriveBmw(){
    	bcb = new BmwCarBuild();
    	List<String> list = new ArrayList<String>();
    	list.add("open");
  	    list.add("stop");
  	    bcb.setSequence(list);
    	return (DriveBmw) bcb.getCarModel();
    }    
}

public class Client {
    public static void main(String[] args){
    	Director director = new Director();
    	director.getDriveBmw().start();
    }
}

1. 建造者模式的优点

• 封装性

使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们就不需要关心每一个具体的模型内部是如何实现的，产生的对象类型就是CarModel。

• 建造者独立，容易扩展

建造者的实现是相互独立的，对系统的扩展非常有利。

• 便于控制细节风险

由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

2. 建造者模式的使用场景

• 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。

• 多个部件或零件,都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式是非常合适。

• 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景，只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计最初目标。