设计模式——建造者模式

场景

在生活中，有时候存在一个很大的实体，其有很多的属性，其构造起来起来就很复杂。这时候，我们可以将这个很大的实体进行拆分，拆分很多部分进行构造。比如：在生产一辆汽车的时候，其属性就有很多。比如轮胎的材质，轮胎的大小，发动机的类型，发动的品牌，车架的材质，车架的颜色。。。。等很多属性。如果我们在生产一个汽车时，要指定这么多参数，必然十分的复杂。这时候，我们就将汽车拆着轮胎、车架、发动机等部分进行构造。然后最后再将这些部分组装起来即可。为了方便，这里的汽车构造就看成是三个部分进行组成的。分别为轮胎tyre、发动机engine、车架Frame三部分组成。

关键点

1. 我们要构造的那个最大的实体存在有各部分，并且对于这些部分有set方法
2. 建造者中有要构造的对象，并且实现每部分的构造，注意各部分的构造返回的是Builder对象
3. 构造器有一个返回我们要实例对象的方法。在我的代码里就是getCar()

代码实现

Car.class

public class Car {
    private Tyre tyre;
    private Frame frame;
    private Engine engine;

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

    public void setFrame(Frame frame) {
        this.frame = frame;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    @Override
    public String toString() {
        return "Car{" +
                "tyre=" + tyre +
                ", frame=" + frame +
                ", engine=" + engine +
                '}';
    }
}

Engine.class

public class Engine {
    private String category;
    private String Brand;

    public Engine(String category, String brand) {
        this.category = category;
        Brand = brand;
    }

    @Override
    public String toString() {
        return "Engine{" +
                "category='" + category + '\'' +
                ", Brand='" + Brand + '\'' +
                '}';
    }
}

Frame

public class Frame {
    private String Materials;
    private String color;

    public Frame(String materials, String color) {
        Materials = materials;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Frame{" +
                "Materials='" + Materials + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

Tyre

public class Tyre {
    private String Materials;   //材质
    private int size;

    public Tyre(String materials, int size) {
        Materials = materials;
        this.size = size;
    }

    @Override
    public String toString() {
        return "Tyre{" +
                "Materials='" + Materials + '\'' +
                ", size=" + size +
                '}';
    }
}

Builder

public abstract class Builder {
    Car car ;

    public Builder(Car car) {
        this.car = car;
    }

    public abstract Builder createFrame();
    public abstract Builder createTyre();
    public abstract Builder createEngine();

    public Car getCar() {
        return car;
    }
}

Volvo

public class Volvo extends Builder {


    public Volvo(Car car) {
        super(car);
    }

    @Override
    public Builder createFrame() {
        car.setFrame(new Frame("A柱杠杠的","bule"));
        return this;
    }

    @Override
    public Builder createTyre() {
        car.setTyre(new Tyre("米其林",23));
        return this;
    }

    @Override
    public Builder createEngine() {
        car.setEngine(new Engine("吉利","涡轮增压"));
        return null;
    }
}

Bike

public class Bike extends Builder {
    public Bike(Car car) {
        super(car);
    }

    @Override
    public Builder createFrame() {
        car.setFrame(new Frame("碳纤维","red"));
        return this;
    }

    @Override
    public Builder createTyre() {
        car.setTyre(new Tyre("朝阳",30));
        return this;
    }

    @Override
    public Builder createEngine() {
        return this;
    }
}

Test

public class Test {
    public static void main(String[] args) {
        Builder volvo = new Volvo(new Car());
        volvo.createEngine();
        volvo.createFrame();
        volvo.createTyre();
        Car car = volvo.getCar();
        System.out.println(car);
        System.out.println("==================");
        Builder bike = new Bike(new Car());
        Car car1 = bike.createTyre().createFrame().getCar();
        System.out.println(car1);

    }
}

个人理解

其实我们感觉构造者模式就是在构造对象的时候，可以有选择的传入参数。比如一个对象他有6个属性，那么我们在对这个对象进行构造时，如果其中的某些属性是没有的，那么我们的构造方法至少要2^6=32个，这还不考虑属性的前后顺序的。而构造这模式，我们就只需要构造六个构造方法。这种做法就像：一开始构造一个空的对象，然后使用set方法对属性进行赋值，而且有属性还可以选择性的进行赋值。个人感觉构造者模式：就是构造方法与set方法之间的一种结合，然后一开始构造对象的时候就可以链式的设置值，而不用构造空的对象再赋值。可能这就是为什么叫创建型模式的原因吧。

常用的一种模式

People

public class People {
    String name;
    int age;
    String location;
    String id;
    int sex;
    int height;
    int weight;

    public People() {
    }

    public static class Builder{
        People people = new People();

        public Builder Name(String name){
            people.name = name;
            return this;
        }

        public Builder Age(int age){
            people.age = age;
            return this;
        }

        public Builder Location(String location){
            people.location = location;
            return this;
        }

        public Builder Id(String id){
            people.id = id;
            return this;
        }

        public Builder Sex(int sex){
            people.sex = sex;
            return this;
        }

        public Builder Height(int height){
            people.height = height;
            return this;
        }

        public Builder Weight(int weight){
            people.weight = weight;
            return this;
        }

        public People getResult(){
            return people;
        }
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", location='" + location + '\'' +
                ", id='" + id + '\'' +
                ", sex=" + sex +
                ", height=" + height +
                ", weight=" + weight +
                '}';
    }
}

Test

public class Test {
    public static void main(String[] args) {
        People p = new People.Builder().Age(18)
                .Height(174)
                .Sex(1)
                .getResult();
        System.out.println(p);
    }
}