设计模式-构造者模式

1. 含义

是指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
通俗的说,假如你要创建一个人类的对象,那么各个实例的属性不同,也就是人的高矮胖瘦不一样.这个时候可以考虑用构造者模式。

2.参与角色

a. 要构造的产品

b.抽象构造者，提供各种方法，和一个返回产品方法

c.具体的构造者实现类

d.指挥者角色，具体操作

3.代码示例如下

构造产品

/**
 * <p>
 * 产品角色
 * </p>
 *
 */

@Data
public class Computer {
    private String CPU;
    private String memory;
    private String hardDisk;
    private String keyboard;

}

抽象构造者

/**
 * <p>
 *建造者抽象角色
 * </p>
 *
 */
public interface ComputerBuilder {
    void setCPU();

    void setMemery();

    void setHardDisk();

    void setKeyboard();

    Computer getComputer();
}

具体构造者实现类，定义了两个实现类

/**
 * <p>
 * 具体建造者角色
 * </p>
 *
 */
public class HighConfigComputer implements ComputerBuilder {
    private Computer computer;

    public HighConfigComputer() {
        this.computer = new Computer();
    }

    @Override
    public void setCPU() {
        computer.setCPU("i7");
    }

    @Override
    public void setMemery() {
        computer.setMemory("16G");
    }

    @Override
    public void setHardDisk() {
        computer.setHardDisk("500G");
    }

    @Override
    public void setKeyboard() {
        computer.setKeyboard("键盘");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

/**
 * <p>
 * 具体建造者角色
 * </p>
 *
 */
public class LowConfigComputer implements ComputerBuilder {
    private Computer computer;

    public LowConfigComputer() {
        this.computer = new Computer();
    }

    @Override
    public void setCPU() {
        computer.setCPU("i5");
    }

    @Override
    public void setMemery() {
        computer.setMemory("8G");
    }

    @Override
    public void setHardDisk() {
        computer.setHardDisk("500G");
    }

    @Override
    public void setKeyboard() {
        computer.setKeyboard("键盘");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

指挥者角色

/**
 * <p>
 * 构造者模式-指挥者角色
 * </p>
 *
 */
public class Director {
    private ComputerBuilder computerBuilder;

    public void setBuilder(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public void createComputer() {
        computerBuilder.setCPU();
        computerBuilder.setHardDisk();
        computerBuilder.setMemery();
        computerBuilder.setKeyboard();
    }

    public Computer getComputer() {
        return computerBuilder.getComputer();
    }

}

测试代码

/**
 * <p>
 *测试
 * </p>
 *
 */
public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        director.setBuilder(new LowConfigComputer());
        director.createComputer();
        Computer computer = director.getComputer();
        System.out.println(computer.toString());
    }
}

4. 构造者四个角色，如果省掉其中的指挥者和抽象构造者,只有一个具体的构造者,那么久是简单的构造者模式。

代码如下

/**
 * <p>
 *构造者简单模式 -省略指挥者和抽象构造者
 * </p>
 *
 */
@Data
public class Person {
    /** 必须 */
    private final String name;
    /** 必须 */
    private final String gender;
    private       String age;
    private       String house;

    private Person(Builder builder) {
        this.name = builder.name;
        this.gender = builder.gender;
        this.age = builder.age;
        this.house = builder.house;
    }


    private static class Builder {
        /** 必须 */
        private final String name;
        /** 必须 */
        private final String gender;
        private       String age;
        private       String house;

        public Builder(String name, String gender) {
            this.name = name;
            this.gender = gender;
        }

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

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

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

    public static void main(String[] args) {
        Person person = new Builder("12", "22").age("22").house("dd").build();
        System.out.println(person.toString());
    }
}