Builder模式

1. 定义：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。
2. 使用场景：
   (1). 相同的方法，不同的执行顺序，产生不同的事件结果。
   (2). 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不想同时。
   (3). 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用构造者模式非常适合。
   (4). 当初始化一个对象特别复杂，如参数多，且很多参数具有默认值时。
3. 代码实现：

    /***
      * 计算机抽象类
      * 
      * @author ping
      * 
      */
     public  class Computer {
         protected String mBoard;
         protected String mDisplay;
         protected String mOS; // 系统
   
         public void setmBoard(String mBoard) {
             this.mBoard = mBoard;
         }
   
         public void setmDisplay(String mDisplay) {
             this.mDisplay = mDisplay;
         }
   
         public String getmOS() {
             return mOS;
         }
   
         public void setmOS(String mOS) {
             this.mOS = mOS;
         }
   
         public String getmBoard() {
             return mBoard;
         }
   
         public String getmDisplay() {
             return mDisplay;
         }
   
         public void setOs(String os) {
             this.mOS = os;
         }
         //构建Builder类
         public static class Builder {
             private Computer mComputer;
   
             public Builder() {
                 super();
                 mComputer = new Computer();
             }
   
             public Builder builderBoard(String board) {
                 mComputer.setmBoard(board);
                 return this;
             }
   
             public Builder builderDisplay(String display) {
                 mComputer.setmDisplay(display);
                 return this;
             }
   
             public Builder builderOS(String os) {
                 mComputer.setOs(os);
                 return this;
             }
   
             public Computer create() {
                 return mComputer;
             }
         }
   
         @Override
         public String toString() {
             return "Computer [mBoard=" + mBoard + ", mDisplay=" + mDisplay
                     + ", mOS=" + mOS + "]";
         }
   
     }
   
   

测试代码：

     public class BuildrtTest {

       /**
        * @param args
        */
       public static void main(String[] args) {

           Computer.Builder mBuilder = new Computer.Builder().builderBoard("因特尔主板").builderDisplay("Retina显示器").builderOS("Mac OS X 10.11");
           System.out.print("\nComputer info: " + mBuilder.create().toString());
           
           Computer mComputer = new Computer.Builder().builderBoard("因特尔主板").builderDisplay("Retina显示器").builderOS("Mac OS X 10.11").create();
           System.out.print("\nComputer info: " + mComputer.getmBoard() +"---" +mComputer.getmDisplay() +"---" + mComputer.getmOS());

       }

   }
   

输出打印：

Computer info: Computer [mBoard=因特尔主板, mDisplay=Retina显示器, mOS=Mac OS X 10.11]
Computer info: 因特尔主板---Retina显示器---Mac OS X 10.11

4. 总结：Builder模式在Android开发中,通常作为配置类的构建器将配置的构建和表示分离开来，同时也是将配置从目标类中隔离出来，避免过多的setter方法。Builder模式比较常见的实现形式是通过调用链实现，使得代码更简介，易懂。
5. 优点：

• 良好的封装性，使用Builder模式可以使客户端不必知道产品内部组成细节；
• 建造者独立，容易扩展；

6. 缺点：

• 产生多余的Builder对象，消耗内存；