（Builder）建造者模式的Java实现

//抽象产品类，使用了模板方法模式，不同产品有不同的“组成部分part” 
abstract  class AbstractProduct{ 
   protected  abstract  void part01(); 
   protected  abstract  void part02(); 
   protected  abstract  void part03(); 
    
   //模板方法给出了默认的组装方式，生成默认的产品 
   public  final AbstractProduct defaultProduct() { 
    part01(); 
    part02(); 
    part03(); 
     return  this;//返回当前对象，即默认组装方式的产品 
  } 
} 

//具体的产品A、B，不同产品实现了不同的“组成部分part” 
class ConcreteProductA  extends AbstractProduct{ 
   protected  void part01() { 
    System.out.println( "产品A ：part01() ..."); 
  } 
   protected  void part02() { 
    System.out.println( "产品A ：part02() ..."); 
  } 
   protected  void part03() { 
    System.out.println( "产品A ：part03() ..."); 
  } 
} 

class ConcreteProductB  extends AbstractProduct{ 
   protected  void part01() { 
    System.out.println( "产品B ：part01() ..."); 
  } 
   protected  void part02() { 
    System.out.println( "产品B ：part02() ..."); 
  } 
   protected  void part03() { 
    System.out.println( "产品B ：part03() ..."); 
  } 
} 

//抽象建造者，制定每一种产品应该实现的组合方式buildPart()和生产buildProduct()的标准 
abstract  class AbstractBuilder{ 
   public  abstract  void buildPart(); 
   public  abstract AbstractProduct buildProduct(); 
} 


/* 
* 具体建造者，如果对于默认产品（即当调用抽象产品中的defaultProduct()方法）不满意时， 
* 可以不调用它来获得产品，而是使用具体的建造者来改变产品的生产组装方式，以得到不同的产品 
*/ 
class ConcreteBuilderA  extends AbstractBuilder{ 
   private AbstractProduct productA =  new ConcreteProductA(); 
    
   public  void buildPart() { 
     this.productA.part03(); 
     this.productA.part02(); 
     this.productA.part01(); 
  } 
    
   public AbstractProduct buildProduct() { 
     return  this.productA; 
  } 
} 

class ConcreteBuilderB  extends AbstractBuilder{ 
   private AbstractProduct productB =  new ConcreteProductB(); 
    
   public  void buildPart() { 
     this.productB.part02(); 
     this.productB.part01(); 
     //特地省略掉产品B中的一个组成部分，例如该部分的功能顾客不需要 
//    this.productB.part03(); 
  } 
    
   public AbstractProduct buildProduct() { 
     return  this.productB; 
  } 
} 

//导演类，预先持有各个产品的建造者，为需要不同于默认产品的用户提供不同的组装方式 
class Director{ 
   private AbstractBuilder builderA =  new ConcreteBuilderA(); 
   private AbstractBuilder builderB =  new ConcreteBuilderB();    
    
   public AbstractProduct getProductA() { 
     this.builderA.buildPart(); 
     return  this.builderA.buildProduct(); 
  } 
    
   public AbstractProduct getProductB() { 
     this.builderB.buildPart(); 
     return  this.builderB.buildProduct(); 
  } 
} 

//测试类 
public  class Client { 
   public  static  void main(String[] args) { 
    System.out.println( "利用模板方法模式获得默认的产品A"); 
    AbstractProduct defualtProductA =  new ConcreteProductA().defaultProduct();    
     
    System.out.println( "\n利用Director类获得不同组装方式的产品A"); 
    Director director =  new Director(); 
    director.getProductA(); 
     
    System.out.println( "\n利用Director类获得不同组装方式的产品B"); 
    director.getProductB(); 
  } 
}