设计模式-建造者模式
建造者模式模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式第一种创建行模式，他讲客户端与包含多个部件的复杂对象的创建过程分离，客户端无需知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。建造者模式关注如何一步一步的创建一个负责对象，不同的建造者定义了不同的建造过程。
模式结构
Builder（抽象的建造者）：他为创建一个产品对象的各个部件制定抽象接口，在该接口中一般声明两个方法，一个是创建对象属性的方法，另一个是用于返回复杂对象的方法。该类可以是抽象类，也可以是接口。
ConcreteBuilder（具体的建造者）：他实现了Build接口，并重写父类方法。
Product（产品）：他是被构建的复杂对象。定义各个部件（属性），具体的建造者负责建造他的部件。并定义它的装配过程。
Director（指挥者）：指挥者又称为导演类，他负责安排创建复杂对象部件的次序，导演类与抽象建造者存在关联关系。可以在其construct()建造方法中调用建造者对象的部件构造与装配种方法，完成对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者的对象，然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者中。
建造者模式与抽象工厂模式都是较为复杂的创建型模式，建造者模式返回一个完整的负责的产品，抽象工厂模式返回一系列相关的产品；在抽象工厂模式中，客户端通过选择具体的工厂来生成岁需要的对象，而在建造者模式中，客户端通过执行具体建造者类型来指导导演类如何创建对象。
举例说明
场景：游戏中的角色。
复杂对象类：角色，其中角色类型，性别，脸型，服装，发型等都为对象的部件
package com.gm.builder.one;
/**
* 角色对象， 充当产品，该产品由较为复杂的属性（组成部分）
*/
public class Actor {
/**
* 角色
*/
private String type;
/**
* 性别
*/
private String sex;
/**
* 脸型
*/
private String face;
/**
* 服装
*/
private String costume;
/**
* 发型
*/
private String hairstyle;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getFace() {
return face;
}
public void setFace(String face) {
this.face = face;
}
public String getCostume() {
return costume;
}
public void setCostume(String costume) {
this.costume = costume;
}
public String getHairstyle() {
return hairstyle;
}
public void setHairstyle(String hairstyle) {
this.hairstyle = hairstyle;
}
@Override
public String toString() {
return "Actor{" +
"type='" + type + '\'' +
", sex='" + sex + '\'' +
", face='" + face + '\'' +
", costume='" + costume + '\'' +
", hairstyle='" + hairstyle + '\'' +
'}';
}
}
抽象建造者：声明创建复杂对象的各个部件，并通过工厂方法返回复杂对象
package com.gm.builder.one;
/**
* 抽象建造者
*/
public abstract class ActorBuild {
protected Actor actor = new Actor();
/**
* 建造角色类型
*/
public abstract void buildType();
/**
* 建造性别
*/
public abstract void buildSex();
/**
* 建造脸型
*/
public abstract void buildFace();
/**
* 建造服装
*/
public abstract void buildCostume();
/**
* 建造发型
*/
public abstract void buildHairstyle();
/**
* 工厂方法，返回完成的对象
* @return
*/
public Actor createActor(){
return actor;
}
}
具体的创建者：天使创建者，英雄创建者，继承抽象建造者，并重写创建部件的方法，完成部件具体创建过程。
package com.gm.builder.one;
/**
* 天使角色
*/
public class AngleBuild extends ActorBuild {
@Override
public void buildType() {
actor.setType("天使");
}
@Override
public void buildSex() {
actor.setSex("女");
}
@Override
public void buildFace() {
actor.setFace("成熟脸");
}
@Override
public void buildCostume() {
actor.setCostume("性感的衣服");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("大波浪");
}
}
package com.gm.builder.one;
/**
* 英雄角色
*/
public class HeroBuild extends ActorBuild {
@Override
public void buildType() {
actor.setType("英雄");
}
@Override
public void buildSex() {
actor.setSex("MAN");
}
@Override
public void buildFace() {
actor.setFace("美队的脸");
}
@Override
public void buildCostume() {
actor.setCostume("钢铁侠的衣服");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("美队的发型");
}
}
导演类：其中的construct()方法进行安排创建部件的次序并逐步完成的创建。
package com.gm.builder.one;
/**
* 角色控制器，充当导演类
*/
public class ActorController {
/**
* 逐步创建产品的组件
* @param build
* @return
*/
public Actor construct(ActorBuild build){
build.buildType();
build.buildSex();
build.buildFace();
build.buildCostume();
build.buildHairstyle();
return build.createActor();
}
}
客户端
package com.gm.builder.one;
public class Client {
public static void main(String[] args) throws Exception{
ActorBuild build = (ActorBuild) Class.forName("com.gm.builder.one.AngleBuild").newInstance();
ActorController controller = new ActorController();
Actor actor = controller.construct(build);
System.out.println(actor);
}
}
运行结果
Actor{type='天使', sex='女', face='成熟脸', costume='性感的衣服', hairstyle='大波浪'}导演类深入讨论
导演类是创建者模式的重要组成部分，控制创建对象部件的次序，并返回一个完整额对象，下面讨论几种导演类的变化形式：
1.省略导演类：
为了简化程序结构，可将导演类和抽象建造者进行合并，在抽象建造者中提供导演类的功能。可将construct()方法使用static修饰，以方便客户端调用。则抽象建造者的代码如下：
package com.gm.builder.two;
public abstract class ActorBuild {
protected static Actor actor = new Actor();
/**
* 建造角色类型
*/
public abstract void buildType();
/**
* 建造性别
*/
public abstract void buildSex();
/**
* 建造脸型
*/
public abstract void buildFace();
/**
* 建造服装
*/
public abstract void buildCostume();
/**
* 建造发型
*/
public abstract void buildHairstyle();
/**
* 工厂方法1，返回完成的对象,逐步创建产品的组件,用来替换导演类
* @return
*/
public Actor construct(){
this.buildType();
this.buildSex();
this.buildFace();
this.buildCostume();
this.buildHairstyle();
return actor;
}
/**
* 工厂方法2，返回完成的对象,逐步创建产品的组件,用来替换导演类
* @return
*/
public static Actor construct(ActorBuild build){
build.buildType();
build.buildSex();
build.buildFace();
build.buildCostume();
build.buildHairstyle();
return actor;
}
}
从而客户端的方法如下：
package com.gm.builder.two;
/**
* 客户端
*/
public class Client {
public static void main(String[] args) throws Exception{
//方法1
ActorBuild build = (ActorBuild) Class.forName("com.gm.builder.two.AngleBuild").newInstance();
Actor actor = build.construct();
System.out.println(actor);
//方法2
ActorBuild build2 = (ActorBuild) Class.forName("com.gm.builder.two.HeroBuild").newInstance();
Actor actor2 = ActorBuild.construct(build2);
System.out.println(actor2);
}
}
2.钩子方法引入
钩子方法通常为boolean型，方法名一般为is****(),钩子方法一边定义在抽象的建造者中。
抽象建造者;
package com.gm.builder.one;
/**
* 抽象建造者
*/
public abstract class ActorBuild {
protected Actor actor = new Actor();
/**
* 建造角色类型
*/
public abstract void buildType();
/**
* 建造性别
*/
public abstract void buildSex();
/**
* 建造脸型
*/
public abstract void buildFace();
/**
* 建造服装
*/
public abstract void buildCostume();
/**
* 建造发型
*/
public abstract void buildHairstyle();
/**
* 钩子方法
* @return
*/
public boolean isBareheaded(){
return false;
}
/**
* 工厂方法，返回完成的对象
* @return
*/
public Actor createActor(){
return actor;
}
}
具体建造者：
package com.gm.builder.one;
/**
* 英雄角色
*/
public class HeroBuild extends ActorBuild {
@Override
public void buildType() {
actor.setType("英雄");
}
@Override
public void buildSex() {
actor.setSex("MAN");
}
@Override
public void buildFace() {
actor.setFace("美队的脸");
}
@Override
public void buildCostume() {
actor.setCostume("钢铁侠的衣服");
}
@Override
public void buildHairstyle() {
actor.setHairstyle("美队的发型");
}
@Override
public boolean isBareheaded(){
return true;
}
}
通过引入钩子方法可以在导演类中对复杂对象进行精细化管理，不仅可以指定对象部件执行顺序，也可进行控制是否需要进行创建某个部件。
优劣势
优势
1.客户端无需知道产品内部组成细节，将产品本身与产品创建过程进行解耦，使得相同的创建过程创建不同的对象。
2.每一个具体的建造者都是独立的，增加新的建造者无需修改原有类的代码，符合开闭原则
3.可以精细化控制对象的创建过程。
劣势
1.建造者模式一般所创建的产品对象都有较多的共同点，如果产品之间的差异性很大，不适用该模式。
2.产品内部变化复杂，可能会导致更多的具体建造者来进行创建，导致系统变得复杂。
适用场景
1.需要生成的产品对象有复杂的内部结构，这些产品通常包含对个成员变量。
2.需要生成的产品属性相互依赖，需要指定其生成顺序。
3.对象的创建过程独立于创建该对象的类型。
4.复杂对象的创建和使用，并使得相同创建过程可以创建不同对象。