建造者模式将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示，属于创建型设计模式
对于用户而言，使用建造者模式只需指定需要创建的类型就可以获得对象，创建过程及细节不需要了解。根据建造者模式的定义，可以简单的理解为两层含义。
构建与表示分离：构建代表对象创建，表示代表对象行为，方法。也就是将对象的创建与行为进行分离（对应到java代码，其实就是使用接口规定行为，然后由具体的实体类进行构建）
创建不同表示：也就是具备同样的行为，但是却由于构建的行为顺序不同或其他原因可以创建出不同的表示
从定义来看，建造者模式和工厂模式是非常相似的，和工厂模式一样，具备创建与表示分离的特性。建造者模式唯一区别与工厂模式的是针对复杂对象的创建，也就是说，如果创建简单对象，通常使用工厂模式进行创建，而如果复杂的对象，就可以考虑使用建造者模式。
当需要创建产品具备复杂创建过程时，可以抽取出共性创建过程，然后交由具体实现类自定义创建流程，使得同样的创建行为可以生产出不同的产品，分离了创建与表示，是创建产品的灵活性大大增加，建造者模式主要用于以下场景
相同的方法，不同的执行顺序，产生不同的结果
多个部件或零件，都可以装配到一个对象中，但是产生的结果有不相同
产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用
初始化一个对象特别复杂，参数多，而且很多参数都具有默认值
右上图可以看到，建造者模式主要包含四个角色
产品（Product）：要创建产品类对象
抽象建造者（IBuilder）：建造者的抽象类，规范产品对象的各个组成部分的创建，一般由子类实现具体的创建过程
建造者（ConcreteBuilder）：具体的Builder类，根据不同的业务逻辑，具体化对象的各个组成部分的创建
调用者（Director）：调用具体的建造者，来创建对象的各个部分，在指导者中不涉及具体产品的信息，自负责保证对象各部分完整创建或者按照某种顺序创建。在类图中，相当于client的角色
package com.design.pattern.builder;
public class Client {
public static void main(String[] args) {
IBuilder builder = new ConcreteBuilder();
System.out.println(builder.build());
}
}
package com.design.pattern.builder;
public class ConcreteBuilder implements IBuilder{
public Product product = new Product();
@Override
public Product build() {
return product;
}
}
package com.design.pattern.builder;
public interface IBuilder {
Product build();
}
package com.design.pattern.builder;
public class Product {
public String name;
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
'}';
}
}以课程为例，一个完整的课程有PPT课件，回放视频，课堂笔记，课后作业组成，但是这些内容的设置顺序可以随意调整，我们用建造者模式来带入理解一下。首先创建一个产品类Course
package com.design.pattern.builder;
import lombok.Data;
@Data
public class Course {
private String name;
private String ppt;
private String videos;
private String note;
private String homework;
@Override
public String toString() {
return "Course{" +
"name='" + name + '\'' +
", ppt='" + ppt + '\'' +
", videos='" + videos + '\'' +
", note='" + note + '\'' +
", homework='" + homework + '\'' +
'}';
}
}然后创建建造者类CourseBuilder，将复杂的创建过程封装起来，创建步骤由用户决定
package com.design.pattern.builder;
public class CourseBuilder {
private Course course = new Course();
public CourseBuilder addName(String name){
course.setName(name);
return this;
}
public CourseBuilder addPpt(String ppt){
course.setPpt(ppt);
return this;
}
public CourseBuilder addVideo(String video){
course.setVideos(video);
return this;
}
public CourseBuilder addNote(String note){
course.setNote(note);
return this;
}
public CourseBuilder addHomeWork(String homeWork){
course.setHomework(homeWork);
return this;
}
public Course builder(){
return course;
}
}最后编写客户端测试代码：
package com.design.pattern.builder;
public class BuilderTest {
public static void main(String[] args) {
CourseBuilder courseBuilder = new CourseBuilder().addName("设计模式")
.addNote("note")
.addPpt("ppt")
.addVideo("video")
.addHomeWork("homeWork");
System.out.println(courseBuilder.builder());
}
}一般情况下，我们更习惯使用静态内部类的方式实现建造者模式，即一个产品类内部自动带有一个具体建造者，由它负责该产品的组装创建，不再需要Builder和director，这样产品表示与创建之间的联系更加紧密，结构更加紧凑，同时是的建造者模式的形式更加简洁
使用静态内部类的方式，前面的案例可以改写为：
package com.design.pattern.builder;
public class Course2 {
private String name;
private String ppt;
private String videos;
private String note;
private String homework;
@Override
public String toString() {
return "Course{" +
"name='" + name + '\'' +
", ppt='" + ppt + '\'' +
", videos='" + videos + '\'' +
", note='" + note + '\'' +
", homework='" + homework + '\'' +
'}';
}
public static class Builder{
private Course course = new Course();
public Builder addName(String name){
course.setName(name);
return this;
}
public Builder addPpt(String ppt){
course.setPpt(ppt);
return this;
}
public Builder addVideo(String video){
course.setVideos(video);
return this;
}
public Builder addNote(String note){
course.setNote(note);
return this;
}
public Builder addHomeWork(String homeWork){
course.setHomework(homeWork);
return this;
}
public Course builder(){
return course;
}
}
}客户端测试代码：
package com.design.pattern.builder;
public class StaticBuilderTest {
public static void main(String[] args) {
Course builder = new Course2.Builder().addName("设计模式")
.addNote("note")
.addPpt("ppt")
.addVideo("video")
.addHomeWork("homeWork")
.builder();
System.out.println(builder);
}
}这样代码看上去更加简洁，不会让人感觉到多了一个类
建造者模式更注重方法的调用顺序，工厂模式更注重创建对象
创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的对象都一样
关注重点不一样，工厂模式只需要把对象创建出来就可以了，而建造者模式不仅要创建出对象，还要知道对象由哪些部件组成
建造者模式根绝建造过程中的顺序不一样，最终的对象部件组成也不一样
封装性好，构建和表示分离
扩展性好，建造类之间独立，在一定程度上接偶
便于控制细节，建造者可以对创建过程逐步细化，而不对其他模块产生任何影响
需要多创建一个Builder对象
如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大