5分钟理解建造者模式【简单使用方式】

1. 建造者模式理解

   可以从字面理解，如建造一栋房屋需要一块块砖累积而成，同理，建造者模式也是基于一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。
   专业定义：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示

2. 为什么要使用建造者模式

   比如：一个复杂对象有很多的成员属性，如果通过构造赋值，由于部分字段无需赋值，可能需要重载构造方法，导致代码冗余，且不能灵活使用，最主要使用不方便
   所以这就引出了建造者模式

3. 建造者模式的使用

package design.builderPattern;
public class Person {
    public static void main(String[] args) {
        Person person = new Person(new Builder("食物", "水", "衣服")
                .setEntertainment("打游戏").setGirlOrBoy("女孩").setKnowledge("知识"));
        System.out.println(person);
    }

    private String food;

    private String water;

    private String clothes;

    private String knowledge;

    private String entertainment;

    private String girlOrBoy;

    public Person(Builder builder) {
        this.food = builder.food;
        this.water = builder.water;
        this.clothes = builder.clothes;
        this.knowledge = builder.knowledge;
        this.entertainment = builder.entertainment;
        this.girlOrBoy = builder.girlOrBoy;
    }

    static class Builder {
        private String food;

        private String water;

        private String clothes;

        private String knowledge;

        private String entertainment;

        private String girlOrBoy;

        public Builder(String food, String water, String clothes) {
            this.food = food;
            this.water = water;
            this.clothes = clothes;
        }

        public Builder setKnowledge(String knowledge) {
            this.knowledge = knowledge;
            return this;
        }

        public Builder setEntertainment(String entertainment) {
            this.entertainment = entertainment;
            return this;
        }

        public Builder setGirlOrBoy(String girlOrBoy) {
            this.girlOrBoy = girlOrBoy;
            return this;
        }
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Person{");
        sb.append("food=‘").append(food).append(‘\‘‘);
        sb.append(", water=‘").append(water).append(‘\‘‘);
        sb.append(", clothes=‘").append(clothes).append(‘\‘‘);
        sb.append(", knowledge=‘").append(knowledge).append(‘\‘‘);
        sb.append(", entertainment=‘").append(entertainment).append(‘\‘‘);
        sb.append(", girlOrBoy=‘").append(girlOrBoy).append(‘\‘‘);
        sb.append(‘}‘);
        return sb.toString();
    }
}

通过上述代码可以创建对象并动态赋值，精髓在于set对应属性后返回this这个对象，又可以重复操作这个对象，就跟java 8的流处理是一个道理，其实上述是建造者模式简单版

4. 真实的建造者模式

• 建造者（Builder）模式存在四种角色
  产品（Product）：简单说就是复杂对象，也就是上述的Person
  抽象建造者（Builder）：建造者抽象类一般包含需要添加的属性的抽象方法 + 返回Product的方法[Person]。
  具体建造者(Concrete Builder）：实现 Builder 接口，对抽象类方法的实现。
  指挥者（Director）：构建与组装 =》 返回复杂对象Product

5. 代码实现

Product(Person类)

package design.builderPattern;
public class Person {

  private String food;

  private String water;

  private String clothes;

  private String knowledge;

  private String entertainment;

  private String girlOrBoy;

  public void setFood(String food) {
      this.food = food;
  }

  public void setWater(String water) {
      this.water = water;
  }

  public void setClothes(String clothes) {
      this.clothes = clothes;
  }

  public void setKnowledge(String knowledge) {
      this.knowledge = knowledge;
  }

  public void setEntertainment(String entertainment) {
      this.entertainment = entertainment;
  }

  public void setGirlOrBoy(String girlOrBoy) {
      this.girlOrBoy = girlOrBoy;
  }

  @Override
  public String toString() {
      final StringBuilder sb = new StringBuilder("Person{");
      sb.append("food=‘").append(food).append(‘\‘‘);
      sb.append(", water=‘").append(water).append(‘\‘‘);
      sb.append(", clothes=‘").append(clothes).append(‘\‘‘);
      sb.append(", knowledge=‘").append(knowledge).append(‘\‘‘);
      sb.append(", entertainment=‘").append(entertainment).append(‘\‘‘);
      sb.append(", girlOrBoy=‘").append(girlOrBoy).append(‘\‘‘);
      sb.append(‘}‘);
      return sb.toString();
  }
}

抽象建造者（Builder）

package design.builderPattern;
public abstract class Builder {
    protected Person person = new Person();
    public abstract void setFood();
    public abstract void setWater();
    public abstract void setClothes();
    public abstract void setKnowledge();
    public abstract void setEntertainment();
    public abstract void setGirlOrBoy();

    public Person getPerson() {
        return person;
    }
}

具体建造者(Concrete Builder）

package design.builderPattern;
public class ConcreteBuilder extends Builder {

    @Override
    public void setFood() {
        person.setFood("食物builder");
    }

    @Override
    public void setWater() {
        person.setWater("水builder");
    }

    @Override
    public void setClothes() {
        person.setClothes("衣服builder");
    }

    @Override
    public void setKnowledge() {
        person.setKnowledge("知识builder");
    }

    @Override
    public void setEntertainment() {
        person.setEntertainment("娱乐builder");
    }

    @Override
    public void setGirlOrBoy() {
        person.setGirlOrBoy("妹子builder");
    }
}

指挥者（Director）

package design.builderPattern;
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Person assemblePerson(){
        builder.setClothes();
        builder.setEntertainment();
        builder.setWater();
        builder.setFood();
        builder.setKnowledge();
        builder.setGirlOrBoy();

        return builder.getPerson();
    }

    public static void main(String[] args) {
        Director director = new Director(new ConcreteBuilder());
        Person person = director.assemblePerson();
        System.out.println(person);
    }
}

运行结果：

本人在代码开发中基本就用到第一种方式。

5分钟理解建造者模式【简单使用方式】

原文：https://www.cnblogs.com/zjd-world/p/14640536.html