设计模式 --建造者模式

部分文字内容摘自网络;

建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

建造者模式使得建造代码与表示代码的分离,可以使客户端不必知道产品内部组成的细节,从而降低了客户端与具体产品之间的耦合度,下面通过类图来帮助大家更好地理清建造者模式中类之间的关系。

  1. 在建造者模式中,指挥者是直接与客户端打交道的,指挥者将客户端创建产品的请求划分为对各个部件的建造请求,再将这些请求委派到具体建造者角色,具体建造者角色是完成具体产品的构建工作的,却不为客户所知道。
  2. 建造者模式主要用于“分步骤来构建一个复杂的对象”,其中“分步骤”是一个固定的组合过程,而复杂对象的各个部分是经常变化的 
  3. 产品不需要抽象类,由于建造模式的创建出来的最终产品可能差异很大,所以不大可能提炼出一个抽象产品类。
  4. 在前面文章中介绍的抽象工厂模式解决了“系列产品”的需求变化,而建造者模式解决的是 “产品部分” 的需要变化。
  5. 由于建造者隐藏了具体产品的组装过程,所以要改变一个产品的内部表示,只需要再实现一个具体的建造者就可以了,从而能很好地应对产品组成组件的需求变化。
详细代码如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BuildFactoryModel
{
    class Program
    {
        static void Main(string[] args)
        {
            //指令,汽车制造者,制造一辆汽车
             Car newcar =  CarMaker.Instance.BuildAnCar();
            Console.ReadKey();
        }
    }
}

具体例子:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BuildFactoryModel
{
    /// <summary>
    /// 制造基类
    /// </summary>
    public abstract class Maker
    {
        /// <summary>
        /// 一个抽象的方法。所有制作者都实现这个方法
        /// </summary>
        /// <returns></returns>
        public abstract basicClass build();
        /// <summary>
        /// 一个虚函数。可以有子类方法来覆盖
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        virtual public basicClass build(string parm)
        {
            return new basicClass();
        }
    }
    /// <summary>
    /// 发动机制作者
    /// </summary>
    public class engineMaker : Maker
    {
        /// <summary>
        /// 建造一个发动机
        /// </summary>
        /// <returns></returns>
        public override basicClass build()
        {
            return new Enginer();
        }
    }
    /// <summary>
    /// 控制系统制作者
    /// </summary>
    public class consysMaker : Maker
    {
        /// <summary>
        /// 建造一个控制系统
        /// </summary>
        /// <returns></returns>
        public override basicClass build()
        {
            return new ControlSystem();
        }
    }

    /// <summary>
    /// 轮胎制作者
    /// </summary>
    public class wheelMaker : Maker
    {
        public override basicClass build()
        {
            return new Wheel();
        }
        /// <summary>
        /// 覆盖父类的建造方法,使用一个带参数
        /// (复习虚函数使用方法)
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public override basicClass build(string parm)
        {
            return new Wheel(parm);
        }
    }
    /// <summary>
    /// 控制系统制作者
    /// </summary>
    public class ControlSystemMaker : Maker
    {
        public override basicClass build()
        {

            return new ControlSystem();
        }
    }
    /// <summary>
    /// 座椅制作者
    /// </summary>
    public class ChairMaker : Maker
    {
        /// <summary>
        /// 制造座椅
        /// </summary>
        /// <returns></returns>
        public override basicClass build()
        {
            return new Chair();
        }
        /// <summary>
        /// 制造某个特定座椅
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public override basicClass build(string param)
        {
            return new Chair(param);
        }
    }

    /// <summary>
    /// 汽车制造者
    /// </summary>
    public class CarMaker
    {
        /// <summary>
        /// 汽车制造者需要的其他部件制作者
        /// </summary>
        /// 汽车铁框框制作者
        private static carframeMaker carframeMaker;
        /// <summary>
        /// 汽车座椅制作者
        /// </summary>
        private static ChairMaker ChairMaker;
        /// <summary>
        /// 汽车轮胎制作者
        /// </summary>
        private static wheelMaker wheelMaker;
        /// <summary>
        /// 汽车发动机制作者
        /// </summary>
        private static engineMaker engineMaker;
        /// <summary>
        /// 汽车控制系统制作者
        /// </summary>
        private static consysMaker consysMaker;

        /// <summary>
        /// 汽车制作者采用单例模式  静态属性,私有构造,
        /// 这里复习单例模式而已
        /// </summary>
        private static CarMaker _carMaker;
        public static CarMaker Instance { get {
            if (null == _carMaker) {
                _carMaker = new CarMaker();
            }
            return _carMaker;
        }
        }
        /// <summary>
        /// 私有构造函数中实例化这些部件制作者
        /// </summary>
        private CarMaker() {
            if (null == carframeMaker) {
                carframeMaker = new carframeMaker();
            }
            if (null == ChairMaker)
            {
                ChairMaker = new ChairMaker();
            }
            if (null == wheelMaker)
            {
                wheelMaker = new wheelMaker();
            }
            if (null == engineMaker)
            {
                engineMaker = new engineMaker();
            }
            if (null == consysMaker)
            {
                consysMaker = new consysMaker();
            }
        }

        /// <summary>
        /// 建造这个汽车方法
        /// </summary>
        /// <returns></returns>
        public Car BuildAnCar() {
            Car car = new Car();
            /// 制造铁壳
            car.carframe = (CarFrame)carframeMaker.build();
            //制造发动机
            car.enginer = (Enginer)engineMaker.build();                             
            //造四个座椅
            for (int i = 1; i <= 4; i++)
            {
                car.Chairs.Add((Chair)ChairMaker.build(i.ToString ()));
            }
            //造四个轮胎
            for (int i = 1; i <= 4; i++)
            {
                car.wheels.Add((Wheel)wheelMaker.build(i.ToString()));
            }
            //造控制系统
            car.controlsystem = (ControlSystem)consysMaker.build();
            return car;
        }
    }


    public class carframeMaker : Maker {
        public override basicClass build()
        {
            return  new CarFrame();
        }
    }
    /// <summary>
    /// 汽车类
    /// </summary>
    public class Car {
        public List<Wheel> wheels;
        public List<Chair> Chairs;
        public Enginer enginer;
        public ControlSystem controlsystem;
        public CarFrame carframe;

        public Car() {
            Chairs = new List<Chair>();
            wheels = new List<Wheel>();
        }
    }

    public class basicClass { 

    }

    /// <summary>
    /// 轮子
    /// </summary>
    public class Wheel :basicClass {
        public Wheel (){
            Console.WriteLine("Wheel is Ready!");
        }
        public Wheel(string WheelName){
            Console.WriteLine(string.Format( "Wheel {0} is Ready!",WheelName));
        }
    }
    /// <summary>
    /// 发动机实体类
    /// </summary>
    public class Enginer :basicClass{
        public Enginer() {
            Console.WriteLine("WEnginer is Ready!");
        }
    }
    /// <summary>
    /// 控制系统
    /// </summary>
    public class ControlSystem :basicClass{
        public ControlSystem() {
            Console.WriteLine("ControlSystem is Ready!");
        }
    }
    /// <summary>
    /// 座椅
    /// </summary>
    public class Chair :basicClass{
        public Chair() {
            Console.WriteLine("Chair is Ready!");
        }
        public Chair(string chairname)
        {
            Console.WriteLine(string.Format("Chair {0}is Ready!",chairname));
        }

    }

    /// <summary>
    /// 铁框框
    /// </summary>
    public class CarFrame : basicClass {
        public CarFrame()
        {
            Console.WriteLine("CarFrame is Ready!");
        }
    }

}


你可能感兴趣的:(设计模式,String,namespace,对象,建造者模式)