生成器模式属于对象结构型模式，其意图是将一个复杂对象的构建与他的表示分离，使得同样的构建创建过程可以创建不同的表示。
适用性：
1.          当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时
2.          当构造过程必须允许被构造的对象有不同的表示时。
 
参与者:
       生成器Builder:为创建一个Product对象的各个部件指定抽象接口(AnimalBuilder)。
       具体生成器ConcreteBuilder:实现Builder接口一构造和装配该产品的各个部件。
                     定义并明确他所创建的表示，
                     提供一个检索产品的接口(getAnimal)。
导向器：构建一个适用Builder对象的接口。
Product（Checken,pig）:表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终的产品。
图1
当客户需要一个产品时，把需要的参数传递个导向器，导向器根据传递的参数调用具体的生成器，具体的生成器通过一系列的操作 (getAnimal() 通过调用其它的接口方法实现 ) 最会返回一个产品。
Bridge 模式的优点：
1.          它使你可以改变一个产品的内部表示， Builder 对象提供给导向器一个构造产品的抽象接口，该接口使得生成器可以隐藏这个产品的表示和内部结构，他同时也隐藏了该产品是如何装配的，因为产品时通过抽象接口构造的 ( 注：本例子把接口的实现放在具体类中了 ) ，你在改变该产品的内部表示时所要做的只是定义一个新的生成器。
2.          他将构造代码和表示代码分开，这有点类似于模板模式。所不同的是模版模式最终是完成复杂的工作，而生成器的目的是要生成一个复杂的对象。
3.          他使得你对构造过程进行更加精细的控制。 Builder 模式是在导向者的控制下一步一步构造产品的，仅当该产品完成时，导向者才从生成器中取回产品。因此 Builder 模式能更好的反映产品的构造过程，使你可以更精细的控制构建过程，从而能更精细的控制所的产品的内部结构。
代码示例 :
AnimalBuilder ：代码
package  builder;
public   interface  AnimalBuilder{
     public   void  buildName();
     public   void  buildLegs();
     public   void  buildMeat();
     public  Animal getAnimal();
}
ChickenBuilder 的 代码：
package  builder;
public   class  ChickenBuilder  implements  AnimalBuilder{
     private  Animal  chicken  =  null ;
     public  ChickenBuilder(){
        chicken  =  new  Animal();
    }
     public   void  buildName(){
        chicken .setName( "chicken" );
    }
     public   void  buildLegs(){
        chicken .setLegs(2);
    }
     public   void  buildMeat(){
        chicken .setMeat( "chicken" );
    }
     public  Animal getAnimal(){
       buildName();
       buildLegs();
       buildMeat();
        return   chicken ;
    }
}
Animal 代码：
package  builder;
public   class  Animal{
     private  String  name ;
     private  String  meat ;
     private   int   legs ;
     public  String getName(){
        return   name ;
    }
     public  String getMeat(){
        return   meat ;
    }
     public   int  getLegs(){
        return   legs ;
    }
     public   void  setName(String aName){
        name  = aName;
    }
     public   void  setMeat(String aMeat){
        meat  = aMeat;
    }
     public   void  setLegs( int  alegs){
        legs  = alegs;
    }
}
Director 代码：
package  builder;
public   class  Director{
     public  Animal getAnimal(String aName){
        if (aName.equals( "chicken" )){
            return   new  ChickenBuilder().getAnimal();
       }
        else   if (aName.equals( "pig" )){
            return   new  PigBuilder().getAnimal();
       }
        else   return   null ;
    }
}
 
客户端代码：
package  builder;
public   class  Client{
     public   static   void  description(Animal animal){
       String desc =  "This animal is called " +animal.getName();
       desc += "\n Its meat is " +animal.getMeat();
       desc += "\n And it has " +animal.getLegs()+ " legs." ;
       System. out .println(desc);
    }
     public   static   void  main(String[] args){
       String aName =  "chicken" ;
       Director d =  new  Director();
       Animal animal =d.getAnimal(aName);
       description(animal);
       aName =  "pig" ;
       animal = d. getAnimal (aName);
       description(animal);
    }
}
结论：生成器模式使得客户可以更加精细的控制一个对象的构建，每个具体的创建者包含了创建和装配一个特定产品的所有代码，这些代码只用写一次，便可以被不同的 Director 使用，从而可以装配出不同的对象。