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

生成器模式功能：

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

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

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

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());
}

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

优点

增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。