java中的建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

介绍

• 意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
• 主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
• 何时使用：一些基本部件不会变，而其组合经常变化的时候。
• 如何解决：将变与不变分离开。
• 关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
• 应用实例：
  • 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。
  • 2、JAVA 中的 StringBuilder。
• 优点：
  • 1、建造者独立，易扩展。
  • 2、便于控制细节风险。
• 缺点：
  • 1、产品必须有共同点，范围有限制。
  • 2、如内部变化复杂，会有很多的建造类。
• 使用场景：
  • 1、需要生成的对象具有复杂的内部结构。
  • 2、需要生成的对象内部属性本身相互依赖。
• 注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

实现

使用 Builder 模式的实现，如图：

image

Product.java

public abstract class Product {
    protected List parts = new ArrayList();

    //添加部件
    public void add(String part){
        parts.add(part);
    }

    //显示产品信息
    public void show(){
        System.out.print("产品部件信息：");
        for(String part : parts){
            System.out.print(part + "\t");
        }
    }
}

Acer.java

public class Acer extends Product {
    
}

Dell.java

public class Dell extends Product {

}

Builder.java

public interface Builder {
    //CUP
    public void buildCPU();

    //内存
    public void buildMemory();

    //显卡
    public void buildDisplayCard();

    //最终产品
    public Product getFinalResult();
}

AcerBuilder.java

public class AcerBuilder implements Builder {
    private Product product = new Acer();

    @Override
    public void buildCPU() {
        product.add("CUP: Intel 酷睿i3 2350M");
    }

    @Override
    public void buildMemory() {
        product.add("内存: 4GB DDR3 1333MHz");
    }

    @Override
    public void buildDisplayCard() {
        product.add("显卡: NVIDIA GeForce GT 520M");
    }

    @Override
    public Product getFinalResult() {
        return product;
    }
}

DellBuilder.java

public class DellBuilder implements Builder {
    private Product product = new Dell();

    @Override
    public void buildCPU() {
        product.add("CUP: Intel 酷睿i7 3612QM");
    }

    @Override
    public void buildMemory() {
        product.add("内存: 8GB DDR3 1600MHz");
    }

    @Override
    public void buildDisplayCard() {
        product.add("显卡: NVIDIA GeForce GT 640M＋Intel GMA HD 4000");
    }

    @Override
    public Product getFinalResult() {
        return product;
    }
}

Director.java

public class Director {
    private Builder builder;

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

    public void construct() {
        builder.buildCPU();
        builder.buildMemory();
        builder.buildDisplayCard();
    }
}

Client.java

public class Client {

    private static Builder acerBuilder = new AcerBuilder(), dellBuilder = new DellBuilder();

    public static void main(String[] args) {

        System.out.print("宏基");
        Director director = new Director(acerBuilder);
        director.construct();
        Product product = acerBuilder.getFinalResult();
        product.show();

        System.out.println();

        System.out.print("戴尔");
        director = new Director(dellBuilder);
        director.construct();
        product = dellBuilder.getFinalResult();
        product.show();
    }
}

返回信息:

宏基产品部件信息：CUP: Intel 酷睿i3 2350M  内存: 4GB DDR3 1333MHz    显卡: NVIDIA GeForce GT 520M  
戴尔产品部件信息：CUP: Intel 酷睿i7 3612QM 内存: 8GB DDR3 1600MHz    显卡: NVIDIA GeForce GT 640M＋Intel GMA HD 4000    

在这里，Acer 类和 Dell 类是空的，如果是这种情况，那么它们可以省略掉，如果Product也不是最终想要的，那么它也可以被省略掉，最终剩下的就只有 Director、Builder、和具体的 Bulider 实现类。

在这里，Acer 类和 Dell 类是有关系的两个类，它们都是电脑的品牌之一，如果遇到两个或多个没有太多关系的类，假设 Acer 类代表电脑，Dell 类代表汽车，很明显，Acer 类和Dell 类就不应该再有共同的父类，也就是这种情况下，Product这个抽象类不存在了，这时候问题就来了，那么 Builder 接口的规定的 getFinalResult() 方法的返回值怎么确定呢？？

如果它的返回值类型是 Acer，那么 DellBuilder 类就会有问题，如果它的返回值类型是 Dell，那么 AcerBuilder 类就会有问题；

很明显，这是由于类型不能正确匹配引起的，如果是这种情况，可以将 Product 设计成标识接口（空接口，接口里面没有规定任何行为方法），再让这些没有相互关系的具体产品类

都去实现这个接口，那么 Builder 接口里面规定的 getFinalResult() 方法的返回值类型依然是 Product 类型，这样一来问题就解决了。

参考：http://www.blogjava.net/fancydeepin/archive/2012/08/05/384783.html