生成器模式（建造者模式）

• 生成器模式功能：

生成器模式的重心在于分离构建算法和具体的构建实现，从而使得构建算法可以重用。具体的构造实现可以很方便地扩展和切换，从而可以灵活的组合构造出不同的产品。

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。根据中文翻译的不同，建造者模式又可以称为生成器模式。

简单生成器模式实现样例：

public class Person {
    private String name;
    private String sex;
    private int age;
    private int wight;
    public Person(String name,String sex,int age,int wight){
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.wight = wight;
    }
    @Override
    public String toString(){
        return "name is "+name+" sex is "+ sex+" age is "+age + " wight is "+wight;

    }
    public String getName() {
        return name;
    }
    public String getSex() {
        return sex;
    }
    public int getAge() {
        return age;
    }
    public int getWight() {
        return wight;
    }
}

    public static void main(String[] args) {
        Person p = new PersonBuilder().name("sb").sex("man")
                .age(33).wight(140).builder();
        System.out.println(p.toString());
    }

内部类生成器模式实现

public class Person1 {
    private String name;
    private String sex;
    private int age;
    private int wight;
    public Person1(String name,String sex,int age,int wight){
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.wight = wight;
    }
    @Override
    public String toString(){
        return "name is "+name+" sex is "+ sex+" age is "+age + " wight is "+wight;
    }
    public String getName() {
        return name;
    }
    public String getSex() {
        return sex;
    }
    public int getAge() {
        return age;
    }
    public int getWight() {
        return wight;
    }

    public static class Builder{
        private String name;
        private String sex;
        private int age;
        private int wight;

        public Builder name(String name){
            this.name = name;
            return this;
        }
        public Builder sex(String sex){
            this.sex = sex;
            return this;
        }
        public Builder age(int age){
            this.age = age;
            return this;
        }
        public Builder wight(int wight){
            this.wight = wight;
            return this;
        }
        public Person1 builder(){
            return new Person1(name, sex, age, wight);
        }
    }
    public static void main(String[] args) {
        Person1 p = new Person1.Builder().name("sb").sex("man")
                .age(33).wight(140).builder();
        System.out.println(p.toString());
    }
}

与普通的区别只是吧builder类放到内部类中了。

复杂的生成器模式样例。

public class School {//假设这个学校就一个老师一个学生
    private String name;
    private String lev;
    private String motto;
    private Person1 student;
    private Person1 teacher;
    private String teacherRole;

    public School(String name,String lev,String motto,Person1 student,Person1 teacher,String teacherRole){
        this.name = name;
        this.lev = lev;
        this.motto = motto;
        this.student = student;
        this.teacher = teacher;
        this.teacherRole = teacherRole;
    }
    public String getName() {
        return name;
    }
    public String getLev() {
        return lev;
    }
    public String getMotto() {
        return motto;
    }
    public Person1 getStudent() {
        return student;
    }
    public Person1 getTeacher() {
        return teacher;
    }
    public String getTeacherRole() {
        return teacherRole;
    }

    public static class Builder{
        private String name;
        private String lev;
        private String motto;
        private Person1 student;
        private Person1 teacher;
        private String teacherRole;
        public Builder name(String name){
            this.name = name;
            return this;
        }
        public Builder lev(String lev){
            this.lev = lev;
            return this;
        }
        public Builder motto(String motto){
            this.motto = motto;
            return this;
        }
        public Builder student(Person1 student){
            this.student = student;
            return this;
        }
        public Builder teacher(Person1 teacher){
            this.teacher = teacher;
            this.teacherRole = "woman".equals(teacher.getSex())?" 做饭，买菜":"赚钱，养家";
            return this;
        }
        public School builder(){
            return new School(name, lev, motto, student, teacher,teacherRole);
        }
    }
    @Override
    public String toString(){
        return "name is "+name+", lev is "+ lev+", motto is "+motto + ", teacher message is ("
                +teacher.toString()+" ),teacherRole is "+teacherRole +", student message is ("+student.toString()+").";
    }
}

    public static void main(String[] args) {
        School sc = new School.Builder()
            .lev("家教")
            .name("家")
            .motto("早点睡，多吃饭")
            .teacher(new Person1.Builder()
                .name("母亲")
                .age(26)
                .sex("woman")
                .wight(99)
                .builder())
            .student(new Person1.Builder()
                .name("宝宝")
                .age(2)
                .sex("man")
                .wight(25)
                .builder())
            .builder();
        System.out.println(sc.toString());
    }

看到下面的生成器模式使用是不是有种很舒服的感觉？不管你有没有我是感觉很爽。虽然编写比较复杂。

优点
增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。