设计模式之创造者模式 Builder

1.简单介绍

 将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，而且客户端不用知道创建的过程，这样的设计模式被称为建造者模式。
 建造者模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态的创建具有复合属性的对象。

2.角色

在这样的设计模式中，有以下几个角色：
    1 builder：为创建一个产品对象的各个部件指定抽象接口。
    2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表
      示，并 提供一个检索产品的接口。
    3 Director：构造一个使用Builder接口的对象。
    4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包
      含定义组成部件的类，包括将这些部件装配成最终产品的接口。

3.示意图

 从示意图中我们看出：
     通过建造者模式，使得建造过程通过Director类的Construct函数固定了，即建造过程不会变；
     基类Builder中将各种Build函数定义为抽象方法，必须在子类中实现，这样使得过程不变，而且很利于系
     统的扩展，符合OCP原则；

4.优缺点

 优点：
     1.使用建造者模式可以使客户端不必知道产品内部组成的细节。
     2.具体的建造者类之间是相互独立的，对系统的扩展非常有利。
     3.由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。
 缺点：
     1.创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临 
     着复杂的变化。
     2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

5.示例代码

 建造者模式在薪酬计算中的应用：
 抽象工厂模式着重于一系列对象的创建，创造者模式着重于一系列对象的组装，其实质的区别在于对类的单一职能的遵守程度。

public abstract class Factory{
      protected  abstract  BasePay getBasePay();

      protected  abstract  Assurance getAssurance();

      protected  abstract  Bonus getBonus();

      protected  abstract  Tax getTax();
}

//定义合同工的工厂类
public class ContractFactory extends Factory{
     public BasePay getBasePay(){
        return new ContractBasePay();
     }
     public Assurance getAssurance(){
        return new ContractAssurance();
     }
     public Bonus getBonus(){
        return new ContractBounts();
     }
     public Tax getTax(){
        return new ContractTax();
     }
}

//定义劳务工的工厂类
public class WorkerFactory extends Factory{
     public BasePay getBasePay(){
        return new WorkerBasePay();
     }
     public Assurance getAssurance(){
        return new WorkerAssurance();
     }
     public Bonus getBonus(){
        return new WorkerBonus();
     }
     public Tax getTax(){
        return new WorkerTax();
     }
}

//定义薪资计算的接口
public interface BasePay{
    public String getBasePay(String name);
}

//定义合同工薪资计算
public class ContractBasePay implement BasePay{
   public String doBasePay(String name){
      return name + "基本薪资开始计算"
   }
}

//定义劳务工薪资计算
public class WorkerBasePay implement BasePay{
   public String doBasePay(String name){
      return name + "基本薪资开始计算"
   }
}

//定义奖金计算的接口
public interface Bonus{
    public String doBonus(String name);
}

//定义合同工奖金计算
public class ContractBonus implement Bonus{
   public String doBonus(String name){
      return name + "奖金开始计算"
   }
}

//定义劳务工奖金计算
public class WorkerBonus implement Bonus{
   public String doBonus(String name){
      return name + "奖金开始计算"
   }
}

//定义保险计算的接口
public interface Assurance{
    public String doAssurance(String name);
}

//定义合同工保险计算
public class ContractAssurance implement Assurance{
   public String doAssurance(String name){
      return name + "保险开始计算"
   }
}

//定义劳务工保险计算
public class WorkerAssurance implement Assurance{
   public String doAssurance(String name){
      return name + "保险开始计算"
   }
}

//定义个人所得税计算的接口
public interface Tax{
    public String doTax(String name);
}

//定义合同工保险计算
public class ContractTax implement Tax{
   public String doTax(String name){
      return name + "个人所得税开始计算"
   }
}

//定义劳务工保险计算
public class WorkerTax implement Tax{
   public String doTax(String name){
      return name + "个人所得税开始计算"
   }
}

public class Director{
    private Factory factory;

    public Factory getFactory(){
	    return factory;
	}

    public void setFactory(Factory factory){
	    this.factory = factory;
	}

	public String doSalary(String name){
          BasePay basepay = factory.getBasePay();
          Assurance assurance = factory.getAssurance();
          Bonus bonus = factory.getBonus();
          Tax tax = factory.getTax();
          retrun basepay.doBasePay(name) + "---" + assurance.doAssurance(name) +"---"+
                 bonus.doBonus() + "---" + tax.doTax();  
    }
}

public class Client{
	public static void main（String[] args）{
	    Director director = new Director();
	    director.setFactory(new WorkerFactory());
	    System.out.pritln(director.doSalary("劳务工"));
	}
}