创建类模式（三）：创建者（Builder）

定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这使得构件算法和组装方式可以独立应对变化；复用同样的构建算法可以创建不同的表示，不同的构建过程可以复用相同的部件组装方式。

和工厂模式的区别

1. 工厂模式注重的对象创建的结果，而创建者模式注重的对象创建的过程。
2. 与抽象工厂模式相比， 建造者模式返回一个组装好的完整产品 ，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。
3. 在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象。
4. 如果将抽象工厂模式看成汽车配件生产工厂 ，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂 ，通过对部件的组装可以返回一辆完整的汽车。

UML

优点

• 在创建者模式中，客户端不再负责对象的创建与组装，而是把这个对象创建的责任交给其具体的创建者类，把组装的责任交给组装类，客户端只负责对象的调用，从而明确了各个类的职责。

缺点

• 虽然利用创建者模式可以创建出不同类型的产品，但是如果产品之间的差异巨大，则需要编写多个创建者类才能实现，如果这是结合工厂模式更好。

应用场景

1. 需要生成的产品对象有复杂的内部结构。
2. 需要生成的产品对象的属性相互依赖，建造者模式可以强迫生成顺序。
3. 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到。

示例

通过创建者创建房子。

Java

import java.util.ArrayList;

public class Main
{
    public static void main(String[] args)
    {
        Director director=new Director();
        
        Builder chineseBuilder=new ChineseBuilder();
        director.construct(chineseBuilder);
        House chineseHouse=chineseBuilder.GetHouse();
        chineseHouse.show();
        
        Builder englandBuilder=new EnglandBuilder();
        director.construct(englandBuilder);
        House englandHouse=englandBuilder.GetHouse();
        englandHouse.show();
    }
    
    /**
     * 抽象建造者
     */
    public static abstract class Builder
    {
        public abstract void BuildDoor();
        public abstract void BuildWall();
        public abstract void BuildWindows();
        public abstract void BuildHouseCeiling();
        public abstract House GetHouse();
    }

    /**
     * 进行建造的产品
     */
    public static class House
    {
        private ArrayList<String> parts = new ArrayList<String>();
        
        public void add(String str)
        {
            parts.add(str);
        }
        
        public void show()
        {
            for(String part : parts)
            {
                System.out.println(part);
            }
            System.out.println("");
        }
    }

    /**
     * 导演类
     */
    public static class Director
    {
        public void construct(Builder builder)
        {
            builder.BuildDoor();
            builder.BuildWall();
            builder.BuildWindows();
            builder.BuildHouseCeiling();
        }
    }

    /**
     * 具体类型的建造者
     */
    public static class ChineseBuilder extends Builder
    {
        private House chineseHouse = new House();
        
        public void BuildDoor()
        {
            chineseHouse.add("ChineseDoor");
        }
        
        public void BuildWall()
        {
            chineseHouse.add("ChineseWall");
        }
        
        public void BuildWindows()
        {
            chineseHouse.add("ChineseWindows");
        }
        
        public void BuildHouseCeiling()
        {
            chineseHouse.add("ChineseHouserCeiling");
        }
        
        public House GetHouse()
        {
            return chineseHouse;
        }
    }

    /**
     * 具体类型的建造者
     */
    public static class EnglandBuilder extends Builder
    {
        private House englandHouse = new House();
        
        public void BuildDoor()
        {
            englandHouse.add("EnglandDoor");
        }
        
        public void BuildWall()
        {
            englandHouse.add("EnglandWall");
        }
        
        public void BuildWindows()
        {
            englandHouse.add("EnglandWindows");
        }
        
        public void BuildHouseCeiling()
        {
            englandHouse.add("EnglandHouserCeiling");
        }
        
        public House GetHouse()
        {
            return englandHouse;
        }
    }
}