接上文,建造者模式比较简单,也属于创建型模式
适用类型:个人理解,(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. 建造者模式的使用场景
-
相同的方法,不同的执行顺序,产生不同的事件结果时,可以采用建造者模式。
-
多个部件或零件,都可以装配到一个对象中,但是产生的运行结果又不相同时,则可以使用该模式。
-
产品类非常复杂,或者产品类中的调用顺序不同产生了不同的效能,这个时候使用建造者模式是非常合适。
-
在对象创建过程中会使用到系统中的一些其它对象,这些对象在产品对象的创建过程中不易得到时,也可以采用建造者模式封装该对象的创建过程。该种场景,只能是一个补偿方法,因为一个对象不容易获得,而在设计阶段竟然没有发觉,而要通过创建者模式柔化创建过程,本身已经违反设计最初目标。