设计模式/建造模式

建造模式(Builder)

有这么个例子来形容建造模式我觉得很易懂!

我要建一个法式风格房子,

如果单单雇佣工人去做,可能最后他给我造出了中式的小楼房(那就跟我的要求完全不符合了),

如果单单找个设计师去做这个事情,(设计师哪会造房子!!),

所以我既要用到设计师为我设计房子,也要用到工人建造房子,才能为我造出设计师画在图纸上的房子!!

---------------------------------------------------------------------------------------------------------------------------

设计师 跟 工人都是我找的, 因为我不可能把这个房子完全交给设计师去做(还是对自己找的工人比较放心),

其次 , 工人要能听从设计师的命令, 造出我想要的房子,

然后最后我问工人 去拿房子 ,为什么找工人而不是设计师呢?

要明白 整个过程中设计师其实就是动动嘴皮子,画画图纸的, 房子是工人 一点一点建造起来的,所以当然要问工人拿房子.

下面就开始建房子咯~~

// Builder的接口,包含制作房子零件的方法,以及取回房子的方法
public interface mBuilder {

// 我要一个窗子
public void makeWindow(String window);
// 我还要一个门
public void makeDoor(String door);
// 最后我需要一块地板
public void makeFloor(String floor);

//问工人拿回房子的方法,因为工人类会实现这个接口
public Room getChineseRoom();

public Room getFrenchRoom();
}

// 设计师类

public class Design {

mBuilder builder;

public Design(mBuilder builder){
this.builder = builder;
}
// 假设我们按照 窗子 --> 门 --> 地板的顺序 构造的是中式的房子
public void makeChineseRoom(String... strings){
builder.makeWindow(strings[0]);
builder.makeDoor(strings[1]);
builder.makeFloor(strings[2]);
}
// 假设我们按照 门 --> 地板 --> 窗子 的顺序 构造的是法式的房子
public void makeFrenchRoom(String... strings){
builder.makeFloor(strings[0]);
builder.makeDoor(strings[1]);
builder.makeWindow(strings[2]);
}
}

//房子类

public class Room {

String a,b,c;

public Room(String... strings){
this.a = strings[0];
this.b = strings[1];
this.c = strings[2];
}

public void out_print(){
System.out.println("零件依旧是:");
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}

//工人类 实现了工人接口

public class GongRen implements mBuilder{

String window ;
String door;
String floor;

@Override
public void makeWindow(String window){
this.window = window;
}

@Override
public void makeDoor(String door) {
this.door = door;
}

@Override
public void makeFloor(String floor) {
this.floor  = floor;
}

@Override
public Room getChineseRoom() {
// TODO Auto-generated method stub
System.out.println("建造了中式的房子!");
return new Room(window,door,floor);
}

public Room getFrenchRoom(){
System.out.println("建造了法式的房子!");
return new Room(door,floor,window);
}

}

// 最后 测试类

public class Client {

public static void main(String[] args){

mBuilder gongren = new GongRen();
Design designer = new Design(gongren);

designer.makeChineseRoom("窗子","门","地板");
// 建造中式房子
Room chineseRoom = gongren.getChineseRoom();
chineseRoom.out_print();
// 建造法式房子
Room frenchroom = gongren.getFrenchRoom();
frenchroom.out_print();
}

}

// 运行结果

建造了中式的房子!

零件依旧是:

窗子

门

地板

建造了法式的房子!

零件依旧是:

门

地板

窗子

通过这个例子看到了,即便相同的零件,不同的顺序可能会构造出不同的产品!!!

-----------------------------------------------------------------------------------------------------

同样的需求,我用工厂模式也写了一下,让我们来观察一下不同点

// 抽象工厂

//我找了一个建筑公司
public abstract class JianZhuGongSi {

// 这个建筑公司会造两种类型的房子
public abstract Room create_ChineseRoom();
public abstract Room create_FrenchRoom();
}

// 具体的工厂

//现在这个公司将这个项目 ,分配给具体的一个部门 A去做这件事情
public class GongSiBuMen extends JianZhuGongSi{

@Override
public Room create_ChineseRoom() {
// TODO Auto-generated method stub
return new ChineseRoom();
}

@Override
public Room create_FrenchRoom() {
// TODO Auto-generated method stub
return new FrenchRoom();
}
}

// 抽象的产品

public abstract class Room {

public void ChineseRoom(){};

public void FrenchRoom(){};
}

// 具体的产品

public class ChineseRoom extends Room{

public ChineseRoom(){
System.out.println("Make Chinese Room");
};
}

public class FrenchRoom extends Room{

public FrenchRoom(){

System.out.println("Make French Room !");
};

}

// 调用类

public class Client {

public static void main(String args[]){

JianZhuGongSi factory = new GongSiBuMen();

ChineseRoom chineseRoom = (ChineseRoom) factory.create_ChineseRoom();

FrenchRoom frenchRoom = (FrenchRoom) factory.create_FrenchRoom();

}
}

我们看到,一个不同的产品,就要实现一个具体的产品类,只要产品不同,就必须多实现一个类,而不管你是不是使用的相同的零件, 由此看来,它与建造者模式的最大的区别在于,

零件的顺序使用上 , 建造模式允许相同零件不同顺序构造不同的产品 !