构造者模式

多种设计模式能够解决普通构造器不能解决的问题。
1.普通构造的挑战：
  突破题1：请列出Java构造器关于使用和行为的4条规则。
  答：(1)如果开发者没有为类提供构造器,那么Java将会为该类提供默认的构造器.
       (2)构造器的名字必须与类名相同。因而，构造器名字通常与其他方法名字不同，它的名字是以大写字母开头。这一点看起来有些怪异。
       (3)构造器可以使用this()方法和super()方法来调用其他构造器，但对this()和super()方法的调用必须是该构造器的第一条语句。
       (4)构造器执行结果会得到该类的一个实例，而常规方法的返回类型不受限制。
       (5)使用new或者反射来调用构造器。

  Java构造器除了会在没有显性声明构造器时提供一个默认的构造器之外，第2个默认提供的内容是，如果构造器声明没有使用this()或者super() 来显性地调用其他构造器，Java会自动添加不带参数的super()。这样做也许会带来意想不到的结果，比如下列代码将导致编译错误：
package app.construction;
public class Fuse
{
private String name;
public Fuse(String name) { this.name = name;}
}

以及如下代码：
package app.construction;
public class QuickFuse extends Fuse
{
}

编译器会报错，错误类似于：
QuickFuse.java:2: 找不到符号
符号： 构造函数 Fuse()
位置： 类 app.construction.Fuse
public class QuickFuse extends Fuse
       ^
1 错误

    当编译器遇到QuickFuse类时会报错，并为之提供一个默认构造器。默认构造器没有参数，也会不带参数调用超类的构造器。然而，接收String对象 参数的Fuse()构造器意味着编译器不再为Fuse类提供默认的构造器。QuickFuse的默认构造器不能调用没有参数的超类构造器，因为这个构造器 是不存在的。

    实例化对象的最常见方法是调用new操作符，但也可以使用反射(reflection)。反射允许将类型和类型成员作为对象使用。即使不经常使用反射，你也能够按照现成的程序来使用反射。下面就是一个例子：
package app.construction;
import java.awt.Point;
import java.lang.reflect.Constructor;
public class ShowReflection
{
     public static void main(String[] args)
     {
          Constructor[] cc = Point.class.getConstructors();
          Constructor cons = null;
          for(int i=0;i<cc.length;i++)
               if(cc[i].getParameterTypes().length == 2)
                   cons = cc[i];
          try
          {
               Object obj = cons.newInstance(new Object[] {new Integer(3),new Integer(4)});
          }catch(Exception e)
          {
               System.out.println("Exception : " + e.getMessage());
          }
     }
}

输出结果如下：
java.awt.Point[x=3,y=4]

我们成功地发现了具有两个参数的构造器，并使用其提供的参数创建一个新的点。

2. 小结：
   通常我们需要为自己开发的类提供构造器用于类的实例化。一个类的构造器之间可能会相互调用，从而相互合作完成初始化工作。类的每个构造器最终都会调用其超类的构造器。常见方式是使用new操作符来调用构造器，但是你也可以使用反射来实例化和使用对象。

3.超载普通构造：
  当我们设计新类时，Java构造器提供的种种特征可为我们提供很多选择。然而，使用构造器进行类的实例化要求我们必须事先知道需要实例化哪个类，以及实例 化的时候需要提供哪些参数。例如，在选择图形用户界面组件时，我们必须考虑该应用程序是运行在手持设备上，还是运行在大型显示设备上。另外，有时候虽然开 发人员知道该实例化哪个类，但他们并不知道必须提供哪些初始参数，或者知道需要哪些参数，但是不知道该使用什么样的格式。例如，开发人员可能需要根据对象 的休眠版本或文本版本构造出该对象。在上述这些情况下，普通的Java构造器是无法解决问题的，因而我们需要使用设计模式。

  下面分别描述了每种构造型模式的设计目的：

         如果你期望                              可应用模式
在构造对象之前逐步收集该对象与构造相关的信息 Builder模式
推迟确定所需要实例化的类 Factory Method模式
构造一系列具有某个公共特性的对象 Abstract Factory模式
根据给定的例子创建一个对象 Prototype模式
根据只包含对象内部状态的休眠版本来重新构造对象 Memento模式

   每种设计模式都有自己不同的应用场合。面向构造的设计模式可以使得客户代码能够在无需调用类的构造器的前提下构建一个新的对象。例如，当我们需要逐步获得构建一个对象所需的初始参数值的时候，可以应用生成器模式。





一、概述
      构造者模式（Builder Pattern）：构造者模式将一个复杂对象的构造过程和它的表现层分离开来，使得同样的构建过程可以创建不同的表示，又称为生成器模式。
    在软件系统 中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变 化，但是将它们组合在一起的算法确相对稳定。如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定 构建算法”不随着需求改变而改变？
      如果我们使用了构造者模式，那么用户就只需要指定需要构造的类型就可以得到它们，而具体的构造过程和细节就不需要知道了。
二、类图和图解
   

三、构造者模式解析
    Builder：是为创建一个Product对象的各个部件指定的抽象接口
    ConcreteBuilder：它是具体的构建者，实现Builder接口，构造和装配各个部件。
    Product：具体的产品
    Director：指挥者，它是构建一个使用Builder接口的对象。

四、实例代码

//产品类：
package com.javapatterns.builder;

public class Product{
    public Product(){
       // System.out.println("product is initing.");
    }
}
//抽象建造方法：
package com.javapatterns.builder;

abstract public class Builder{
    public abstract void buildPart1();

    public abstract void buildPart2();

    public abstract Product retrieveResult();
}
//具体的建造类：产品的零件制造
package com.javapatterns.builder;

public class ConcreteBuilder extends Builder{

    private Product product = new Product() ;
    public void buildPart1(){
        System.out.println("build part one.");
    }

    public void buildPart2(){
        System.out.println("build part two.");
    }

    public Product retrieveResult(){
        return product;
    }
}


//产品的建造过程：
package com.javapatterns.builder;

public class Director{
    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

   public void construct(){
        builder = new ConcreteBuilder();

        builder.buildPart1();

        builder.buildPart2();

        builder.retrieveResult();

        //continue with other code
    }
}


//测试：
package com.javapatterns.builder;

public class Client{

    private static Director director;

    private static Builder builder = new ConcreteBuilder();
      
    public void requestBuild(){
       // director = new Director(builder);
    }
  
     public static void main(String[] args) {
        director = new Director(builder);
        director.construct();
    }

}



一， 一般来说你要做一件复杂的事情的时候，把它分成多个小的部分来做是比较好的方法，
把每个小部分做完，然后结合成一个完整的事情。例如生产一辆汽车，你是一个个零件
生产完了，才组装成一辆辆汽车。这个就是建造模式的工作。
二，建造模式的角色
1、抽象建造者
2、具体构造者
3、导演者
4、产品角色
三、实现代码 ：
与上述代码相似