建造者模式

建造者模式(Builder)也被称为生成器模式，将一个复杂对象的构造与它的表示分离，使得同样的构建过程可以创建不同的表示。

image

建造者模式中的角色：

• Director：导演类，负责安排已有模块的顺序，然后通知 Builder 开始构造。
• Builder：抽象 Builder 类，规范产品的组建，一般由子类实现。
• ConcreteBuilder：具体建造者，实现抽象 Builder 类定义的所有方法，并且返回一个组建好的对象。
• Product：产品类。

建造者模式的简单实现

(1) 创建产品类

public class Circle {

    private Point mPoint;
    private double mRadius;

    public void setPoint(Point Point) {
        this.mPoint = Point;
    }

    public void setRadius(double Radius) {
        this.mRadius = Radius;
    }

    public Point getPoint() {
        return mPoint;
    }

    public double getRadius() {
        return mRadius;
    }
}

public class Point {

    private double x;
    private double y;

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
}

(2) 创建 Builder 类

public abstract class Builder {
    public abstract void buildPoint(Point point);
    public abstract void buildRadius(double radius);
    public abstract Circle draw();
}

实现抽象 Builder 类。

public class DrawCircleBuilder extends Builder {

    private Circle circle = new Circle();

    @Override
    public void buildPoint(Point point) {
        circle.setPoint(point);
    }

    @Override
    public void buildRadius(double radius) {
        circle.setRadius(radius);
    }

    @Override
    public Circle draw() {
        return circle;
    }
}

(3) 用导演类来统一组装过程

public class Director {

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

    public Circle drawCircle(Point point, double radius) {
        mBuilder.buildPoint(point);
        mBuilder.buildRadius(radius);
        return mBuilder.draw();
    }
}

(4) 客户端调用导演类

public class DrawCircle {
    public static void main(String[] args) {
        Builder builder = new DrawCircleBuilder();
        Director director = new Director(builder);
        Point point = new Point();
        point.setX(10);
        point.setY(10);
        director.drawCircle(point, 10);
    }
}

建造者模式的使用场景

使用场景：
当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
相同的方法，不同的执行顺序，产生不同的事件结果时。
多个部件或零件都可以被装配到一个对象中，但是产生的运算结果又不同时。
产品类非常复杂，或者产品类中的调用顺序不同而产生不同的效能。
在创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定，但是对象的内部组成构件面临着复杂的变化。

建造模式的优缺点

优点：
使用建造模式可以使客户端不必知道产品内部组成的细节。
具体的建造类之间是相互独立的，容易扩展。
由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

缺点：产生多余的 Build 对象以及导演类。