建造者模式的介绍和代码示例

    将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。建造者模式是一步一步创建一个复杂对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们。用户不知道具体的构建细节。

    建造者模式的具体的类之间的关系：一个director, 一个抽象Builder,一个具体建造者ConcreteBuilder, 若干个具体Product。用户直接和director打交道，得到相应的Product。而这个过程是这样的，客户向director描述想要的产品的细节，director指挥具体的建造者取出相应产品，用户由此得到相关产品。

    director类：构建一个使用Builder接口的对象。（里面只有一个方法用来构建Builder里的接口）。这个类的作用就是为了和客户打交道，客户只需要说明想要的产品的具体细节，director就直接吩咐Builder中的一员去取产品。如：麦当劳的收银员。

   抽象Builder类：使用抽象类或者接口来实现。主要是抽象出所有产品类的特性，为创建一个具体的product对象的各个部件指定抽象接口。如：麦当劳员工（抽象的）。

    具体的创建者ConcreteBuilder: 实现了Builder中的接口。如：麦当劳员工小王。

    具体Product：即客户所需要的产品。

   代码示例（C#）:

 

using System;
using System.Collections.Generic;
using System.Collections;


namespace MyStudy
...{
        class Shop
        ...{
            //用抽象类做参数，实现多态
            /**//*
             * 指挥者
             */
            public void Construct(VehicleBuilder vehicleBuilder)
            ...{
                vehicleBuilder.BuildFrame();
                vehicleBuilder.BuildEngine();
                vehicleBuilder.BuildWheels();
                vehicleBuilder.BuildDoors();
            }
        }

        /**//*
         * "Builder建造者"
         * 抽象建造者的四种方法
         * 装配框架
         * 装配发动机
         * 装配轮子
         * 装配车门
         */
        abstract class VehicleBuilder
        ...{
            protected Vehicle vehicle;
            //返回建造的车辆属性
            public Vehicle Vehicle
            ...{
                get
                ...{
                    return vehicle;
                }
            }

            abstract public void BuildFrame();
            abstract public void BuildEngine();
            abstract public void BuildWheels();
            abstract public void BuildDoors();
        }

        //具体建造者--摩托车车间
        class MotorCycleBuilder : VehicleBuilder
        ...{
            public override void BuildFrame()
            ...{
                vehicle = new Vehicle("摩托车");
                vehicle["frame"] = "MotorCycle Frame";
            }

            public override void BuildEngine()
            ...{
                vehicle["engine"] = "500 cc";
            }

            public override void BuildWheels()
            ...{
                vehicle["wheels"] = "2";
            }

            public override void BuildDoors()
            ...{
                vehicle["doors"] = "0";
            }
        }
        //具体建造者--轿车车间
        class CarBuilder : VehicleBuilder
        ...{
            public override void BuildFrame()
            ...{
                vehicle = new Vehicle("轿车");
                vehicle["frame"] = "Car Frame";
            }

            public override void BuildEngine()
            ...{
                vehicle["engine"] = "2500 cc";
            }

            public override void BuildWheels()
            ...{
                vehicle["wheels"] = "4";
            }

            public override void BuildDoors()
            ...{
                vehicle["doors"] = "4";
            }
        }

        //具体建造者--单脚滑行车车间
        class ScooterBuilder : VehicleBuilder
        ...{
            public override void BuildFrame()
            ...{
                vehicle = new Vehicle("单脚滑行车");
                vehicle["frame"] = "Scooter Frame";
            }

            public override void BuildEngine()
            ...{
                vehicle["engine"] = "none";
            }

            public override void BuildWheels()
            ...{
                vehicle["wheels"] = "2";
            }

            public override void BuildDoors()
            ...{
                vehicle["doors"] = "0";
            }
        }

        //车辆产品类
        class Vehicle
        ...{
            private string type;
            private Hashtable parts = new Hashtable();
            //构造函数，决定类型
            public Vehicle(string type)
            ...{
                this.type = type;
            }
            //索引
            public object this[string key]
            ...{
                get
                ...{
                    return parts[key];
                }
                set
                ...{
                    parts[key] = value;
                }
            }
            //显示方法
            public void Show()
            ...{
                Console.WriteLine(" -------------------------");
                Console.WriteLine("车辆类类型："+type);
                Console.WriteLine("框架：" + parts["frame"]);
                Console.WriteLine("发动机：" + parts["engine"]);
                Console.WriteLine("#轮子数：" + parts["wheels"]);
                Console.WriteLine("#车门数：" + parts["doors"]);
            }
        }

        /**//// <summary>
        /// 建造者模式应用测试
        /// </summary>
        /**//*
         * 客户
         */
        class CarShop
        ...{
            [STAThread]
            static void Main(string[] args)
            ...{
                //创建车间及指挥者
                Shop shop = new Shop();
                VehicleBuilder b1 = new ScooterBuilder();//抽象类的作用 大多用于做方法参数
                VehicleBuilder b2 = new CarBuilder();
                VehicleBuilder b3 = new MotorCycleBuilder();
                //装配并显示车辆
                shop.Construct(b1);
                b1.Vehicle.Show();
                shop.Construct(b2);
                b2.Vehicle.Show();
                shop.Construct(b3);
                b3.Vehicle.Show();
                Console.Read();
            }
        }
    }

    代码示例（Java）：

Director根据客户传来的参数，创建不同的House

package Builder;
public class Director 
...{
    public IHouse BuildHouse(boolean mblnBackyard)
    ...{
        if(mblnBackyard)
        ...{
            return new SingleFamilyHome();
        }
        else
        ...{
            return new Apartment();
        }
    }
}

房间类（和模式的角色无关，主要是为房间提供父类）

 

package Builder;

public class Room 
...{
    public String RoomName;
}

房间类型一：Aparment

package Builder;
import java.util.*;

public class Apartment implements IHouse
...{
    private boolean mblnBackyard;
    private Vector Rooms;
    
    public Apartment()
    ...{
        Room room = new Room();
        Rooms = new Vector();
        room.RoomName = "Master Room";
        Rooms.addElement(room);
        room = new Room();
        room.RoomName = "Second Bedroom";
        Rooms.addElement(room);
        room = new Room();
        room.RoomName = "Living room";
        Rooms.addElement(room);
        mblnBackyard = false; 
    }
    
    public boolean GetBackyard()
    ...{
        return mblnBackyard;
    }
    
    public long NoOfRooms()
    ...{
        return Rooms.size();
    }
    
    public String Description()
    ...{
        String strDescription;
        strDescription = "这是一间公寓，有" + Rooms.size() + "间房间 ";
        strDescription = strDescription + "这间公寓没有后院";
        for(int i = 1; i<=Rooms.size();i++)
        ...{
            strDescription = strDescription + " " + "房间" + i + " " +((Room)Rooms.elementAt(i-1)).RoomName;
        }
        return strDescription;
    }
}

房间类型二：SingleFamilyHome

package Builder;
import java.util.*;
public class SingleFamilyHome implements IHouse
...{
    private boolean mblnBackyard;
    private Vector Rooms;
    public SingleFamilyHome()
    ...{
        Room room = new Room();
        Rooms = new Vector();
        room.RoomName = "Master BedRoom";
        Rooms.addElement(room);
        room = new Room();
        room.RoomName = "Second Bedroom";
        Rooms.addElement(room);
        room = new Room();
        room.RoomName = "Thrid Bedroom";
        Rooms.addElement(room);
        room = new Room();
        room.RoomName = "Living room";
        Rooms.addElement(room);
        room = new Room();
        room.RoomName = "Guest room";
        Rooms.addElement(room);
        mblnBackyard = true;
    }
    
    public boolean GetBackyard()
    ...{
        return mblnBackyard;
    }
    public long NoOfRooms()
    ...{
        return Rooms.size();
    }
    public String Description()
    ...{
        String strDescription;
        strDescription = "这是一间公寓，有" + Rooms.size() + "间房间 ";
        strDescription = strDescription + "这间房子有后院 ";
        for(int i = 1;i<=Rooms.size();i++)
        ...{
            strDescription = strDescription + " " + "房间" + i + " " +((Room)Rooms.elementAt(i-1)).RoomName;
        }
        return strDescription;
    }
}

客户类：

package Builder;
public class Client ...{
    public static void main(String[] args) ...{
        Director director = new Director();
        IHouse house = director.BuildHouse(true);
        System.out.println(house.Description());
    }
}

输出：

这是一间公寓，有5间房间
这间房子有后院

房间1 Master BedRoom
房间2 Second Bedroom
房间3 Thrid Bedroom
房间4 Living room
房间5 Guest room