北风设计模式课程---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(); } }
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生成器)对产品属性有不同的创建方法