建造者模式

一、定义

创建型设计模式
将复杂对象的构建与表示分离，使得同样的构建过程可以有不同的表示
用户只需要指定建造的类型就可以的到（需要将构建的组件传入），不需要知道建造的细节

二、代码

//要创建的课程对象
public class Course {
   //为了方便，我们属性都使用String类型
    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;

    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;
    }

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

//抽象的courseBuilder
public abstract class CourseBuilder {
    //设置course属性
    public abstract void buildCourseName(String courseName);
    public abstract void buildCoursePPT(String coursePPT);
    public abstract void buildCourseVideo(String courseVideo);
    public abstract void buildCourseArticle(String courseArticle);
    //返回course对象
    public abstract Course makeCourse();
}

//实际上创建course的builder实现类
public class CourseActuallyBuilder 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 Course makeCourse() {
        return course;
    }
}

//下达命令的coach类
public class Coach {
   //这里注入的是builder的抽象类，我们就可以根据客户端传的builder不同而创建不同的对象
    private CourseBuilder courseBuilder;
    public void setCourseBuilder(CourseBuilder courseBuilder) {
        this.courseBuilder = courseBuilder;
    }
//创建course
    public Course makeCourse(String courseName, String coursePPT, String courseVideo, String couresArticle) {
        courseBuilder.buildCourseName(courseName);
        courseBuilder.buildCoursePPT(coursePPT);
        courseBuilder.buildCourseVideo(courseVideo);
        courseBuilder.buildCourseArticle(couresArticle);
        return courseBuilder.makeCourse();
    }
}

//test测试类（客户端）
public class Test {
    public static void main(String[] args) {
        Coach coach = new Coach();
        coach.setCourseBuilder(new CourseActuallyBuilder());
        Course course = coach.makeCourse("Java设计模式","Java设计模式PPT",
                "Java设计模式视频","Java设计模式手记");
        System.out.println(course);
    }
}

进阶版的建造者模式
演进版的建造者模式，把对象的建造者写在内部类，在测试类使用链式调用，再调用build就可以拿到想要的对象，简化类调用，也极大的避免了因为给coach传错建造者而创造对象错误的情况。
这种写法在开发中会比较常用

public class Course {
    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;

    public Course(CourseBuilder courseBuilder) {
        this.courseName = courseBuilder.courseName;
        this.coursePPT = courseBuilder.coursePPT;
        this.courseVideo = courseBuilder.courseVideo;
        this.courseArticle = courseBuilder.courseArticle;
    }

    @Override
    public String toString() {
        return "Course{" +
                "courseName='" + courseName + '\'' +
                ", coursePPT='" + coursePPT + '\'' +
                ", courseVideo='" + courseVideo + '\'' +
                ", courseArticle='" + courseArticle + '\'' +
                '}';
    }
    //定义一个内部类--建造者
    public static class CourseBuilder{
        //和产品相同的属性
        private String courseName;
        private String coursePPT;
        private String courseVideo;
        private String courseArticle;
        //为了可以链式调用，需要将当前对象返回
        public CourseBuilder buildeCourseName(String courseName){
            this.courseName = courseName;
            return this;
        }
        public CourseBuilder buildeCoursePPT(String coursePPT){
            this.coursePPT = coursePPT;
            return this;
        }
        public CourseBuilder buildeCourseVideo(String courseVideo){
            this.courseVideo = courseVideo;
            return this;
        }
        public CourseBuilder buildeCourseArticle(String courseArticle){
            this.courseArticle = courseArticle;
            return this;
        }
        //调用Course的构造器，并将当前builder的值传进
        public Course build(){
            return new Course(this);
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Course course = new Course.CourseBuilder().buildeCourseName("java设计模式")
                .buildeCoursePPT("java设计模式PPT").buildeCourseVideo("java设计模式视频").build();
        System.out.println(course);
    }
}

三、适用场景

1、如果一个对象有非常多的内部结构，属性比较多的时候
2、想把对象的创建和适用进行分离

优点：
1、封装性好，创建和使用分离。
2、扩展性好，建造类之间相互独立，一定程度上解耦。
缺点：
1、会建造多余的builder对象
2、 产品内部结构发生变化，建造者都需要修改，改动根据业务或大或小，成本比较高