android设计模式：Builder模式

Builder模式（建造者模式）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
我们看看一种对象生成的方式，以宠物医院记录宠物狗信息为例：

//汪汪信息类
public class Dog{   
    private int identifier;//编号
    private String name;//名字
    private int age;//年龄
    private int weight;//体重
    private String breed;//品种
    private boolean gender;//性别，true：公狗；false：母狗
    private String sickness;//疾病

    public void setIdentifier(int identifier){
         this.identifier=identifier;
    }

     public void setName(String name){
         this.name=name;
    }

     public void setAge(int age){
         this.age=age;
    }

     public void setWeight(int weight){
         this.weight=weight;
    }

     public void setBreed(int breed){
         this.breed=breed;
    }

     public void setGender(boolean gender){
         this.gender=gender;
    }
    public void setSickness(String sickness){
         this.sickness=sickness;
    }
}

//一只新的汪进来了
Dog dog=new Dog;
dog.setIdentifier(2222);//因为是一只二哈,2炸了
dog.setName("sijia");//撕家小能手呀
dog.setAge(3);
dog.setWeight(20);
dog.setBreed("Husky");
dog.setGender(true);
dog.setSickness("doubi");//这只哈士奇太逗逼了，还能治吗？

终于把它的信息记录完了，有没发现类名dog都重复了好多遍，那有没有简洁点的方式，有的。在Dog类中增加新的方法：

public void setDogInfo(int identifier,int String name,int age,int weight,String breed,boolean gender,String sickness){
    this.identifier=identifier;
    this.name=name;
    this.age=age;
    this.weight=weight;
    this.breed=breed;
    this.gender=gender;
    this.sickness=sickness;
}

//感觉完美呀，调用看看
Dog dog=new Dog();
dog.setDogInfo(2222,"sijia",3,20,"Husky",true,"doubi");

一行搞定，不过数字和字符串的含义不是一目了然，还是得查看定义。新增参数就得修改定义，调用的地方也得修改
而且如果参数更多的话，看起来会更乱

建造者模式就为提供了另外一种解决方式，引入构造器Builder，让它实现构造的任务。

//汪汪信息类
public class Dog{   
    private int identifier;//编号
    private String name;//名字
    private int age;//年龄
    private int weight;//体重
    private String breed;//品种
    private boolean gender;//性别，true：公狗；false：母狗
    private String sickness;//疾病

    static class Builder{
        private Dog dog;

        public Builder(){
            dog=new Dog();
        }
        public Builder setIdentifier(int identifier){
             dog.identifier=identifier;
             return this;
    }

         public Builder setName(String name){
             dog.name=name;
             return this;
        }

         public Builder setAge(int age){
             dog.age=age;
             return this;
        }

         public Builder setWeight(int weight){
             dog.weight=weight;
             return this;
        }

         public Builder setBreed(int breed){
             dog.breed=breed;
             return this;
        }

         public Builder setGender(boolean gender){
             dog.gender=gender;
             return this;
        }
        public Builder setSickness(String sickness){
             dog.sickness=sickness;
             return this;
        }

        public Dog create(){
            return dog;
        }
    }
}

在对象内部增加了Builder，Buidler设置参数的方法返回都是Builder这个对象
现在调用一下：

Dog dog=new Dog.Builder().setIdentifier(2222).setName("sijia").setAge(3)
.setWeight(20).setBreed("Husky").setGender(true).setSickness("doubi")
.create();

这样，每项参数定义清晰，而且直接头尾相连定义，省去重复的代码。
感觉上是我们先获取Builder，然后构建所有参数，最后再将构建出的对象显露出来。
契合了模式定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。