程序中的建造者：我们买的电脑都是由主板、内存、cpu、显卡等组成，如何把这些东西组装起来给用户这就是建造者模式的作用，不同的人对电脑的配置需求不一样的「打游戏的对显卡要求高」，但是电脑构成部件是固定的，我们找电脑城的装机人员把电脑装起来这一过程就是建造模式
建造者模式定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，这是官方定义，通俗的说就是：建造者模式就是如何一步步构建一个包含多个组成部件的对象，相同的构建过程可以创建不同的产品（创建型设计模式）
建造者模式结构 ：
- Builder：接口或抽象类，抽象的建造者
- ConcreateBuilder：具体的建造者，可以有多个，建造风格可能不一样
- Product：具体的产品，即被建造的对象
- Director：导演，也叫指挥者，统一指挥建造者去建造目标
组装电脑
package com.ag.builder;
public class Test1 {
public static void main(String[] args) {
Builder builder = new XiaoLiBuilder();
Designer designer = new Designer(builder);
Computer computer1 = designer.buildComputer("三星", "SK 海力士 32G DDR4 2666 3200 MHZ",
"联想(Lenovo)拯救者刃7000P ", "金士顿(Kingston) 500GB SSD固态硬盘",
"AMD 锐龙9 5950X 处理器(r9)7nm");
System.out.println(computer1);
}
}
class Computer{
private String cpu;
private String memory;//内存
@Override
public String toString() {
return "Computer{" +
"cpu='" + cpu + ''' +
", memory='" + memory + ''' +
", hardDisk='" + hardDisk + ''' +
", host='" + host + ''' +
", monitor='" + monitor + ''' +
'}';
}
private String hardDisk;//硬盘
private String host;//主机
private String monitor;//显示屏
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getMemory() {
return memory;
}
public void setMemory(String memory) {
this.memory = memory;
}
public String getHardDisk() {
return hardDisk;
}
public void setHardDisk(String hardDisk) {
this.hardDisk = hardDisk;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public String getMonitor() {
return monitor;
}
public void setMonitor(String monitor) {
this.monitor = monitor;
}
}
abstract class Builder{
public abstract void createCpu(String cpu);
public abstract void createMemory(String memory);
public abstract void createHardDisk(String hardDisk);
public abstract void createHost(String host);
public abstract void createMonitor(String monitor);
public abstract Computer createComputer();
}
class XiaoLiBuilder extends Builder{
Computer computer = new Computer();
public void createCpu(String cpu){
computer.setCpu(cpu);
}
public void createMemory(String memory){
computer.setMemory(memory);
}
public void createHardDisk(String hardDisk){
computer.setHardDisk(hardDisk);
}
public void createHost(String host){
computer.setHost(host);
}
public void createMonitor(String monitor){
computer.setMonitor(monitor);
}
public Computer createComputer() {
return this.computer;
}
}
class Designer{
Builder builder;
public Designer(Builder builder){
this.builder = builder;
}
public Computer buildComputer(String cpu,String memory,String hardDisk,String host,String monitor){
builder.createCpu(cpu);
builder.createHardDisk(hardDisk);
builder.createHost(host);
builder.createMemory(memory);
builder.createMonitor(monitor);
return builder.createComputer();
}
public Computer buildComputer(String cpu,String memory,String hardDisk,String host){
builder.createCpu(cpu);
builder.createHardDisk(hardDisk);
builder.createHost(host);
builder.createMemory(memory);
return builder.createComputer();
}
public Computer buildBijibenComputer(String cpu,String memory,String hardDisk,String monitor){
builder.createCpu(cpu);
builder.createHardDisk(hardDisk);
builder.createMemory(memory);
builder.createMonitor(monitor);
return builder.createComputer();
}
}
如果需要不一样的建造风格可以直接定义一个建造者继承Builder类，然后在main中使用即可
与不可变对象配合使用：
package com.ag.builder;
public class BuilderMode {
public static void main(String[] args) {
Computer1 computer1 = new Computer1.Builder().createCpu("三星").createHardDisk("联想(Lenovo)拯救者刃7000P ")
.createHost("金士顿(Kingston) 500GB SSD固态硬盘").createMemory("SK 海力士 32G DDR4 2666 3200 MHZ")
.createMonitor("AMD 锐龙9 5950X 处理器(r9)7nm").build();
System.out.println(computer1);
}
}
class Computer1{
private final String cpu;
private final String memory;//内存
private final String hardDisk;//硬盘
private final String host;//主机
private final String monitor;//显示屏
@Override
public String toString() {
return "Computer1{" +
"cpu='" + cpu + ''' +
", memory='" + memory + ''' +
", hardDisk='" + hardDisk + ''' +
", host='" + host + ''' +
", monitor='" + monitor + ''' +
'}';
}
// public Computer1() {
// }
Computer1(String cpu, String memory, String hardDisk, String host, String monitor) {
this.cpu = cpu;
this.memory = memory;
this.hardDisk = hardDisk;
this.host = host;
this.monitor = monitor;
}
static class Builder{
private String cpu;
private String memory;//内存
private String hardDisk;//硬盘
private String host;//主机
private String monitor;//显示屏
public Builder createCpu(String cpu){
this.cpu = cpu;
return this;
}
public Builder createMemory(String memory){
this.memory = memory;
return this;
}
public Builder createHardDisk(String hardDisk){
this.hardDisk = hardDisk;
return this;
}
public Builder createHost(String host){
this.host = host;
return this;
}
public Builder createMonitor(String monitor){
this.monitor = monitor;
return this;
}
public Computer1 build(){
return new Computer1( this.cpu, this.memory, this.hardDisk, this.host, this.monitor);
}
}
}
应用场景：
- 需要生成的对象具有复杂的内部结构
- 需要生成的对象内部属性本身相互依赖
- 与不可变对象配合使用
- 建造者独立易于扩展
- 便于控制细节风险
