安卓设计模式-构建者模式

是什么

构建者模式又生builder模式，是将复杂的对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表现

有什么

1. 经典构建模式

• 要创建的产品（即对象）
• 抽象的build，进行设置的各个过程
• build的具体实现 对抽象builder的实现
• 使用者

2. 变种的builder模式

• 产品类
• 内部builder

怎么做

经典builder

1. 创建一个产品类 Person

public class Person{
    private String career;//职业
    private String name;
    private String sex;
    private int age;
    public String getName(){
        return name ;
    }
    poblic String getSet(){
        return sex;
       
    }
    public int getAge(){
        return age;
    }
}

2. builder 接口

public inerface PersonBuiler{
    public void career();
    public void name();
    public void sex();
    public voide age();
    Person getPerson();
}

3. builder 实现
   教师的实现

public class TeacherBuilder implement PersonBuild(){
   private Person person;
   public TeacherBuilder(){
       person=new Person();
   }
   public void career(){
       person.setCareer("老师");
   }
    public void name(){
        person.setName("张老师");
    }
    public void sex(){
        person.setSex("男");
    }
    public voide age(){
        person.setAge(35);
    }
    Person getPerson(){
        return person;
    }
}

学生类的实现

public class StudentBuilder implement PersonBuild(){
   private Person person;
   public TeacherBuilder(){
       person=new Person();
   }
   public void career(){
       person.setCareer("学生");
   }
    public void name(){
        person.setName("张三");
    }
    public void sex(){
        person.setSex("男");
    }
    public voide age(){
        person.setAge(18);
    }
    Person getPerson(){
        return person;
    }
}

4. 使用者 Director,持有builder对象，创建者方法，返回产品

public class Director{
    private PersonBuilder builder;
    public void setBuilde(PersonBuilder builder){
        this.builder=builder;
    }
    public void creater(){
        builder.career();
        builder.sex();
        builer.name();
        builder.age();
    }
    public Person getPerson(){
        return builder.getPerson();
    }
}

5. 演示

创建一个学生类
Director d=new Director();
d.setBuilder(new StudentBuilder());
d.creater();
Person p=d.getPerson();
~~
### 变种builder
​~~~java
public class Person{
    private String career;//职业
    private String name;
    private String sex;
    private int age;
    public String getName(){
        return name ;
    }
    poblic String getSet(){
        return sex;
       
    }
    public int getAge(){
        return age;
    }
    private Person(Builder builder ){
        this.sex=builder.sex;
        this.age=builder.age;
        this.name=builder.name;
        this.career=builder.career;
    }
    public static class Builer(){
        private final String career;//职业
        private String name;
        private String sex;
        private int age;
        public Builder(String career){
            this.career=career;
        }
        public Builder setSex(String sex){
            this.sex=sex();
            return this;
        }
        public Builder setAge(int age){
            this.age=age;
            return this;
        }
        public Builder setName(String name){
            this.name=name ;
            retuen this;
        }
        public Person build(){
            return new Person(this);
        }
    }
}

演示

Person p=new Person.builder("教师").setSex("男").builder();

什么时候用

1.当需要创建一个对象需要很多变量组合而成，这个时候可以考虑将这个对象的创建过程和对象的表示分离开来，这样可以很简洁的构建一个复杂的对象

优缺点

优点：
（1）良好的封装性， 使用建造者模式可以使客户端不必知道产品内部组成的细节；
（2）建造者独立，容易扩展；
（3）在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。

缺点：
（1）会产生多余的Builder对象以及Director对象，消耗内存；
（2）对象的构建过程暴露。。