java设计模式-Builder创建者模式

问题分析：

Builder模式是一步一步创建一个复杂对象的创建型模式。该模式是为了将构建复杂对象的过程和他的部件解耦，使得构建过程和部件的表示隔离开来。

Builder模式 主要用于“构建一个复杂的对象”。把复杂对象的创建过程加以抽象，通过子类继承和重写方法，来得到具有复合属性的对象。

同时为了统一创建过程，把对象的创建操作统一封装到Director的方法中。
由于一个复杂对象的单个属性可能会发生变化（例如：制造汽车时使用的某一部件属于不同的厂家）但是整个复杂对象的构建过程却不会发生变化（例如：汽车的构建图纸已经固定，只需要把部件按照图纸装配好）
GOF：将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。即构建过程相同，但是子部件却不相同。

即：创建者模式只关心构建过程

抽象工厂注重的是不同的工厂生产不同的产品，builder注重的是某个产品由不同的零件组成，产品的生产工程。
Director就是负责产品组装的，是控制生产过程的；而builder是负责产品部件生产的。这样就实现了“过程”和“部件”的解耦。
抽象工厂通过不同的构建过程生成不同的对象表示，而Builder模式通过相同的构建过程生成不同的表示。

UML图：

生活中的例子：计算机的组装过程简化为构建主机，设置操作系统，设置显示器3个部分，然后通过Director类和具体的Builder来构建计算机对象

Computer.java

package com.hust.builder;
//计算机抽象类，即Product角色
public abstract class Computer {
      protected String mBoard;
      protected String mDisplay;
      protected String mOs;
      
      protected Computer(){};
      //设置CPU核心数
      public void setBoard(String board) {
    	  mBoard=board;
	  }
      //设置内存
      public void setDisplay(String display){
    	  mDisplay=display;
      }
      //设置操作系统
      public abstract void setOs();
       
      public String toString(){
    	return "Computer[mBoard="+mBoard+",mDisplay="+mDisplay+",mOs="+mOs+"]";  
      }
}

MacBook.java

package com.hust.builder;
//具体的Computer类，Macbook
public class MacBook extends Computer {

	public void setOs() {
		 mOs="Mac OS X 10.10";
	}

}

Builder.java

</pre><pre name="code" class="java">package com.hust.builder;
//抽象Builder类
public abstract class Builder {
       //必须有建造部件的方法
      public abstract void buildBoard(String board) ;
      public abstract void buildDisplay(String display) ;
      public abstract void buildOS();
      //必须有获得结果对象的方法
      public abstract Computer create() ;
} 

MacBookBuilder.java

package com.hust.builder;
//具体Builder类，MacbookBuilder
public class MacBookBuilder extends Builder {
    private Computer mComputer=new MacBook();//被构造对象作为具体Builder的成员变量
    
    //以下三种方法，是构建对象的部分或者零件
	public void buildBoard(String board) {
		mComputer.setBoard(board);
	}

	public void buildDisplay(String display) {
		mComputer.setDisplay(display);
	}

	public void buildOS() {
		mComputer.setOs();
	}

	public Computer create() {		
		return mComputer;
	}

}

Director.java

package com.hust.builder;
//Director类，负责构造Computer
public class Director {
     Builder mBuilder=null;//把构建器作为成员变量
     public Director(Builder mBuilder){
    	 this.mBuilder=mBuilder;
     }
     //封装构建过程
     public void construct(String board,String display) {
		mBuilder.buildBoard(board);
		mBuilder.buildDisplay(display);
		mBuilder.buildOS();
	}
}

输出：Computer[mBoard=英特尔主板,mDisplay=AOC显示器,mOs=Mac OS X 10.10]
注意：

1，builder抽象类必须要有建造部件的方法和获得结果对象的方法

2，builder具体类必须是对象结果作为成员变量

3，Director的类必须有一个construct方法封装构造过程

在实际开发中，Director角色经常被省略，直接使用一个Builder来进行对象的主机组装，这个Builder通常为链是调用，它的关键点是setter方法都会返回自身，就是return this

MacBookBuilder.java

package com.hust.builder2;
//具体Builder类，MacbookBuilder
public class MacBookBuilder {
    private Computer mComputer=new MacBook();//被构造对象作为具体Builder的成员变量
    
    //以下三种方法，是构建对象的部分或者零件
	public MacBookBuilder buildBoard(String board) {
		mComputer.setBoard(board);
		return this;
	}

	public MacBookBuilder buildDisplay(String display) {
		mComputer.setDisplay(display);
		return this;
	}

	public MacBookBuilder buildOS() {
		mComputer.setOs();
		return this;
	}

	public Computer create() {		
		return mComputer;
	}

}

test.java

package com.hust.builder2;

public class TestBuilder2 {

	/**
	 *计算机的组装过程简化为构建主机，设置操作系统，设置显示器3个部分，然后通过Director类和具体的Builder来构建计算机对象
	 */
	public static void main(String[] args) {
	    //构建器，是为了构建对象的零件
		MacBookBuilder mBuilder=new MacBookBuilder();
		   
	   
	   //在实际开发中，Director角色经常被省略，直接使用一个Builder来进行对象的主机组装，这个Builder通常为链是调用，它的关键点事setter方法都会返回自身，他、也就是return this	   
	     ;
	   System.out.println(mBuilder.buildBoard("因特尔主板").buildDisplay("AOC显示器").buildOS().create().toString());
	   //System.out.println(mBuilder.create().toString());

	}

}

参考：http://blog.csdn.net/jiafu1115/article/details/6668563