java設計模式-Builder建造者模式

在實際開發(fā)過程中，我們可能遇到過這么一個問題：創(chuàng)建一個比較復雜的對象的時候，它有特別多的屬性，比如需要創(chuàng)建一個電腦對象，我們就需要設置例如主板、顯卡、內存、顯示器、鼠標、鍵盤等等一系列的值?？赡鼙容^常規(guī)的做法如下：

public class Computer {
    private String graphics;
    private String memory;
    private String cpu;
    private String os;
    
    public Computer(String graphics,String memory,String cpu,String os) {
        this.graphics = graphics;
        this.memory = memory;
        this.cpu = cpu;
        this.os = os;
    }
    
    public static void main(String[] args) {
        Computer c = new Computer("NVIDA 980","8G","I7","WINDOWS");
    }
}

看起來挺正常的。
但實際上我們要組建一臺電腦肯定不是這么簡單的，可能我們要先有一個主板，再按照順序將內存、顯卡、cpu、風扇等一些部件添加上去，然后是外設，最后還需要操作系統(tǒng)。
如何我們需要創(chuàng)建一個電腦對象，通過在構造方法里面?zhèn)鬟f參數(shù)肯定是不行的，既然這樣干脆加上setter方法吧。

public class Computer {
    private String board;
    private String cpu;
    private String memory;
    private String fan;
    private String os;

    public void setBoard(String board) {
        this.board = board;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setFan(String fan) {
        this.fan = fan;
    }

    public void setOs(String os) {
        this.os = os;
    }
}

但是這樣又有一個問題，我們創(chuàng)建電腦的時候需要指定一個順序，這又如何做呢？
所以使用builder模式能夠解決我們的問題。

Builder模式的類圖

builder.png

在builder模式中主要有4種角色：

  • Product類：產(chǎn)品抽象類。
  • Builder：抽象的Builder類，定義了產(chǎn)品的組建行為。
  • ConcreteBuilder：具體的builder實現(xiàn)類
  • Director：組建產(chǎn)品的過程

當我們需要創(chuàng)建的產(chǎn)品由多個部件組成的時候，不同的組建順序可能導致創(chuàng)建的產(chǎn)品不同，這時候使用builder模式是非常合適。
我們還是以創(chuàng)建電腦對象來說明builder模式是怎么使用的。

抽象產(chǎn)品類：

public abstract class Computer {

    private String board;
    private String cpu;
    private String memory;
    private String fan;
    private String os;

    public void setBoard(String board) {
        this.board = board;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setFan(String fan) {
        this.fan = fan;
    }

    public void setOs(String os) {
        this.os = os;
    }

    public abstract void open();

}

產(chǎn)品類：

public class MacComputer extends Computer {
    @Override
    public void open() {
        System.out.println("open IOS system");
    }
}

public class LenovoComputer extends Computer {

    @Override
    public void open() {
        System.out.println("open windows system");
    }
}

抽象build類：

public abstract class Builder {

    public abstract void buildBoard(String board);
    public abstract void buildMemory(String memory);
    public abstract void buildCPU(String cpu);
    public abstract void buildFan(String fan);
    public abstract void buildOs();
    public abstract Computer create();
}

具體build類：

public class MacBuilder extends Builder {
    Computer computer = new LenovoComputer();

    @Override
    public void buildBoard(String board) {
        computer.setBoard(board);
    }

    @Override
    public void buildMemory(String memory) {
        computer.setMemory(memory);
    }

    @Override
    public void buildCPU(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildFan(String fan) {
        computer.setFan(fan);
    }

    @Override
    public void buildOs() {
        computer.setOs("IOS");
    }

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

public class LenovoBuilder extends Builder {
    Computer computer = new LenovoComputer();

    @Override
    public void buildBoard(String board) {
        computer.setBoard(board);
    }

    @Override
    public void buildMemory(String memory) {
        computer.setMemory(memory);
    }

    @Override
    public void buildCPU(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildFan(String fan) {
        computer.setFan(fan);
    }

    @Override
    public void buildOs() {
        computer.setOs("Windows");
    }

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

組建類：

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

    public void construct(String board,String cpu,String memory,String fan) {
        builder.buildBoard(board);
        builder.buildCPU(cpu);
        builder.buildMemory(memory);
        builder.buildFan(fan);
        builder.buildOs();
    }
}

測試類：

public class Test {
    public static void main(String[] args) {
        Builder lenovoBuilder = new LenovoBuilder();
        Director lenovoDirector = new Director(lenovoBuilder);
        lenovoDirector.construct("主板1","I7","8G","美的");
        Computer lenovoComputer = lenovoBuilder.create();

        Builder macBuilder = new MacBuilder();
        Director macDirector = new Director(macBuilder);
        macDirector.construct("主板2","I7","5G","奧克斯");
        Computer macComputer = macBuilder.create();

        lenovoComputer.open();
        macComputer.open();
    }
}

在實際開發(fā)中，builder模式也出現(xiàn)了一種變種寫法，builder同時容納了build類本身的功能和Director功能。我們將上面的代碼修改一下：

public class LenovoComputer extends Computer {

    @Override
    public void open() {
        System.out.println("open windows system");
    }

    public static class Builder{
        private String board;
        private String cpu;
        private String memory;
        private String fan;
        private String os;

        public Builder setBoard(String board) {
            this.board = board;
            return this;
        }

        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder setMemory(String memory) {
            this.memory = memory;
            return this;
        }

        public Builder setFan(String fan) {
            this.fan = fan;
            return this;
        }

        public Builder setOs(String os) {
            this.os = os;
            return this;
        }

        public Computer create() {
            Computer c = new LenovoComputer();
            c.setBoard(board);
            c.setMemory(memory);
            c.setCpu(cpu);
            c.setFan(fan);
            c.setOs(os);
            return c;
        }
    }
}

Builder以一個內部類的形式存在，產(chǎn)品的創(chuàng)建行為和創(chuàng)建過程都在builder中完成了，這種寫法方式相比標準的builder模式來說更加的簡潔了。

所以我們在開發(fā)的時候使用設計模式時需要靈活的變通，不要死死的按照標準的模式來開發(fā)。

?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容