北风设计模式课程---7、建造者模式

一、总结

一句话总结：

设计模式都是对生活中好的做事方法的一些抽象，使得各司其职，减少出错。

建造者模式可以看做模仿的生活中：设计师，施工队做复杂房子交给客户的场景

角色：学设计模式分清角色就很简单了

1、建造者模式是什么？

1、造房子：隐藏复合对象的创建过程

2、不同施工队：把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建

3、用户：用户单纯的从施工队那里接收房子即可

用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

2、建造者模式实例？

1、房子基类：比如修房子，有房子基类，如果直接让用户修房子的话，修不同的房子修改麻烦

2、施工队：找工程队(接口)来修，如果修平房就找修平房的建造工人(接口实例)，如果修楼房就找修楼房的建造工人(接口实例)，这些具体的工人要返回实例出去的，修房子的过程就是修改房子基类属性的过程

3、设计师：有设计师角色，设计师角色指导工程队来修房子，设计师里面有工程队的实例，方便指挥工程队做事

3、建造者模式的修房子实例的核心代码示例？

1、找具体工程队：HouseBuilder builder = new GongyuBuilder(); //比如这里修公寓 //由工程队来修

2、设计师指导工程队做：HouseDirector director = new HouseDirector(); director.makeHouse(builder);

3、第二步中可以弄成静态方法来优化一下

4、建造者模式应用场景是什么？

1、创建对象的时候：Builder模式是为对象的创建而设计的模式

2、创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象

3、关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法

5、建造者模式的实质是什么？

施工队：做房子由专门的施工队来做

设计师：施工队怎么做由设计师来指导

用户：直接接收施工队做好的house即可

6、建造者模式的优缺点是什么？

1、方便用户：用户不必关注复杂房子的创建过程，直接从施工队手里拿房子即可

2、不同施工队各司其职：建造不同的房子，或者建造房子中不同的部位，有不同的施工队

7、legend2项目中如何使用建造者模式（比如构建奖励的数据）？

施工队：比如构建奖励的数据，不同的施工队构建不同类型的奖励，比如装备、特性书等

设计师：有一个设计师，来负责指导施工队该怎么做

用户：用户只管得到施工队处理好的数据即可

二、内容在总结中

1、相关知识

2、代码

房子基类：House.java

施工队接口：HouseBuilder.java

平房施工队（实现施工队接口）：PingFangBuilder.java：做平房

公寓施工队（实现施工队接口）：GongyuBuilder.java：做公寓

设计师：HouseDirector.java：指导具体施工队如何做房子

用户-主类： MainClass.java：获取具体施工队做好的房子

房子基类：House.java

 1 /*
 2  * ·¿×Ó
 3  */
 4 public class House {
 5     // µØ°å
 6     private String floor;
 7     // Ç½
 8     private String wall;
 9     // ÎÝ¶¥
10     private String housetop;
11
12     public String getFloor() {
13         return floor;
14     }
15
16     public void setFloor(String floor) {
17         this.floor = floor;
18     }
19
20     public String getWall() {
21         return wall;
22     }
23
24     public void setWall(String wall) {
25         this.wall = wall;
26     }
27
28     public String getHousetop() {
29         return housetop;
30     }
31
32     public void setHousetop(String housetop) {
33         this.housetop = housetop;
34     }
35
36 }

施工队接口：HouseBuilder.java

/** ¹¤³Ì¶Ó*/
public interface HouseBuilder {//ÐÞµØ°åpublic void makeFloor();//ÐÞÇ½public void makeWall();//ÐÞÎÝ¶¥public void makeHousetop();public House getHouse();
}

平房施工队（实现施工队接口）：PingFangBuilder.java：做平房

/** 平房工程队*/public class PingFangBuilder implements HouseBuilder {House house = new House();public void makeFloor() {house.setFloor("平房-->地板");}public void makeHousetop() {house.setHousetop("平房-->房顶");}public void makeWall() {house.setWall("平房-->墙");}public House getHouse() {return house;}}

公寓施工队（实现施工队接口）：GongyuBuilder.java：做公寓

public class GongyuBuilder implements HouseBuilder{House house = new House();public House getHouse() {return house;}public void makeFloor() {house.setFloor("公寓-->地板");}public void makeHousetop() {house.setHousetop("公寓-->房顶");}public void makeWall() {house.setWall("公寓-->墙");}}

设计师：HouseDirector.java：指导具体施工队如何做房子

public class HouseDirector {    public void makeHouse(HouseBuilder builder) {builder.makeFloor();builder.makeWall();builder.makeHousetop();}}

用户-主类： MainClass.java：获取具体施工队做好的房子

public class MainClass {public static void main(String[] args) {
//        //客户直接造房子
//        House house = new House();
//        house.setFloor("地板");
//        house.setWall("墙");
//        house.setHousetop("屋顶");//由工程队来修HouseBuilder builder = new GongyuBuilder();//设计者来做HouseDirector director = new HouseDirector();director.makeHouse(builder);House house = builder.getHouse();System.out.println(house.getFloor());System.out.println(house.getWall());System.out.println(house.getHousetop());}}

三、java设计模式-----6、建造者模式

转自或参考：java设计模式-----6、建造者模式
https://www.cnblogs.com/xiaobai1226/p/8507239.html

　　Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

　　建造者模式的结构

　　角色

　　在这样的设计模式中，有以下几个角色：

　　　　1 builder：为创建一个产品对象的各个部件指定抽象接口。

　　　　2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

　　　　3 Director：构造一个使用Builder接口的对象。

　　　　4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

　　首先，举个例子，建造者模式我们比方我们要造个房子。

　　房子的图纸

 1 public class House {
 2     //地板
 3     private String floor;
 4     //墙
 5     private String wall;
 6     //房顶
 7     private String roof;
 8
 9     public String getFloor() {
10         return floor;
11     }
12     public void setFloor(String floor) {
13         this.floor = floor;
14     }
15     public String getWall() {
16         return wall;
17     }
18     public void setWall(String wall) {
19         this.wall = wall;
20     }
21     public String getRoof() {
22         return roof;
23     }
24     public void setRoof(String roof) {
25         this.roof = roof;
26     }
27 }

　　有了图纸后，最笨的方法就是自己造房子

　　客户端

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         //客户直接造房子
 4         House house = new House();
 5
 6         house.setFloor("地板");
 7         house.setWall("墙");
 8         house.setRoof("屋顶");
 9
10         System.out.println(house.getFloor());
11         System.out.println(house.getWall());
12         System.out.println(house.getRoof());
13     }
14 }

　　可是这样的方法不是很好，真正我们造房子都是找施工队，所以我们要把造房子分离出来，交给施工队

　　新建一个施工队，为了扩展性，声明一个施工队的接口

 1 public interface HouseBuilder {
 2     //修地板
 3     public void makeFloor();
 4     //修墙
 5     public void makeWall();
 6     //修屋顶
 7     public void makeRoof();
 8     //获得修好的房子
 9     public House getHouse();
10 }

　　新建一个施工队，实现此接口

 1 public class LoufangBuilder implements HouseBuilder{
 2     House house = new House();
 3
 4     @Override
 5     public void makeFloor() {
 6         house.setFloor("楼房->地板");
 7     }
 8
 9     @Override
10     public void makeWall() {
11         house.setWall("楼房->墙");
12     }
13
14     @Override
15     public void makeRoof() {
16         house.setRoof("楼房->屋顶");
17     }
18
19     @Override
20     public House getHouse() {
21         return house;
22     }
23 }

　　客户端

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         //施工队造房子
 4         HouseBuilder loufangBuilder = new LoufangBuilder();
 5         loufangBuilder.makeFloor();
 6         loufangBuilder.makeWall();
 7         loufangBuilder.makeRoof();
 8
 9         House house = loufangBuilder.getHouse();
10         System.out.println(house.getFloor());
11         System.out.println(house.getWall());
12         System.out.println(house.getRoof());
13     }
14 }

　　可以看到，这样子造房子就交给施工队了，但可以看到造房子的具体细节还在客户端里，如图。

　　这就相当于我们在指导施工队干活，这肯定不是最好的方案，最好的解决方案，是由一个设计师也可以说是指挥者来指导工程队，所以在新建一个指挥者

 1 public class HouseDirector {
 2     private HouseBuilder houseBuilder;
 3
 4     public HouseDirector(HouseBuilder houseBuilder){
 5         this.houseBuilder = houseBuilder;
 6     }
 7
 8     public void make(){
 9         houseBuilder.makeFloor();
10         houseBuilder.makeWall();
11         houseBuilder.makeRoof();
12     }
13 }

　　客户端

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         //施工队造房子
 4         HouseBuilder loufangBuilder = new LoufangBuilder();
 5 //        loufangBuilder.makeFloor();
 6 //        loufangBuilder.makeWall();
 7 //        loufangBuilder.makeRoof();
 8         HouseDirector houseDirector = new HouseDirector(loufangBuilder);
 9         houseDirector.make();
10
11         House house = loufangBuilder.getHouse();
12         System.out.println(house.getFloor());
13         System.out.println(house.getWall());
14         System.out.println(house.getRoof());
15     }
16 }

　　这样子，把施工队交给这个设计者，施工细节的工作就由这个设计者执行了。

　　当然，还有一种写法，有一些细微的改动，也是更常用的，就是设计者（Director）不在构造时传入builder，而是在调用方法时，才传入，像这样

1 public class HouseDirector {
2     public void make(HouseBuilder houseBuilder){
3         houseBuilder.makeFloor();
4         houseBuilder.makeWall();
5         houseBuilder.makeRoof();
6     }
7 }

　　客户端

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         //施工队造房子
 4         HouseBuilder loufangBuilder = new LoufangBuilder();
 5
 6         HouseDirector houseDirector = new HouseDirector();
 7         houseDirector.make(loufangBuilder);
 8
 9         House house = loufangBuilder.getHouse();
10         System.out.println(house.getFloor());
11         System.out.println(house.getWall());
12         System.out.println(house.getRoof());
13     }
14 }

　　这样子，出来的效果是一样的。

　　这就是一个简单的建造者模式

　　这样也提高了系统的扩展性与可维护性，如果不想造楼房了，想造一个别墅，只需新增一个别墅施工队就好了，像这样

 1 public class BieshuBuilder implements HouseBuilder{
 2     House house = new House();
 3
 4     @Override
 5     public void makeFloor() {
 6         house.setFloor("别墅->地板");
 7     }
 8
 9     @Override
10     public void makeWall() {
11         house.setWall("别墅->墙");
12     }
13
14     @Override
15     public void makeRoof() {
16         house.setRoof("别墅->屋顶");
17     }
18
19     @Override
20     public House getHouse() {
21         return house;
22     }
23 }

　　客户端只需把施工队换成别墅施工队

public class MainClass {public static void main(String[] args) {//施工队造房子HouseBuilder bieshuBuilder = new BieshuBuilder();//只需要修改这里
HouseDirector houseDirector = new HouseDirector();houseDirector.make(bieshuBuilder);House house = bieshuBuilder.getHouse();System.out.println(house.getFloor());System.out.println(house.getWall());System.out.println(house.getRoof());}
}

　　适用范围

　　1、对象的创建：Builder模式是为对象的创建而设计的模式

　　2、创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象

　　3、关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法

转载于:https://www.cnblogs.com/Renyi-Fan/p/10993594.html