9、建造者模式-两款手机的生产过程

建造者模式（Builder）：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。

UML图：

package com.thpin.repository.designpattern;

public class BuilderDemo {
    public static void main(String[] args) {
        Director director = new Director();
        PhoneBuilder iPhoneBuilder = new IPhoneBuilder();
        PhoneBuilder samsungBuilder = new SamsungBuilder();
        director.construct(iPhoneBuilder);
        director.construct(samsungBuilder);
        Phone iPhone = iPhoneBuilder.build();
        Phone samsung = samsungBuilder.build();
        System.out.println(iPhone);
        System.out.println(samsung);
    }
}

/*
 * 手机产品
 */
class Phone {
    private String mainboard;
    private String screen;
    private String backCover;
    private String camera;

    public String getMainboard() {
        return mainboard;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }

    public String getScreen() {
        return screen;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }

    public String getBackCover() {
        return backCover;
    }

    public void setBackCover(String backCover) {
        this.backCover = backCover;
    }

    public String getCamera() {
        return camera;
    }

    public void setCamera(String camera) {
        this.camera = camera;
    }

    public String toString() {
        return "Phone [mainboard=" + mainboard + ", screen=" + screen + ", backCover=" + backCover + ", camera="
                + camera + "]";
    }
}

/*
 * 手机建造者接口
 */
interface PhoneBuilder {

    void buildMainboard();

    void buildScreen();

    void buildBackCover();

    void buildCamera();
    
    Phone build();
}

/*
 * iphone手机建造者
 */
class IPhoneBuilder implements PhoneBuilder {
    
    private Phone phone = new Phone();
    
    public void buildMainboard() {
        phone.setMainboard("iPhone主板");
    }

    public void buildScreen() {
        phone.setScreen("iPhone屏幕");
    }

    public void buildBackCover() {
        phone.setBackCover("iPhone后盖");
    }

    public void buildCamera() {
        phone.setCamera("iPhone相机");
    }

    public Phone build() {
        return phone;
    }
}

/*
 * 三星手机建造者
 */
class SamsungBuilder implements PhoneBuilder {
    
    private Phone phone = new Phone();
    
    public void buildMainboard() {
        phone.setMainboard("Samsung主板");
    }

    public void buildScreen() {
        phone.setScreen("Samsung屏幕");
    }

    public void buildBackCover() {
        phone.setBackCover("Samsung后盖");
    }

    public void buildCamera() {
        phone.setCamera("Samsung相机");
    }

    public Phone build() {
        return phone;
    }
}

/*
 * 建造指导者
 */
class Director {
    public void construct(PhoneBuilder builder) {
        builder.buildMainboard();
        builder.buildScreen();
        builder.buildBackCover();
        builder.buildCamera();
    }
}

结果：

Phone [mainboard=iPhone主板, screen=iPhone屏幕, backCover=iPhone后盖, camera=iPhone相机]

Phone [mainboard=Samsung主板, screen=Samsung屏幕, backCover=Samsung后盖, camera=Samsung相机]

建造者模式在使用过程中可以演化出多种形式：

如果具体的被建造对象只有一个的话，可以省略抽象的Builder和Director，让ConcreteBuilder自己扮演指导者和建造者双重角色，甚至ConcreteBuilder也可以放到Product里面实现。

建造者模式主要用于创建一些复杂的对象，这些对象内部构建顺序通常是稳定的，但对象内通常面临着复杂的变化。

好处就是使得建造代码与标识代码分离，由于建造者隐藏了产品时如何组装的，所以如果要改变一个产品的内部表示，只需再定义一个建造者就可以了。

建造者模式是在创建复杂对象的算法应该独立于对象组成部分以及他们的装配方式时适用的模式。