谈谈我对Builder建造者模式的想法

首先，我们先看Builder建造者模式的UML图！！！

对着别人代码也敲了下，我们先来看看，也许你也会有点感触。

对着上面的UML图，我们可以对着敲出以下代码：

public class MacBook extends Computer {

    protected MacBook() {
    }

    @Override
    public void setmOs() {

    }
}

abstract class Computer {
    protected String mBorad;
    protected String mDisplay;
    protected String mOs;

    public Computer() {
    }

    public void setmBorad(String mBorad) {
        this.mBorad = mBorad;
    }

    public void setmDisplay(String mDisplay) {
        this.mDisplay = mDisplay;
    }

    public abstract void setmOs();

    @Override
    public String toString() {
        return "Computer{" +
                "mBorad='" + mBorad + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOs='" + mOs + '\'' +
                '}';
    }
}

abstract class Builder {
    public abstract void buildBroad(String broad);

    public abstract void buildDisplay(String display);

    public abstract void buildOs();

    public abstract Computer create();
}

class MacBookBuilder extends Builder {
    private Computer mcomputer = new MacBook();

    @Override
    public void buildBroad(String broad) {
        mcomputer.setmBorad(broad);
    }

    @Override
    public void buildDisplay(String display) {
        mcomputer.setmDisplay(display);
    }

    @Override
    public void buildOs() {
        mcomputer.setmOs();
    }

    @Override
    public Computer create() {
        return mcomputer;
    }
}

class Director {
    Builder builder = null;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct(String broad, String dispaly) {
        builder.buildBroad(broad);
        builder.buildDisplay(dispaly);
        builder.buildOs();
    }

}

上面我们对着UML敲了个例子，但是我们知道接口和抽象类实际的效果是一样的都是解耦

我们又可以这样写！

代码如下：

public class MacBook implements Computer {
    private String Borad;
    private String Display;
    private String Os;

    protected MacBook() {
    }

    @Override
    public void setmBorad(String Borad) {
        this.Borad = Borad;
    }

    @Override
    public void setmDisplay(String Display) {
        this.Display = Display;
    }

    @Override
    public void setmOs() {
    }
}

interface Computer {
    void setmBorad(String Borad);

    void setmDisplay(String Display);

    void setmOs();
}

interface Builder {
    void buildBroad(String broad);

    void buildDisplay(String display);

    void buildOs();

    Computer create();
}

class MacBookBuilder implements Builder {
    private Computer mcomputer = new MacBook();

    @Override
    public void buildBroad(String broad) {
        mcomputer.setmBorad(broad);
    }

    @Override
    public void buildDisplay(String display) {
        mcomputer.setmDisplay(display);
    }

    @Override
    public void buildOs() {
        mcomputer.setmOs();
    }

    @Override
    public Computer create() {
        return mcomputer;
    }
}

class Director {
    Builder builder = null;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct(String broad, String dispaly) {
        builder.buildBroad(broad);
        builder.buildDisplay(dispaly);
        builder.buildOs();
    }

}

用接口和抽象类，总感觉有点不舒服，看起来不是那么直观，记得alertdialog是一段.set(),链式的结构。

那我们模仿alertdialog写写，我的感触是他并没有像UML那样划分的很细致。

如果我们把接口和抽象类全部去掉，代码会是怎么样？

代码如下：

public class MacBook   {
    private String Borad;
    private String Display;
    private String Os;

    protected MacBook() {
    }
    public void setmBorad(String Borad) {
        this.Borad = Borad;
    }
    public void setmDisplay(String Display) {
        this.Display = Display;
    }
    public void setmOs() {
    }
}

class MacBookBuilder  {
    private MacBook mcomputer = new MacBook();
    public void buildBroad(String broad) {
        mcomputer.setmBorad(broad);
    }
    public void buildDisplay(String display) {
        mcomputer.setmDisplay(display);
    }
    public void buildOs() {
        mcomputer.setmOs();
    }
    public MacBook create() {
        return mcomputer;
    }
}
class Director {
    MacBookBuilder builder = null;

    public Director(MacBookBuilder builder) {
        this.builder = builder;
    }
    public void construct(String broad, String dispaly) {
        builder.buildBroad(broad);
        builder.buildDisplay(dispaly);
        builder.buildOs();
    }
}

咦，貌似有那么点意思了。

最后有个类Director,用的好像就是一段set的链式结构

模仿AlertDialog它有两种生成对象的方式：

1.Builder

它是通过类似链式结构的形式创建

2.alertdialog对象

它是通过类似创建类对象的形式创建

OK,思路：1.我们就可以把Director这个导向类，放入类中，2.Builder中创建类对象返回对象3.通过各自的构造函数传递值

我们试一试！

public class MacBook   {
     String Borad;
     String Display;
     String Os;
    MacBookBuilder builder = new MacBookBuilder(this);
    protected MacBook(MacBookBuilder builder) {
        this.Borad=builder.Borad;
        this.Display=builder.Display;
        this.Os=builder.Os;
    }
    public void setmBorad(String Borad) {
        this.Borad = Borad;
    }
    public void setmDisplay(String Display) {
        this.Display = Display;
    }
    public void setmOs() {
    }
    public void construct(String broad, String dispaly) {
        builder.buildBroad(broad);
        builder.buildDisplay(dispaly);
        builder.buildOs();
    }
}

class MacBookBuilder  {
     String Borad;
     String Display;
     String Os;
    MacBookBuilder(MacBook macBook){

    }
    MacBook macBook = new MacBook(this);
    public MacBookBuilder buildBroad(String broad) {
        macBook.setmBorad(broad);
        return this;
    }
    public MacBookBuilder buildDisplay(String display) {
        macBook.setmDisplay(display);
        return this;
    }
    public MacBookBuilder buildOs() {
        macBook.setmOs();
        return this;
    }
    public MacBook create() {
        return macBook;
    }
}

虽然，我不是处女座。就像卖牛奶的广告一样 没有最好，只有更好

我们需要加工下！！！

代码如下：

public class MacBook   {
     String Borad;
     String Display;
     String Os;

    protected MacBook(MacBookBuilder builder) {
        this.Borad=builder.Borad;
        this.Display=builder.Display;
        this.Os=builder.Os;
    }
    public String setmBorad(String Borad) {
        this.Borad = Borad;
        return Borad;
    }
    public String setmDisplay(String Display) {
        this.Display = Display;
        return Display;
    }
    public String setmOs() {
        this.Os="ubuntu";
        return Os;
    }
    public MacBookBuilder construct() {
        return new MacBookBuilder(this);
    }
}

class MacBookBuilder  {
     String Borad;
     String Display;
     String Os;
    MacBookBuilder(MacBook macBook){
        this.Borad=macBook.Borad;
        this.Display=macBook.Display;
        this.Os=macBook.Os;
    }
    public MacBookBuilder buildBroad(String broad) {
        this.Borad = broad;
        return this;
    }
    public MacBookBuilder buildDisplay(String display) {
        this.Display = display;
        return this;
    }
    public MacBookBuilder buildOs() {
        this.Os = "";
        return this;
    }
    public MacBook create() {
        return new MacBook(this);
    }
}

再次更好！

代码：

public class MacBook {
    String Borad;
    String Display;
    String Os;

    protected MacBook(MacBookBuilder builder) {
        this.Borad = builder.Borad;
        this.Display = builder.Display;
        this.Os = builder.Os;
    }

    public String setmBorad(String Borad) {
        this.Borad = Borad;
        return Borad;
    }

    public String setmDisplay(String Display) {
        this.Display = Display;
        return Display;
    }

    public String setmOs() {
        this.Os = "ubuntu";
        return Os;
    }

    public MacBookBuilder construct() {
        return new MacBookBuilder(this);
    }

    static class MacBookBuilder {
        String Borad;
        String Display;
        String Os;

        MacBookBuilder(MacBook macBook) {
            this.Borad = macBook.Borad;
            this.Display = macBook.Display;
            this.Os = macBook.Os;
        }

        public MacBookBuilder buildBroad(String broad) {
            this.Borad = broad;
            return this;
        }

        public MacBookBuilder buildDisplay(String display) {
            this.Display = display;
            return this;
        }

        public MacBookBuilder buildOs() {
            this.Os = "";
            return this;
        }

        public MacBook create() {
            return new MacBook(this);
        }
    }
}

总结：

1.在什么时候使用建造者模式？

就比如android上创建订单，类的字段比较多

2.建造者模式有什么好处？

我认为是更好的展现多态吧。用链式的set对对象字段设置，我想要什么特性就有什么特性。

3.那怎么创建自己的建造者模式？

我自己想了个想法。我要在一片空地造房子，我可以自己买材料装修，也能自己包给别人来做。（小弟不才，忘大佬们指点指点。）