介绍建造者模式

建造者模式

将一个复杂对象的创建与它的表示分离，使得同样的构建过程可以创建不同的表示

四种角色

1. Product 产品角色 指的是一个具体的产品对象
2. Builder 抽象建造者 创建一个产品对象的各个部件的接口/抽象类
3. ConcreteBuilder 具体建造者 实现或继承抽象建造者接口 具体的构建和装配各个部件
4. Director 指挥者 构建一个使用Builder接口的对象，主要用于创建一个复杂的对象，负责指挥构建一个工程，决定了工程如何构建，按照什么顺序构建

场景

• 需要生成的对象具有复杂的内部结构
• 需要生成的对象内部属性本身相互依赖
• 与不可变对象配合使用

优点

• 建造者独立，易于扩展
• 便于控制细节风险

实现

使用继承的方式实现

public class ExtendTest {
    public static void main(String[] args) {
        AbstractBook book = new MacBookPro();
        book.produceBook();
        System.out.println("========================================");
        book = new XiaoMiBook();
        book.produceBook();
    }
}
// 定义一个抽象类
abstract class AbstractBook {
    public abstract void fillwithCpu();
    public abstract void fillwithGpu();
    public void produceBook() {
        fillwithCpu();
        fillwithGpu();
    }
}
// 定义具体实现类1
class MacBookPro extends AbstractBook {
    @Override
    public void fillwithCpu() {
        System.out.println("我是高端的MacBook Pro，我使用的是迄今为止地表最强的M2 MAX芯片，我可太快太牛逼了...");
    }
    @Override
    public void fillwithGpu() {
        System.out.println("我是高端的MacBook Pro，我使用的是迄今为止地表最强的M2 MAX GPU，对图形这块，我可是没输过...");
    }
}
// 定义具体实现类2
class XiaoMiBook extends AbstractBook {
    @Override
    public void fillwithCpu() {
        System.out.println("我是小米笔记本，我的CPU是还不错的13代英特尔酷睿i5处理器...");
    }
    @Override
    public void fillwithGpu() {
        System.out.println("我是小米笔记本，我的GPU是还不错的Geforce GTX3050Ti...");
    }
}

使用建造者模式

public class BuilderTest2 {
    public static void main(String[] args) {
        Book build = new BookBuilder().buildTotalPage(1).buildTotalWord(2).build();
        System.out.println(build);
        Book build2 = new BookBuilder().buildTotalPage(3).buildTotalWord(4).build();
        System.out.println(build2);
    }
}

class Book{
    private Integer totalPage;
    private Integer totalWord;
    public Book(){
    }
    public Book(BookBuilder builder){
        this.totalPage = builder.totalPage;
        this.totalWord = builder.totalWord;
    }
    public String toString(){
        return "Book[totalPage="+this.totalPage+",totalWord="+this.totalWord+"]";
    }
}
final class BookBuilder{
    public Integer totalPage;
    public Integer totalWord;
    public BookBuilder buildTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
        return this;
    }
    public BookBuilder buildTotalWord(Integer totalWord) {
        this.totalWord = totalWord;
        return this;
    }
    public Book build(){
        return new Book(this);
    }
}

简化对象实现

public class BuilderTest {
    public static void main(String[] args) {
        Director director = new Director(new IphoneBuilder());
        MobilePhone construct = director.construct();
        System.out.println(construct);

        Director director1 = new Director(new SanXinBuilder());
        MobilePhone construct1 = director1.construct();
        System.out.println(construct1);
    }
}

@Getter
@Setter
class MobilePhone{
    private String name;
    private String cpu;
    private String screen;
    public MobilePhone(){}
    @Override
    public String toString(){
        return this.name+"-"+this.cpu+"-"+this.screen;
    }
}
// 定义builder接口
abstract class Builder {
    public static final MobilePhone mobilePhone = new MobilePhone();
    private String name;
    private String cpu;
    private String screen;
    abstract void buildName();
    abstract void buildCpu();
    abstract void buildScreen();
    public MobilePhone createPhone(){
        return mobilePhone;
    }
}
class IphoneBuilder extends Builder{

    @Override
    public void buildName() {
        mobilePhone.setName("iphoneName");
    }

    @Override
    public void buildCpu() {
        mobilePhone.setCpu("iphoneCpu");
    }

    @Override
    public void buildScreen() {
        mobilePhone.setScreen("iphoneScreen");
    }

    @Override
    public MobilePhone createPhone() {
        return mobilePhone;
    }
}
class SanXinBuilder extends Builder{

    @Override
    public void buildName() {
        mobilePhone.setName("三星1.0");
    }

    @Override
    public void buildCpu() {
        mobilePhone.setCpu("三星8G");
    }

    @Override
    public void buildScreen() {
        mobilePhone.setScreen("三星56寸");
    }

    @Override
    public MobilePhone createPhone() {
        return mobilePhone;
    }
}
// 创建Director 通过有参构造器注入一个具体的builder，在核心方法construct方法完成各个组件的具体组装，并返回最后组装出来的对象
class Director{
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public MobilePhone construct(){
        builder.buildName();
        builder.buildCpu();
        builder.buildScreen();
        return builder.createPhone();
    }
}