安装电脑思考到了Java设计模式：建造者模式
定义
建造者模式是对象的创建型模式，可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象
建造者模式将产品的结构和产品的零件建造过程对客户端隐藏起来，把对建造过程进行指挥的责任和具体建造者零件的责任分割开来，达到责任划分和封装的目的
意图
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示
主要解决问题
主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定
何时使用
一些基本部件不会变，而其组合经常变化的时候
优缺点
优点：
- 建造者独立，易扩展
- 便于控制细节风险
缺点：
- 产品必须有共同点，范围有限制
- 如果内部变化复杂，会有很多的建造类
结构
涉及的角色：
- 抽象建造者（Builder）角色：给出一个抽象接口，用来规范产品对象的各个组成成分的建造，一般来说，产品所包含的零件数目和建造方法的数目相等，换而言之，有多少个零件，就有多少相应的建造方法
- 具体建造者（ConcreteBuilder）角色：实现抽象建造者所声明的接口，给出一步步的完成创建产品实例的操作；在建造过程完成后，提供产品的实例
- 导演者（Director）角色：担任这个角色的类调用具体建造者角色来创建产品对象，导演者角色并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者角色
- 产品（Product）角色：产品便是建造中的复杂对象，一般来说，一个系统中会有多于一个的产品类，而且这些产品类并不一定有共同的接口，而完全可以是不相关的
一般来说，每有一个产品类，就有一个相应的具体建造者类，这些产品应当有一样数目的零件，而每有一个零件，就相应的在所有的建造者角色中有一个建造方法
源码如下：
public interface Builder {
/** 产品零件构造方法 */
void buildPart1();
/** 产品零件构造方法 */
void buildPart2();
/** 产品返还方法 */
Product retrieveResult();
}
public class ConcreteBuilder implements Builder {
private Product product = new Product();
/** 产品零件构造方法 */
@Override
public void buildPart1() {
//建造产品的第一个零件
}
/** 产品零件构造方法 */
@Override
public void buildPart2() {
//建造产品的第二个零件
}
/** 产品返还方法 */
@Override
public Product retrieveResult() {
return product;
}
}
public class Director {
private Builder builder;
/**
* 产品构造方法，负责调用各个零件构造方法
*/
public void construct() {
builder = new ConcreteBuilder();
builder.buildPart1();
builder.buildPart2();
builder.retrieveResult();
}
}
public class Product {
}
组装电脑的例子
电脑的组装有内存、主板、cpu、机箱等，可以按照不同的步骤进行组装
电脑类：
public class Compute {
/** cpu */
private String cpu;
/** 主板 */
private String board;
/** 内存 */
private String memory;
/** 机箱 */
private String crate;
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getBoard() {
return board;
}
public void setBoard(String board) {
this.board = board;
}
public String getMemory() {
return memory;
}
public void setMemory(String memory) {
this.memory = memory;
}
public String getCrate() {
return crate;
}
public void setCrate(String crate) {
this.crate = crate;
}
@Override
public String toString() {
return "Compute{" +
"cpu='" + cpu + '\'' +
", board='" + board + '\'' +
", memory='" + memory + '\'' +
", crate='" + crate + '\'' +
'}';
}
}
抽象建造者角色，抽象出组装电脑的步骤：
public interface ComputeBuilder {
/** 组装CPU */
void buildCpu();
/** 组装主板 */
void buildBoard();
/** 组装内存 */
void buildMemory();
/** 组装机箱 */
void buildCrate();
/** 组装完成，返回一台电脑 */
Compute getCompute();
}
具体建造者角色，组装各个零件的操作：
public class ConcreteComputeBuilder implements ComputeBuilder {
private Compute compute = new Compute();
@Override
public void buildCpu() {
System.out.println("组装cpu");
compute.setCpu("组装cpu");
}
@Override
public void buildBoard() {
System.out.println("组装主板");
compute.setBoard("组装主板");
}
@Override
public void buildMemory() {
System.out.println("安装内存条");
compute.setMemory("安装内存条");
}
@Override
public void buildCrate() {
System.out.println("安装机箱");
compute.setCrate("安装机箱");
}
@Override
public Compute getCompute() {
return compute;
}
}
开始组装：
public class ComputeDirector {
private ComputeBuilder builder;
public void assemblyCompute() {
builder = new ConcreteComputeBuilder();
builder.buildCpu();
builder.buildBoard();
builder.buildMemory();
builder.buildCrate();
System.out.println(builder.getCompute());
}
}
测试类：
public class Client {
public static void main(String[] args) {
ComputeDirector director = new ComputeDirector();
director.assemblyCompute();
}
}
