建造者模式

时间：2019-08-13 14:46:53 阅读：68 评论：0 收藏：0 [点我收藏+]

1 定义域特征

定义：将一个复杂的对象构建与其表示分离，使得同样的构建过程可以创建不同的表示。特征：用户只需要指定需要建造的类型即可，对于中间的细节不考虑。

2 代码实现及分析

course类：

//课程类
public class Course {

    private String courseName;
    private String coursePPT;
    private String courseVideo;
    //笔记
    private String courseArticle;
    //question & answer
    private String courseQA;

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getCoursePPT() {
        return coursePPT;
    }

    public void setCoursePPT(String coursePPT) {
        this.coursePPT = coursePPT;
    }

    public String getCourseVideo() {
        return courseVideo;
    }

    public void setCourseVideo(String courseVideo) {
        this.courseVideo = courseVideo;
    }

    public String getCourseArticle() {
        return courseArticle;
    }

    public void setCourseArticle(String courseArticle) {
        this.courseArticle = courseArticle;
    }

    public String getCourseQA() {
        return courseQA;
    }

    public void setCourseQA(String courseQA) {
        this.courseQA = courseQA;
    }

    @Override
    public String toString() {
        return "Course{" +
                "courseName=‘" + courseName + ‘\‘‘ +
                ", coursePPT=‘" + coursePPT + ‘\‘‘ +
                ", courseVideo=‘" + courseVideo + ‘\‘‘ +
                ", courseArticle=‘" + courseArticle + ‘\‘‘ +
                ", courseQA=‘" + courseQA + ‘\‘‘ +
                ‘}‘;
    }
}

CourserBuilder：抽象的课程建造者

/**
 * 课程建造者
 */
public abstract class CourseBuilder {

    public abstract void buildCourseName(String courseName);
    public abstract void buildCoursePPT(String coursePPT);
    public abstract void buildCourseVideo(String courseVideo);
    public abstract void buildCourseArticle(String courseArticle);
    public abstract void buildCourseQA(String courseQA);
    //制作一个课程
    public abstract Course makeCourse();

}

CourserActualBuilder：

/**
 * 课程的真实构建类
 */
public class CourseActualBuilder extends CourseBuilder {

    private Course course = new Course();

    @Override
    public void buildCourseName(String courseName) {
        course.setCourseName(courseName);
    }

    @Override
    public void buildCoursePPT(String coursePPT) {
        course.setCoursePPT(coursePPT);
    }

    @Override
    public void buildCourseVideo(String courseVideo) {
        course.setCourseVideo(courseVideo);
    }

    @Override
    public void buildCourseArticle(String courseArticle) {
        course.setCourseArticle(courseArticle);
    }

    @Override
    public void buildCourseQA(String courseQA) {
        course.setCourseQA(courseQA);
    }

    @Override
    public Course makeCourse() {
        return course;
    }
}

Coach：辅助类

/**
 * 课程教练，通过接收到的课程信息来构建课程。
 */
public class Coach {

    private CourseBuilder courseBuilder;

    //set方式注入
    public void setCourseBuilder(CourseBuilder courseBuilder) {
        this.courseBuilder = courseBuilder;
    }

    //根据接收到的课程的信息制作课程。
    public Course makeCourse(String courseName,String coursePPT,
                             String courseVideo,String courseArticle,
                             String courseQA){
        this.courseBuilder.buildCourseName(courseName);
        this.courseBuilder.buildCoursePPT(coursePPT);
        this.courseBuilder.buildCourseVideo(courseVideo);
        this.courseBuilder.buildCourseArticle(courseArticle);
        this.courseBuilder.buildCourseQA(courseQA);
        return this.courseBuilder.makeCourse();
    }
}

Test类：应用层

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        //多态父类引用子类实现
        CourseBuilder courseBuilder = new CourseActualBuilder();
        Coach coach = new Coach();
        //在coach中注入courseBuilder
        coach.setCourseBuilder(courseBuilder);

        Course course = coach.makeCourse("Java设计模式精讲", "Java设计模式精讲PPT", "Java设计模式精讲视频",
                                          "Java设计模式精讲手记","Java设计模式精讲问答");
        
        System.out.println(course);

    }
}

在应用层中通过向coach传递参数来构建一个具体的对象，coach和CourserBuilder为组合的关系，1对1。CourserActualBuilder与Course同样为组合的1对1关系，其类图关系如下图所示。

技术分享图片

3 优化

对于上面的代码，coach不是必须的可以让应用层直接控制，采用静态内部类进行改善。

Course类：

public class Course {

    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;
    //question & answer
    private String courseQA;

    //这里的CourseBuilder就是静态内部类返回的对象
    public Course(CourseBuilder courseBuilder) {
        this.courseName = courseBuilder.courseName;
        this.coursePPT = courseBuilder.coursePPT;
        this.courseVideo = courseBuilder.courseVideo;
        this.courseArticle = courseBuilder.courseArticle;
        this.courseQA = courseBuilder.courseQA;
    }

    //采用静态内部类创建Course对象
    public static class CourseBuilder{
        private String courseName;
        private String coursePPT;
        private String courseVideo;
        private String courseArticle;
        //question & answer
        private String courseQA;

        //返回对象本身可以让应用层链式调用
        public CourseBuilder buildCourseName(String courseName){
            this.courseName = courseName;
            return this;
        }


        public CourseBuilder buildCoursePPT(String coursePPT) {
            this.coursePPT = coursePPT;
            return this;
        }

        public CourseBuilder buildCourseVideo(String courseVideo) {
            this.courseVideo = courseVideo;
            return this;
        }

        public CourseBuilder buildCourseArticle(String courseArticle) {
            this.courseArticle = courseArticle;
            return this;
        }

        public CourseBuilder buildCourseQA(String courseQA) {
            this.courseQA = courseQA;
            return this;
        }

        public Course build(){
            return new Course(this);
        }
    }

    @Override
    public String toString() {
        return "Course{" +
                "courseName=‘" + courseName + ‘\‘‘ +
                ", coursePPT=‘" + coursePPT + ‘\‘‘ +
                ", courseVideo=‘" + courseVideo + ‘\‘‘ +
                ", courseArticle=‘" + courseArticle + ‘\‘‘ +
                ", courseQA=‘" + courseQA + ‘\‘‘ +
                ‘}‘;
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
        //链式调用
        Course course = new Course.CourseBuilder().buildCourseName("Java设计模式精讲").buildCoursePPT("Java设计模式精讲PPT").buildCourseVideo("Java设计模式精讲视频").build();
        System.out.println(course);
    }
}

这样其类比上部分要简化很多，其关系图如下：

技术分享图片

4 源码分析

（1）JDK源码

StringBuilder类中的append方法：

public StringBuilder append(StringBuffer sb) {
    super.append(sb);
    return this;
}

@Override
 public StringBuilder append(CharSequence s) {
     super.append(s);
     return this;
 }

可以看出与优化部分的代码类似StringBuilder在建造时没有采用过多的抽象而是采用链式方法直接进行修改。同样的还有StringBuffer，加了关键字synchronized保证了其线程安全

@Override
public synchronized StringBuffer append(Object obj) {
     toStringCache = null;
     super.append(String.valueOf(obj));
     return this;
}

@Override
public synchronized StringBuffer append(String str) {
     toStringCache = null;
     super.append(str);
     return this;
}

建造者模式

原文：https://www.cnblogs.com/youngao/p/11345708.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)