设计模式(三)----- 建造者模式(Builder)----(JAVA版)

 将一个复杂对象的构建与它的表示分离，使同样的构建过程可以创建不同的表示。可以将建造模式的精髓概括为：将构造复杂对象的过程和对象的部件解耦。这是对降低耦合、提高可复用性精神的一种贯彻。其实这种精神贯彻在GOF几乎所有的设计模式中。

适用性：

1.当创建复杂对象的算法应该独立与该对象的组成部分以及它们的装配方式时

2.当构造过程必须允许被构造的对象有不同的表示时

   当要生成的产品有复杂的内部结构，其中的内部结构由多个对象组成；系统将来可能要改变产品对象的内部结构的构成或者实现方式，比如说产品的一些属性现在是从数据库中得到的，而将来可能从XML中解析得到；而且不能将产品的内部构造完全暴露给客户程序，一是为了可用性，二是为了安全等因素。满足上面的设计环境就可以考虑使用建造模式来搭建框架了。

参与者：

1.Builder

  为创建一个Product对象的各个部件指定抽象接口

2.ConcreteBuilder

   实现Builder的接口以构造和装配该产品的各个部件

   定义并且明确它所创建的表示

  提供一个检索产品的接口

3.Director

  构造一个使用Builder接口的对象

4.Product

  表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。

  包含定义组成部件的类，包括将这些部件装配成最终产品的接口

UML:

一个简单的例子：

Builder

新建地图接口：

[java] view plain copy

1. public interface map_interface{  
2.    public void create_weather();  
3.    public void create_house();  
4.    public void create_tree();  
5.    public void create_way();  
6. }  

ConcreteBuilder

新建晴天地图类：

[java] view plain copy

1. public class map_sun implements map_interface{  
2.    public void create_weather(){  
3.       System.out.println("晴天");  
4.    }  
5.    public void create_house(){  
6.       System.out.println("房子上玻璃发亮");  
7.    }  
8.    public void create_tree(){  
9.       System.out.println("树的颜色是浅绿色");  
10.    }  
11.    public void create_way(){  
12.       System.out.println("路面有些干燥");  
13.    }  
14. }  

新建阴天地图类：

[java] view plain copy

1. public class map_cloudy implements map_interface{  
2.    public void create_weather(){  
3.       System.out.println("阴天");  
4.    }  
5.    public void create_house(){  
6.       System.out.println("房子上玻璃发暗");  
7.    }  
8.    public void create_tree(){  
9.       System.out.println("树的颜色是深绿色");  
10.    }  
11.    public void create_way(){  
12.       System.out.println("路面有些潮湿");  
13.    }  
14. }  

Director

新建一个高画质builder建造者类

[java] view plain copy

1. public class map_build_adv{  
2.   private map_interface map_interface_ref;  
3.   public map_build_adv(map_interface map_interface_ref){  
4.       super();  
5.       this.map_interface_ref = map_interface_ref;  
6.   }   
7.   public void create_map(){  
8.       System.out.println("创建一个高画质的地图");  
9.       //创建的顺序很重要  从天空往路面创建  
10.       map_interface_ref.create_weather();  
11.       map_interface_ref.create_house();  
12.       map_interface_ref.create_tree();  
13.       map_interface_ref.create_way();  
14.    }  
15. }  

新建一个低画质builder建造者类

[java] view plain copy

1. public class map_build_low{  
2.   private map_interface map_interface_ref;  
3.   public map_build_adv(map_interface map_interface_ref){  
4.       super();  
5.       this.map_interface_ref = map_interface_ref;  
6.   }   
7.   public void create_map(){  
8.       System.out.println("创建一个低画质的地图");  
9.       //创建的顺序很重要  从天空往路面创建  
10.       map_interface_ref.create_weather();  
11.       map_interface_ref.create_house();  
12.       //map_interface_ref.create_tree();将创建树的过程去掉  
13.       map_interface_ref.create_way();  
14.    }  
15. }  

Test

[java] view plain copy

1. public class Test{  
2.   public static void main(String[] args){  
3.      map_cloudy map_cloudy_ref = new map_cloudy();  
4.      map_build_adv map_build_adv_ref = new map_build_adv(map_cloudy_ref);  
5.      map_build_adv_ref.create_map();  
6.        
7.      System.out.println();      
8.   
9.      map_sun map_sun_ref = new map_sun();  
10.      map_build_low map_build_low_ref = new map_build_low(map_sun_ref);  
11.      map_build_low_ref.create_map();  
12. }  

result:

创建一个高画质的地图

阴天

房子上玻璃发暗

树的颜色是深绿色

路面有些潮湿

创建一个低画质的地图

晴天

房子上玻璃发亮

路面有些干燥

第二个例子：

     比如：一部汽车：它由发动机，轮胎、底盘，车身组成。而此时无论我最终构建的汽车是大众牌的汽车还是奥迪汽车，它的构建过程是不会变的，都是由发动机，轮胎、底盘，车身组成。至于大众牌的汽车还是奥迪汽车它们各自采用的是什么样的发动机，轮胎、地盘这些肯定是不一样的，也就是经常变化的。

Builder:

[java] view plain copy

1. public abstract class BuilderCar  
2.      {  
3.          public abstract void Engine();//发动机  
4.          public abstract void Chassis();//底盘  
5.          public abstract void Carbody();//车身  
6.          public abstract void Tire();//轮胎  
7.    
8.          public abstract Car GetCar();//最终构建出来的汽车  
9.          
10.      }  

ConcreteBuilder

[java] view plain copy

1. public class OOOOBuilderCar : BuilderCar{  
2.    public void Engine(){  
3.       System.out.println("奥迪------Engine");        
4.    }  
5.    public  void Chassis(){  
6.       System.out.println("奥迪-----Chassis");  
7.    }  
8.    public void Carbody(){  
9.       System.out.println("奥迪-----Carbody");  
10.    }  
11.    public void Tire(){  
12.       System.out.println("奥迪-----Tire");                 
13.    }  
14.    public Car GetCar(){  
15.        return new Car("奥迪");    
16.    }  
17.   
18.   
19. }  

Director:

[java] view plain copy

1. public class ClentBLL {   
2.    private BuilderCar buildercar=null;  
3.    public ClentBLL(BuilderCar buildercar)  
4.    {  
5.      this.buildercar = buildercar;  
6.    }  
7.     
8.    public Car BuilderCar()  
9.    {  
10.       buildercar.Carbody();//车身  
11.       buildercar.Chassis();//底盘  
12.       buildercar.Engine();//发动机  
13.       buildercar.Tire();//轮胎  
14.       return buildercar.GetCar();  
15.     }   }  

Test

[java] view plain copy

1. public class Test{  
2.   public static void main(String[] args){  
3.      ClentBLL clentBLL = new ClentBLL(new 0000BuilderCar);  
4.      clentBLL.BuilderCar();  
5.            
6. }  

result:

奥迪------Engine

奥迪-----Chassis

奥迪-----Carbody

奥迪-----Tire"

应用优点

　　建造模式可以使得产品内部的表象独立变化。在原来的工厂方法模式中，产品内部的表象是由产品自身来决定的；而在建造模式中则是“外部化”为由建造者来负责。这样定义一个新的具体建造者角色就可以改变产品的内部表象，符合“开闭原则”。

　　建造模式使得客户不需要知道太多产品内部的细节。它将复杂对象的组建和表示方式封装在一个具体的建造角色中，而且由指导者来协调建造者角色来得到具体的产品实例。

　　每一个具体建造者角色是毫无关系的。

　　建造模式可以对复杂产品的创建进行更加精细的控制。产品的组成是由指导者角色调用具体建造者角色来逐步完成的，所以比起其它创建型模式能更好的反映产品的构造过程。

参考资料：

1.http://rainbowj234.diandian.com/post/2011-11-11/6662347

2.http://www.yesky.com/447/1903447.shtml

3.http://www.kaiyuanba.cn/html/1/131/138/7675.htm