喵星之旅-沉睡的猫咪-建造者模式

 

一、建造者是什么？

建造者模式是将一个复杂对象的构建过程与它的表示分离,使得同样的构建过程可以创建不同的表示,属于创建型模式。

使用建造者模式对于用户而言只需指定需要建造的类型就可以获得对象,建造过程及细节不需要了解。

它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

建造者模式主要包含下面四大角色：

1、产品角色：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个组成部件。

2、抽象建造者：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。

3、具体建造者：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

4、指挥者：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

 

二、java代码实现建造者

课程产品通过建造者实现如下（单一课程，如果多课程需要添加新的子类）：

产品角色：

 

package create.builder;
/**
 * 
 * @author bunny～～我是兔子我会喵，我叫喵星兔。
 *将被创建的对象
 */
public class Course {
    private String name;
    private String ppt;
    private String video;
    private String note;
    private String homework;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPpt() {
        return ppt;
    }

    public void setPpt(String ppt) {
        this.ppt = ppt;
    }

    public String getVideo() {
        return video;
    }

    public void setVideo(String video) {
        this.video = video;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getHomework() {
        return homework;
    }

    public void setHomework(String homework) {
        this.homework = homework;
    }

    @Override
    public String toString() {
        return "Course [name=" + name + ", ppt=" + ppt + ", video=" + video + ", note=" + note + ", homework="
                + homework + "]";
    }

}

 

 

 

抽象建造者：

 

package create.builder;
/**
 * 
 * @author bunny～～我是兔子我会喵，我叫喵星兔。
 *建造者抽象类
 */
public abstract class CourseBuilder {
    protected Course course = new Course();
    public abstract CourseBuilder buildName();
    public abstract CourseBuilder buildPpt();
    public abstract CourseBuilder buildVideo();
    public abstract CourseBuilder buildNote();
    public abstract CourseBuilder buildHomework();
    public Course getResult() {
        return course;
    }
}

 

 

 

具体建造者：

package create.builder;
/**
 * 
 * @author bunny～～我是兔子我会喵，我叫喵星兔。
 *具体建造者，涉及具体组件的实现
 */
public class JavaCourseBuilder extends CourseBuilder {

    @Override
    public CourseBuilder buildName() {
        course.setName("java");
        return this;
    }

    @Override
    public CourseBuilder buildPpt() {
        course.setPpt("java ppt");
        return this;
    }

    @Override
    public CourseBuilder buildVideo() {
        course.setVideo("java video");
        return this;
    }

    @Override
    public CourseBuilder buildNote() {
        course.setNote("java note");
        return this;
    }

    @Override
    public CourseBuilder buildHomework() {
        course.setHomework("homework");
        return this;
    }

}

 

指挥者：

package create.builder;
/**
 * 
 * @author bunny～～我是兔子我会喵，我叫喵星兔。
 *调度者，不关心具体内容，只关心流程
 */
public class CourseDirector {
    private CourseBuilder builder;

    public CourseDirector(CourseBuilder builder) {
        super();
        this.builder = builder;
    }

    public Course construct() {
        builder.buildHomework().buildName().buildNote().buildPpt().buildVideo();
        return builder.getResult();
    }

}

测试类：

package create.builder;
/**
 * 
 * @author bunny～～我是兔子我会喵，我叫喵星兔。
 *
 */
public class Test {

    public static void main(String[] args) {
        CourseBuilder b = new JavaCourseBuilder();
        CourseDirector d = new CourseDirector(b);
        Course c = d.construct();
        System.out.println(c);
    }

}

 

三、总结

建造者模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定。

建造者模式适用于创建对象需要很多步骤,但是步骤的顺序不一定固定。创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化。产品的构建过程和最终的表示是独立的。

建造者的实现类也是多种选择，否则不需要接口。

其使用就像测试类展示的，先创建建造者实例，然后交给指挥调度着。

建造者也可以参考jdk中的例子，所以也可以由链式调用的实现。参看StringBuilder的使用。

建造者（Builder）模式和工厂模式很像，但是关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。建造者模式创建复杂的对象,由各种复杂的部件组成,工厂模式创建出来的都一样。建造者模式根据建造过程中的顺序不一样,最终的对象部件组成也不一样。