设计模式（十一）——生成器模式

1.描述

将一组复杂对象的构建与他的表示相分离，使同样的构建过程可以创建不同的表示。

2.模式的使用

·产品(Product)：具体生成器要构造的复杂对象。

·抽象生成器(Builder)：一个接口，该接口除了为创建一个Product对象的各个组件定义了若干方法外，还要定义返回Product对象的方法。

·具体生成器(ConcreteBuilder)：实现Builder接口的类，具体生成器将实现Builder接口所定义的方法。

·指挥者(Director)：指挥者是一个类，该类需含有Builder接口声明的变量。指挥者的职责是负责向用户提供具体生成器，即指挥者将请求具体生成器来构造用户所需的Product对象，如果所请求的具体生成器成功的构造出Product对象，指挥者就可以让该具体生成器返回所构造的Product。

3.使用情景

·当系统准备为用户提供一个内部构造复杂的对象，而且构造方法中编写创建该对象的代码无法满足用户需求时，可以使用该模式。

·当某些系统要求对象的构造过程必须独立于创建该对象的类时。

4.优点

·将创建对象的构造过程封装在具体生成器中，使用户可以使用不同的具体生成器得到该对象的不同表示。

·生成器模式将对象的构造过程从创建对象的类中分离，使用户无需了解该对象的具体组件。

·可以精细控制对象的构造过程。生成器将对象的构造过程分解成若干步骤，这就使程序更加精细可控。

·讲对象的构造过程与创建对象的类解耦且满足“开——闭”原则

5.UML图

6案例

三角、圆、矩形为基础图形类。现在要求一个几何类，可以创建由三角、长方形组成的图形，也可以创建由原型、三角形，等等各种图形组合的图形。但是不希望几何类包含所有基础图形对象（三角、圆、矩形）的引用；而且几何类要满足产生特殊图形的要求，比如三角形为等边三角形，矩形为正方形等要求。为了方便扩展，可以这样使用生成器模式：

package 生成器模式;

import java.util.ArrayList;

public class test1 {

    public static void main(String[] args) {
        ConcreteBuilder1 cb = new ConcreteBuilder1();
        Geometry g = cb.createGeometry();
        System.out.println(g.getList().get(0).getName() + "面积是" + g.getList().get(0).getArea());
    }
}

abstract class abstractGeometry{
    public abstract double getArea();
    public abstract void setName(String name);
    public abstract String getName();
}

/*
 * 三角
 */
class Triangle extends abstractGeometry{
    long[] sides = new long[3];
    String name;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    Triangle(long side1, long side2, long side3){
        sides[0] = side1;
        sides[1] = side2;
        sides[2] = side3;
    }
    @Override
    public double getArea() {
        double p = (sides[0] + sides[1] + sides[2])/2;
        return Math.sqrt(p * (p - sides[0]) * (p - sides[1]) * (p - sides[2]));
    }
    //判断是否为等边三角形
    public boolean isEqu(){
        return sides[1] == sides[0] && sides[1] == sides[2] ? true : false;
    }
    //判断是否为直角三角形
    public boolean isReg(){
        return (Math.pow(sides[0], 2) + Math.pow(sides[1], 2)) == Math.pow(sides[2], 2) 
                || (Math.pow(sides[0], 2) + Math.pow(sides[2], 2)) == Math.pow(sides[1], 2) 
                || (Math.pow(sides[2], 2) + Math.pow(sides[1], 2)) == Math.pow(sides[0], 2) ? true :false;
    }
}

/*
 * 圆
 */
class Circle extends abstractGeometry{
    long radius;
    String name;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    Circle(long radius){
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
}

/*
 * 矩形
 */
class Rectangle extends abstractGeometry{
    long[] sides = new long[2];
    String name;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    Rectangle (long side1, long side2){
        sides[0] = side1;
        sides[1] = side2;
    }
    @Override
    public double getArea() {
        return sides[0] * sides[1];
    }
    //判断是否为正方形
    public boolean isSqu(){
        return sides[0] == sides[1] ? true : false;
    }
}

/*
 * 工厂
 */
interface abstractFactory{
    public abstractGeometry creatTriangle(long side1, long side2,long side3);
    public abstractGeometry creatCircle(long side);
    public abstractGeometry creatRectangle(long side1, long side2);
    public abstractGeometry creatEquTri(long side1, long side2,long side3);//等边三角形
    public abstractGeometry creatregularTri(long side1, long side2,long side3);//正三角形
    public abstractGeometry creatSquare(long side1, long side2);//正方形
}

/*
 * 具体工厂
 */
class Factory implements abstractFactory{
    //生产三角形
    public abstractGeometry creatTriangle(long side1, long side2,long side3) {
        if(side1 + side2  > side3 && side2 +side3 > side1){
            Triangle t = new Triangle(side1, side2, side3);
            t.setName("一个三角形");
            return t;
        }
        return null;
    }
    //生产圆形
    public abstractGeometry creatCircle(long radius) {
        Circle c = new Circle(radius);
        c.setName("一个圆");
        return c;
    }
    //生产矩形
    public abstractGeometry creatRectangle(long side1, long side2) {
        Rectangle r = new Rectangle(side1, side2);
        r.setName("一个矩形");
        return r;
    }
    //生产等边三角形
    public abstractGeometry creatEquTri(long side1, long side2,long side3) {
        Triangle t = (Triangle) this.creatTriangle(side1, side2, side3);
        if(t.isEqu()){
            t.setName("一个等边三角形");
            return t;
        }
        return null;
    }
    //生产直角三角形
    public abstractGeometry creatregularTri(long side1, long side2,long side3) {
        Triangle t = (Triangle) this.creatTriangle(side1, side2, side3);
        if(t.isReg()){
            t.setName("一个直角三角形");
            return t;
        }
        return null;
    }
    //生产正方形
    public abstractGeometry creatSquare(long side1, long side2) {
        Rectangle r = (Rectangle) this.creatRectangle(side1, side2);
        if(r.isSqu()){
            r.setName("一个正方形");
            return r;
        }
        return null;
    }
}

/*
 * 抽象生成器
 */
interface Builder{
    Factory factory = new Factory();
}

/*
 * 具体生成器
 */
class ConcreteBuilder1 implements Builder{
    Geometry  geometry;
    ConcreteBuilder1(){
        geometry = new Geometry();
    }
    
    public Geometry createGeometry(){
        geometry.getList().add(factory.creatTriangle(3, 4, 5));
        return geometry;
    }
}
/*
 * 产品
 */
class Geometry{
    private ArrayList<abstractGeometry> list;
    Geometry(){
        this.list = new ArrayList<abstractGeometry>();
    }
    public ArrayList<abstractGeometry> getList(){
        return this.list;
    }
}