Java设计模式-建造者模式

概念

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

角色说明

Product 产品类 : 具体产品类。
Builder : 抽象接口类， 规范产品的组建。
ConcreteBuilder : 具体的建造者，实现Builder接口，构造和装配各个部件。.
Director : 指挥着，构建一个使用Builde接口的对象。

实例

具体产品（product）

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   : 具体产品类
 *     version: 1.0
 * </pre>
 */
public class Computer {
    public void setCpuCore(String partCore) {
        Log.e("打印电脑cpu核数--->", partCore);
    }

    public void setRamSize(String partSize) {
        Log.e("打印电脑内存大小--->", partSize);
    }
}

建造者（builder）接口

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   :建造者类接口
 *     version: 1.0
 * </pre>
 */
public interface IComputerBuilder {
    /**
     * cpu核数
     */
    void BuilderCpuCore();

    /**
     * 内存大小
     */
    void BuilderRamSize();
}

具体的建造者类

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   : 具体的建造者类1
 *     version: 1.0
 * </pre>
 */
public class ConcreateBuilder1 implements IComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void BuilderCpuCore() {
        computer.setCpuCore("4");
    }

    @Override
    public void BuilderRamSize() {
        computer.setRamSize("2");

    }
}

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   : 具体的建造者类2
 *     version: 1.0
 * </pre>
 */
public class ConcreateBuilder2 implements IComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void BuilderCpuCore() {
        computer.setCpuCore("8");
    }

    @Override
    public void BuilderRamSize() {
        computer.setRamSize("4");

    }
}

指挥着（Director）

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   : 指挥着，构建使用builder接口对象
 *     version: 1.0
 * </pre>
 */
public class Director {
    public void Construct(IComputerBuilder builder) {
        builder.BuilderCpuCore();
        builder.BuilderRamSize();
    }
}

测试代码

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   : 测试类
 *     version: 1.0
 * </pre>
 */
public class TestMain {
    public void Test() {
        Director director = new Director();
        IComputerBuilder b1 = new ConcreateBuilder1();
        IComputerBuilder b2 = new ConcreateBuilder2();
        director.Construct(b1);
        director.Construct(b2);
    }

}

链式builder模式

/**
 * <pre>
 *     author : duyb
 *     time   : 2017/10/17
 *     desc   :链式建造者
 *     version: 1.0
 * </pre>
 */
public class Student {
    //final修饰：必须在构造中初始化
    private final int stuId;//必须
    private final String name;//必须
    private final int age;//可选
    private final int gender;//可选
    private final String address;//可选

    //注意：此处构造私有
    private Student(StudentBuilder builder) {
        this.stuId = builder.stuId;
        this.name = builder.name;
        this.age = builder.age;
        this.gender = builder.gender;
        this.address = builder.address;
    }

    //此处省略各get方法（只提供get方法）.....

    public static class StudentBuilder {
        private final int stuId;
        private final String name;
        private int age;
        private int gender;
        private String address;

        //必填属性
        public StudentBuilder(int stuId, String name) {
            this.stuId = stuId;
            this.name = name;
        }

        public StudentBuilder setAge(int age) {
            this.age = age;
            return this;
        }

        public StudentBuilder setGender(int gender) {
            this.gender = gender;
            return this;
        }

        public StudentBuilder setAddress(String address) {
            this.address = address;
            return this;
        }

        //结束方法
        public Student build() {
            return new Student(this);
        }
    }
}

public class TestMain {
    public Student Test() {
       return new Student.StudentBuilder(1,"duyb")
               .setAge(25)
               .setAddress("中国.北京")
               .build();
    }

}

分析：

return new Student.StudentBuilder(1,”duyb”)
.setAge(25)
.setAddress(“中国.北京”)
.build();
—————————————
.build()返回student实例， 调用Student构造：
private Student(StudentBuilder builder) {
this.stuId = builder.stuId;
this.name = builder.name;
this.age = builder.age;
this.gender = builder.gender;
this.address = builder.address;
}，而Student(StudentBuilder builder)的参数是StudentBuilder 实例，故在调用.build()之前通过调用StudentBuilder 的构造Student.StudentBuilder(1,”duyb”)来初始化参数。

小结

使用场景：
相同的方法，不同的执行顺序，产生不同的执行效果
一个对象可以配置多个不同的零件，产生不同的效果
一个对象，参数方法极多，调用顺序不同则效果不同

参考
http://blog.csdn.net/nugongahou110/article/details/50395698