C++模式设计之Builder
第十五章 C++ Builder资料库程式设计概念
15-2. SQL语法
范例:
– 依照部门别计算每个部门的平均薪资. Select Avg(薪水) From 员工资料表 Group By 部门别 – 依照薪水高低对员工资料表内容进行排序. Select 员工代码, 员工姓名, 薪水, 部门别 From 员工资料表 Order By 薪水 Desc 注:Desc为递减排序,Asc为递增排序
15-2. SQL语法
SQL语法包含了DDL(资料定义语言),DML(资料处理语言)和 DCL(资料控制语言)三部分.
– DDL (Data Definition Language)语言主要用来定义资料库中各资料表 的一些相关资讯. – DML (Data Manipulation Language)语言主要是针对资料表内的资料 进行处理. – DCL (Data Control Language)语言主要用途为改变使用权限和一些安 全相关的设定 .
15-1. 资料库简介
资料库中的组成单位为资料表 资料表,每个资料表内存放著使用者所输入的一笔 资料表 笔资料,称为纪录 纪录,而每笔纪录又包含了数个栏位 栏位,分别指定不同资料型 纪录 栏位 态的资料,整个示意图可以如下所示:
15-1. 资料库简介
资料库系统除了能储存大量的资料外,和同样能储存资料的 传统档案系统相比,还有以下几个特色:
DML语法:针对资料表内的资料进行处理,包括
– – – – 撷取资料库内资料表的内容 新增,删除记录至资料库中 更新资料库中的资料 常用的关键字有 Insert ( 新增资料记录 ) Delete ( 删除资料记录 ) Update ( 更新资料记录 ) Select ( 选取资料记录 )
15-2. SQL语法
DDL语法
C++设计模式-Builder建造者模式
作用:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
Builder模式和AbstractFactory模式在功能上很相似,因为都是用来创建大的复杂的对象,它们的区别是:Builder模式强调的是一步步创建对象,并通过相同的创建过程可以获得不同的结果对象,一般来说Builder模式中对象不是直接返回的。
而在AbstractFactory模式中对象是直接返回的,AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。
适用于以下情况:1)当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2)当构造过程必须允许被构造的对象有不同的表示时。
UML图如下:Builder:定义创建对象过程的抽象,提供构建不同组成部分的接口其中:BuildPartA,BuildPartB,BuildPartC是对一个对象不同部分的构建函数接口,由Builder 的派生类ConcreteBuilder1、ConcreteBuilder2来具体实现.另外还有一个需要注意的函数,就是Director::Construct函数,这个函数里面通过调用上面的接口函数完成对象的构建--也就是说各个不同部分装配的过程都是一致的(同样的调用的Construct函数),但是不同的构建方式会有不同的表示(根据Builder的实际类型来决定如何构建,也就是多态)Builder模式是基于这样的一个情况:一个对象可能有不同的组成部分,这几个部分的不同的创建对象会有不同的表示,但是各个部分之间装配的方式是一致的.比方说一辆单车,都是由车轮车座等等的构成的(一个对象不同的组成部分),不同的品牌生产出来的也不一样(不同的构建方式).虽然不同的品牌构建出来的单车不同,但是构建的过程还是一样的也就是说,Director::Construct函数中固定了各个组成部分的装配方式,而具体是装配怎样的组成部分由Builder的派生类实现.实现:Builder模式的实现基于以下几个面向对象的设计原则:1)把变化的部分提取出来形成一个基类和对应的接口函数,在这里不会变化的是都会创建PartA 和PartB,变化的则是不同的创建方法,于是就抽取出这里的Builder基类和BuildPartA,BuildPartB接口函数2)采用聚合的方式聚合了会发生变化的基类,就是这里Director聚合了Builder类的指针.以上,通过两个派生类ConcreteBuilder1、ConcreteBuilder2定义了两种不同的建造细节(建造步骤是一样的,由Construct函数确定),通过两个派生类所建造出来的对象,对外部所展现出来的属性或者功能是不一样的,由各自Builder派生类中的建造方法(BuildPartA、BuildPartB、BuildPartC)决定。
C++builder 窗体设计
第4讲窗体设计1 基本概念C++ Builder应用程序的界面主要是通过窗体来设计的。
窗体是C++ Builder构造程序的基础,是其它VCL组件的容器。
在一定意义上,可以认为:程序在运行时的窗体就是窗口。
PS:在Windows编程中,窗体和窗口是两个不同的概念。
窗体只是窗口的一个子集,按钮、菜单、单选框等都是一个窗口。
Windows系统可以识别窗口,并为窗口的操作调用函数。
当系统有事件发生,通知消息会发往相应的窗口,由窗口做出相应的响应。
也就是说,系统的每个窗口均有相应的函数来处理窗口的所有事件。
PS:在Windows系统中,有一个内核对象包含着每个应用程序所建立的窗口的列表,并赋给每个窗口一个唯一的值,这个值称为窗口的句柄(Handle)。
大部分应用程序都是通过窗体上的文字、图形图像、选择按钮以及菜单、工具条等控件和用户进行交互的。
目前,随着多媒体和因特网的发展,窗体也顺应这种趋势,较以往的窗体有了一些改变。
窗体设计器是C++ Builder最实用、功能最强大的特征之一,它也是C++ Builder可视化开发环境的表现。
使用窗体设计器,可以简单便捷地创建几乎所有的交互界面。
2 窗体的常用属性在C++ Builder中,窗体是从TForm类继承的子类的对象,TForm类是VCL中的标准窗体类,它代表了一个空的窗体。
TForm类有下列常用的属性(不要强制记忆,用熟了自然会记住。
现在记不住怎么办?查帮助。
):●AlphaBlend属性该属性用来设置窗体是否以半透明的方式来显示。
●AlphaBlendValue属性该属性指定了窗体以半透明方式显示时的透明度。
●BorderIcons属性该属性指定了窗体是否具有最小化、最大化、关闭等系统按钮。
●BorderStyle属性该属性指定了窗体边界的特性,如是否为可调整大小等。
●Caption属性该属性指定了窗体的标题。
我们在第一讲中已经使用到了此属性。
●ClientHeight属性该属性用于设置窗体客户区的高度,单位为像素。
设计模式(六)——建造者模式(源码StringBuilder分析)
设计模式(六)——建造者模式(源码StringBuilder分析)建造者模式1 盖房项⽬需求1) 需要建房⼦:这⼀过程为打桩、砌墙、封顶2) 房⼦有各种各样的,⽐如普通房,⾼楼,别墅,各种房⼦的过程虽然⼀样,但是要求不要相同的.3) 请编写程序,完成需求.2 传统⽅式解决盖房需求1) 思路分析(图解)2) 代码AbstractHouse类package com.lin.bulider;public abstract class AbstractHouse {public abstract void bulidBasc();public abstract void bulidWalls();public abstract void bulidRoof();public void bulid() {bulidBasc();bulidWalls();bulidRoof();}}class CommonHouse extends AbstractHouse{@Overridepublic void bulidBasc() {System.out.println("普通房⼦打地基!");}@Overridepublic void bulidWalls() {System.out.println("普通房⼦砌墙!");}@Overridepublic void bulidRoof() {System.out.println("普通房⼦封顶!");}}class HighBuilding extends AbstractHouse{@Overridepublic void bulidBasc() {System.out.println("⾼楼⼤厦打地基!");}@Overridepublic void bulidWalls() {System.out.println("⾼楼⼤厦砌墙!");}@Overridepublic void bulidRoof() {System.out.println("⾼楼⼤厦封顶!");}}Client类package com.lin.bulider;public class Client {public static void main(String[] args) {CommonHouse commonHouse = new CommonHouse();commonHouse.bulid();}}3 传统⽅式的问题分析1) 优点是⽐较好理解,简单易操作。
C#设计模式之建造者设计模式(Builde)
产品(Product)角色:产品便是建造中的复杂对象。
指导者角色是于客户端打交道的角色。导演者角色将客户端创建产品的请求划分为对各个零件的建造请求,再将这些请求委派给具体建造者角色。具体建造者角色是做具造者(Builder)模式
建造者模式可以将一个产品的内部表象与产品的生成过程分割开来,从而可以使一个建造过程生成具有不同的内部表象的产品对象。
对象性质的建造
有些情况下,一个对象会有一些重要的性质,在它们没有恰当的值之前,对象不能作为一个完整的产品使用。比如,一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分,而在最起码的收件人地址未被赋值之前,这个电子邮件不能发出。
具体建造者(Concrete Builder)角色:担任这个角色的是于应用程序紧密相关的类,它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括:
实现Builder角色提供的接口,一步一步完成创建产品实例的过程。
在建造过程完成后,提供产品的实例。
指导者(Director)角色:担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识,真正拥有产品类的具体知识的是具体建造者对象。
命名的考虑
之所以使用"建造者"而没有用"生成器"就是因为用零件生产产品,"建造"更为合适,"创建"或"生成"不太恰当。
二、Builder模式的结构:
建造者(Builder)角色:给出一个抽象接口,以规范产品对象的各个组成成分的建造。一般而言,此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者(ConcreteBuilder)角色。具体建造者类必须实现这个接口所要求的方法:一个是建造方法,另一个是结果返还方法。
原创]C++builder组件属性详解
原创]C++builder组件属性详解尽管C++Builder的组件种类繁多,每种组件又都有许多不同的属性,但是在这些众多的属性中有相当一部分是大多数组件所共有的。
因此我们应当主要掌握这些共有组件。
在设计时设置属性一般是通过属性窗口来进行的。
在属性窗口设置组件属性的操作步骤如下:1)打开相应对象的属性窗口。
2)从属性列表中选定属性名称。
3)在属性窗口的右列输入或选择新的属性值。
注意:有些属性在设置值右侧有…按钮,单击该按钮会出现相应的设置对话框,设置值需要在对话框中选定。
在代码中设置组件属性的方法是:对象名称->属性名称=设置值;下面我们来介绍一些主要组件的主要属性。
窗体form的属性:1.Caption:标题。
是窗体和各种可视化控件的共有属性,用来指定窗体标题栏中的说明文字,默认与控件名相同,但程序员可以在对象监视器和代码中修改。
在代码中修改的格式为:Form->Caption = "da";// da表示程序员输入的标题。
通常,对于Windows系统中的多文档界面( MDI )应用程序,当主框架窗口中的子窗口以最大化显示的时候,应用程序的标题栏中显示的内容为“ <应用程序名> - <打开的文档名>”;当子窗口以非最大化窗口显示的时候,主框架窗口中只显示应用程序的名称,子窗口有自己的标题栏,其中显示该窗口打开的文件名。
所以,当窗体的显示方式发生了改变后,应该立即改变标题栏中的内容。
2.Name:变量名。
是窗体和所有控件的共有属性,系统给予其默认名字,但程序员可以在对象监视器修改,不要在代码中修改。
通常,应该在系统开发的设计阶段就将整个工程中所有窗体的名称确定,然后在编程阶段,根据设计文档修改窗体的Name属性。
一般情况下,不要在程序运行期间通过代码修改Name属性。
3.Enabled:可操作性。
决定了对象在运行时是否允许用户进行操作。
它是逻辑型:true表示允许用户操作并可对其操作作出响应;false表示禁止用户操作,此时对象呈灰色。
设计模式之构建者(Builder)模式
设计模式之构建者(Builder)模式 在五⼤设计原则的基础上经过GOF(四⼈组)的总结,得出了23种经典设计模式,其中分为三⼤类:创建型(5种)、结构型(7种)、⾏为型(11种)。
今天对创建型中的构建者(Builder)模式的思想进⾏了⼀下复习和实践,在此做⼀下记录。
理解或实践不到位的地⽅,希望⾛过路过的看官指正⼀下! 先来看看构建者(Builder)模式的定义: Separate the construction of a complex object from its representation,so that the same construction process can create different representations. 意思就是说:将复杂对象的构造与其表⽰分离,以便相同的构造过程可以创建不同的表⽰。
也就是当⼀个对象⽐较复杂,⽽且每次的构造过程⼜相同的时候,可以考虑⼀下使⽤构建者模式。
今天重新复习该模式的思想后,中午出去吃饭刚好接到“阿尔法.罗密欧”的汽车销售⼴告,背后有Giulia的配置表。
咋⼀看这汽车整车构造:尺⼨和重量、发动机、轮圈和底盘、安全技术....⼀⼤堆的部件和参数,确实够复杂的哈,再想想汽车的⽣产和组装过程⼏乎也可以说是相同的。
以汽车和其⽣产组装过程作为实践构建者(Builder)模式的例⼦应该⽐较能说清楚!那就撸起袖⼦码起来,为是简单起见我把汽车和相关部件定义的⽐较粗陋,构建过程也很简陋,但应该能很好的说明构建者(Builder)模式的应⽤场景和原理了! 先将复杂对象——汽车(Car)的主要部件(底盘、发动机、变速箱、轮胎、车⾝)定义⼀下:///<summary>///底盘///</summary>[Serializable]public class Chassis{///<summary>///轴距(前后轮之车轮轴距离)///</summary>public int Wheelbase { get; set; }///<summary>///驱动⽅式<see cref="DriveMode"/>///</summary>public DriveMode DriveMode { get; set; }///<summary>///初始化底盘///</summary>public Chassis() { }///<summary>///初始化底盘(带参)///</summary>///<param name="wheelbase">轴距(前后轮之车轮轴距离)</param>///<param name="driveMode">驱动⽅式<see cref="DriveMode"/></param>public Chassis(int wheelbase, DriveMode driveMode){Wheelbase = wheelbase;DriveMode = driveMode;}///<summary>///格式化输出底盘信息///</summary>///<returns>底盘信息</returns>public override string ToString(){StringBuilder sb = new StringBuilder();sb.AppendLine(string.Format("轴距(mm):{0}", Wheelbase));sb.AppendLine(string.Format("驱动⽅式:{0}", Enum.GetName(typeof(DriveMode), DriveMode)));return sb.ToString();}}///<summary>///发动机接⼝///</summary>public interface IEngine{///<summary>///喷油///</summary>///<param name="fuelQuantity">燃油量</param>void FuelInjection(double fuelQuantity);///<summary>///进(氧)⽓///</summary>///<param name="oxygenValue">氧⽓值</param>void OxygenIntake(double oxygenValue);///<summary>///点⽕启动///</summary>///<returns>是否动启成功</returns>bool IgnitionStart();///<summary>///做功并输出动⼒///</summary>///<returns>输出的动⼒值</returns>double Work();}///<summary>///发动机///</summary>[Serializable]public class Engine : IEngine{///<summary>///喷油量///</summary>protected double fuelQuantity;///<summary>///进(氧)⽓量///</summary>protected double oxygenValue;///<summary>///是否已启动///</summary>protected bool isStarted = false;///<summary>///汽缸数///</summary>public int CylinderNumber { get; set; }///<summary>///单缸⽓门数///</summary>public int ValveNumber { get; set; }///<summary>///总⽓门数///</summary>public int TotalValveNumber{get{return CylinderNumber * ValveNumber;}}///<summary>///冷却⽅式<see cref="CoolingMode"/>///</summary>public CoolingMode CoolingMode { get; set; }///<summary>///初始化发动机///</summary>public Engine() { }///<summary>///初始化发动机(带参)///</summary>///<param name="cylinderNumber">汽缸数</param>///<param name="valveNumber">单缸⽓门数</param>///<param name="coolingMode">冷却⽅式<see cref="CoolingMode"/></param>public Engine(int cylinderNumber, int valveNumber, CoolingMode coolingMode){CylinderNumber = cylinderNumber;ValveNumber = valveNumber;CoolingMode = coolingMode;}///<summary>///格式化输出发动机信息///</summary>///<returns>发动机信息</returns>public override string ToString(){StringBuilder sb = new StringBuilder();sb.AppendLine(string.Format("汽缸数量:{0}", CylinderNumber));sb.AppendLine(string.Format("⽓门数量:{0}", TotalValveNumber));sb.AppendLine(string.Format("冷却⽅式:{0}", Enum.GetName(typeof(CoolingMode), CoolingMode)));return sb.ToString();}///<summary>///喷油///</summary>///<param name="fuelQuantity">燃油量</param>public virtual void FuelInjection(double fuelQuantity){this.fuelQuantity = fuelQuantity;}///<summary>///进(氧)⽓///</summary>///<param name="oxygenValue">氧⽓值</param>public virtual void OxygenIntake(double oxygenValue){this.oxygenValue = oxygenValue;}///<summary>///点⽕启动///</summary>///<returns>是否动启成功</returns>public virtual bool IgnitionStart(){if (fuelQuantity <= 0){isStarted = false;throw new Exception("发动机点⽕失败,燃油不⾜或喷油系统故障!");}if (oxygenValue <= 0){isStarted = false;throw new Exception("发动机点⽕失败,⽓门关闭或⽓门系统故障!");}isStarted = true;Console.WriteLine("启动成功,发动机正常⼯作!");return isStarted;}///<summary>///做功并输出动⼒///</summary>///<returns>输出的动⼒值</returns>public virtual double Work(){if (isStarted){if (fuelQuantity <= 0){isStarted = false;throw new Exception("发动机熄⽕,燃油不⾜或喷油系统故障!");}if (oxygenValue <= 0){isStarted = false;throw new Exception("发动机熄⽕,⽓门关闭或⽓门系统故障!");}//这⾥只做简单的假设性能量转换if (CoolingMode.Equals(CoolingMode.WaterCooling)){return fuelQuantity * oxygenValue * CylinderNumber * TotalValveNumber * 0.85; }else{return fuelQuantity * oxygenValue * CylinderNumber * TotalValveNumber * 0.75; }}else{Console.WriteLine("发动机未启动!");return0;}}}///<summary>///变速箱动⼒输出结构///</summary>[Serializable]public struct GearboxOutput{///<summary>///驱动轮转矩///</summary>public double Torque;///<summary>///转速///</summary>public double Speed;///<summary>///传动⽅向///</summary>public TransmitDirection direction;}///<summary>///变速箱接⼝///</summary>public interface IGearBox{///<summary>///根据当前变速箱所挂档位、传动⽅向和所连接的发动机进⾏动⼒传输///</summary>///<param name="engine">连接的发动机</param>///<returns>动⼒传输结果</returns>GearboxOutput TransmitPower(IEngine engine);}///<summary>///变速箱///</summary>[Serializable]public class Gearbox : IGearBox{///<summary>///变速箱类型<see cref="GearboxType"/>///</summary>public GearboxType GearboxType { get; set; }///<summary>///当前档位(会影响动⼒传送)<see cref="GearPosition"/>///</summary>public GearPosition CurrentPosition { get; set; }///<summary>///传动⽅向<see cref="TransmitDirection"/>///</summary>public TransmitDirection TransmitDirection { get; set; }///<summary>///初始化变速箱///</summary>public Gearbox() { CurrentPosition = GearPosition.N; }///<summary>///初始化变速箱(带参)///</summary>///<param name="gearboxType">变速箱类型<see cref="GearboxType"/></param>public Gearbox(GearboxType gearboxType){GearboxType = gearboxType;CurrentPosition = GearPosition.N;}///<summary>///格式化输出变速箱信息///</summary>///<returns>变速箱信息</returns>public override string ToString(){return string.Format("变速箱类型:{0}\r", Enum.GetName(typeof(GearboxType), GearboxType)); }///<summary>///根据当前变速箱所挂档位、传动⽅向和所连接的发动机进⾏动⼒传输///</summary>///<param name="engine">连接的发动机</param>///<returns>动⼒传输结果</returns>public virtual GearboxOutput TransmitPower(IEngine engine){//这⾥只做简单的假设性动⼒传输int currentPositionValue = int.Parse(Convert.ToString(CurrentPosition));double enginePower = engine.Work();GearboxOutput gearboxOutput = new GearboxOutput();gearboxOutput.Speed = enginePower * currentPositionValue;gearboxOutput.Torque = 10 - currentPositionValue;gearboxOutput.direction = TransmitDirection;return gearboxOutput;}}///<summary>///轮胎///</summary>[Serializable]public class Tyre{///<summary>///轮胎预装位置///</summary>public TyrePosition TyrePosition { get; set; }///<summary>///胎宽(mm)///</summary>public int Width { get; set; }///<summary>///胎厚(mm)<///</summary>public int Thickness { get; set; }///<summary>///轮辋直径(英⼨)///</summary>public double Radial { get; set; }///<summary>///载重系数(⼀般不超过110)///</summary>public int LoadIndex { get; set; }///<summary>///速度等级<see cref="SpeedGrade"/>///</summary>public SpeedGrade SpeedGrade { get; set; }///<summary>///胎⾯花纹种类<see cref="TreadPattern"/>///</summary>public TreadPattern TreadPattern { get; set; }///<summary>///初始化轮胎///</summary>public Tyre() { }///<summary>///初始化轮胎(带参)///</summary>///<param name="width">胎宽(mm)</param>///<param name="thickness">胎厚(mm)</param>///<param name="radial">轮辋直径(英⼨)</param>///<param name="loadIndex">载重系数(⼀般不超过110)</param>///<param name="speedGrade">速度等级<see cref="SpeedGrade"/></param>///<param name="treadPattern">胎⾯花纹种类<see cref="TreadPattern"/></param>public Tyre(int width, int thickness, double radial, int loadIndex, SpeedGrade speedGrade, TreadPattern treadPattern){Width = width;Thickness = thickness;Radial = radial;LoadIndex = loadIndex;SpeedGrade = speedGrade;TreadPattern = treadPattern;}///<summary>///初始化轮胎(带参并指明轮胎预装位置)///</summary>///<param name="width">胎宽(mm)</param>///<param name="thickness">胎厚(mm)</param>///<param name="radial">轮辋直径(英⼨)</param>///<param name="loadIndex">载重系数(⼀般不超过110)</param>///<param name="speedGrade">速度等级<see cref="SpeedGrade"/></param>///<param name="treadPattern">胎⾯花纹种类<see cref="TreadPattern"/></param>///<param name="tyrePosition">轮胎位置</param>public Tyre(int width, int thickness, double radial, int loadIndex, SpeedGrade speedGrade, TreadPattern treadPattern, TyrePosition tyrePosition) {Width = width;Thickness = thickness;Radial = radial;LoadIndex = loadIndex;SpeedGrade = speedGrade;TreadPattern = treadPattern;TyrePosition = tyrePosition;}///<summary>///输出轮胎规格描述([胎宽mm]/[胎厚与胎宽的百分⽐] R[轮辋直径(英⼨)] [载重系数][速度标识])///</summary>///<returns>轮胎规格描述</returns>public override string ToString(){return string.Format("轮胎规格:{0}/{1} R{2} {3}{4}", Width, ((Thickness*100) / Width), Radial, LoadIndex, Enum.GetName(typeof(SpeedGrade), SpeedGrade)); }}///<summary>///车⾝///</summary>[Serializable]public class Bodywork{///<summary>///车⾝结构<see cref="BodyworkStructure"/>///</summary>public BodyworkStructure Structure { get; set; }///<summary>///车⾝颜⾊<see cref="BodyworkColor"/>///</summary>public BodyworkColor Color { get; set; }///<summary>///长(mm)///</summary>public int Length { get; set; }///<summary>///宽(mm)///</summary>public int Width { get; set; }///<summary>///⾼(mm)///</summary>public int Height { get; set; }///<summary>///初始化车⾝///</summary>public Bodywork() { }///<summary>///初始化车⾝(带参)///</summary>///<param name="structure">车⾝结构<see cref="BodyworkStructure"/></param>///<param name="color">车⾝颜⾊<see cref="BodyworkColor"/></param>///<param name="length">长(mm)</param>///<param name="width">宽(mm)</param>///<param name="height">⾼(mm)</param>public Bodywork(BodyworkStructure structure, BodyworkColor color, int length, int width, int height){Structure = structure;Color = color;Length = length;Width = width;Height = height;}///<summary>///格式化输出车⾝信息///</summary>///<returns>车⾝信息</returns>public override string ToString(){StringBuilder sb = new StringBuilder();sb.AppendLine(string.Format("车⾝结构:{0}", Enum.GetName(typeof(BodyworkStructure), Structure)));sb.AppendLine(string.Format("车⾝颜⾊:{0}", Enum.GetName(typeof(BodyworkColor), Color)));sb.AppendLine(string.Format("长度/宽度/⾼度(mm):{0}/{1}/{2}", Length, Width, Height));return sb.ToString();}} 可以看到简陋的主要部件的定义都已经够复杂了,汽车整车不⽤说都符合a complex object这个标准! 以下是汽车(Car)及其相关主要部件(底盘、发动机、变速箱、轮胎、车⾝)定义中⽤到的枚举:///<summary>///车辆驱动⽅式///</summary>public enum DriveMode{///<summary>///前轮驱动///</summary>FrontWheelDrive,///<summary>///后轮驱动///</summary>RearWheelDrive,///<summary>///全时全轮驱动///</summary>FullTimeAllWheelDrive,///<summary>///接通式全轮驱动///</summary>OnLineFullWheelDrive}///<summary>///发动机冷却⽅式///</summary>public enum CoolingMode{///<summary>///风冷///</summary>AirCooling,///<summary>///⽔冷///</summary>WaterCooling}///<summary>///变速箱类型///</summary>public enum GearboxType{///<summary>///⾃动型///</summary>Automatic,///<summary>///⼿动型///</summary>Manual}///<summary>///⾃动档与⼿动档通⽤档位///</summary>public enum GearPosition{First = 1,Second = 2,Third = 3,Fourth = 4,Fifth = 5,Sixth = 6,Seventh = 7,Eighth = 8,Ninth = 9,///<summary>///空档///</summary>N = 0}///<summary>///变速箱传动⽅向///</summary>public enum TransmitDirection {///<summary>///正向(前进)///</summary>Forward = 1,///<summary>///反向(后退)///</summary>Backward = -1}///轮胎速度等级,对应的枚举值为相应等级的最⾼时速(单位km/h)///</summary>public enum SpeedGrade{A1 = 5,A2 = 10,A3 = 15,A4 = 20,A5 = 25,A6 = 30,A7 = 35,A8 = 40,B = 50,C = 60,D = 65,E = 70,F = 80,G = 90,J = 100,K = 110,L = 120,M = 130,N = 140,P = 150,Q = 160,R = 170,S = 180,T = 190,U = 200,H = 210,V = 240,W = 270,Y = 300,///<summary>///超过240km/h的通⽤等级///</summary>ZR = 241}///<summary>///胎⾯花纹///</summary>public enum TreadPattern{///<summary>///⽆花纹(光头轮胎)///</summary>None,///<summary>///纵向花纹///</summary>Longitudinal,///<summary>///横向花纹///</summary>Transverse,///<summary>///单导向花纹///</summary>SingleGuide,///<summary>///块状花纹///</summary>Lumpy,///<summary>///不对称花纹///</summary>Asymmetrical,///<summary>///混合花纹///</summary>Mixed}///<summary>///轮胎位置///</summary>public enum TyrePosition{///<summary>///前轮///</summary>Front,///后轮///</summary>Rear}///<summary>///车⾝结构///</summary>public enum BodyworkStructure{///<summary>///⾮承载式///</summary>NonLoad,///<summary>///承载式///</summary>Load,///<summary>///半承载式///</summary>HalfLoad}///<summary>///车⾝颜⾊///</summary>public enum BodyworkColor{Black,White,Red,Yellow,Silvery,Blue,Gray} 终于轮到汽车整车(Car)的定义了:///<summary>///汽车///</summary>public class Car{private readonly string name;private readonly string model;///<summary>///车名///</summary>public string Name { get { return ; } }///<summary>///型号///</summary>public string Model { get { return this.model; } }///<summary>///底盘///</summary>public Chassis Chassis { get; set; }///<summary>///发动机///</summary>public IEngine Engine { get; set; }///<summary>///变速箱///</summary>public IGearBox GearBox { get; set; }///<summary>///轮胎///</summary>public IList<Tyre> Tyres { get; set; }///<summary>///车⾝///</summary>public Bodywork Bodywork { get; set; }///<summary>///初始化汽车///</summary>public Car() { }///<summary>///初始化汽车(带简要参数)///</summary>///<param name="name"></param>///<param name="model"></param>public Car(string name, string model){ = name;this.model = model;}///<summary>///格式化输出整车信息///</summary>///<returns>整车信息</returns>public override string ToString(){StringBuilder sb = new StringBuilder();sb.AppendLine(string.Format("车名:{0}", ));sb.AppendLine(string.Format("型号:{0}", this.model));sb.AppendLine(Chassis.ToString());sb.AppendLine(Engine.ToString());sb.AppendLine(GearBox.ToString());sb.AppendLine(Bodywork.ToString());if (Tyres != null && Tyres.Count > 0){var tyreGroups = Tyres.GroupBy(t => t.TyrePosition);if (tyreGroups.Count() > 1){foreach (var group in tyreGroups){sb.AppendLine(string.Format("{0}{1}", Enum.GetName(typeof(TyrePosition), group.First().TyrePosition), group.First().ToString()));}}else{sb.AppendLine(Tyres[0].ToString());}sb.AppendLine(string.Format("轮胎数量:{0}", Tyres.Count));}return sb.ToString();}} 汽车整车主要由底盘、发动机、变速箱、轮胎、车⾝等组装⽽成,但汽车类Car中并没有给出这些部件的⽣产和组装⽅法(过程),因为这些过程⽐较复杂,⽽且对于汽车⽣产来说都要经过这些标准过程(规范),我们将这些复杂的部件⽣产和组装过程交给专门的构建者去做——即将复杂对象的构造与其表⽰分离! 我们先定义⼀下汽车⽣产组装的主要过程标准——构建标准(规范):///<summary>///汽车构建标准(规范)///</summary>public interface IBuilder{///<summary>///构建底盘///</summary>void BuildChassis();///<summary>///构建发动机///</summary>void BuildEngine();///<summary>///构建变速箱///</summary>void BuildGearbox();///<summary>///构建轮胎///</summary>void BuildTyre();///<summary>///构建车⾝///</summary>void BuildBodywork();///<summary>///取得构建好的汽车///</summary>///<returns>构建好的汽车</returns>Car GetCar();} 有了要构建的产品——汽车Car,也有了构建标准(规范)——IBuilder接⼝,但具体执⾏各个部件构建的构建者还没有,这个很容易,只要让构建者按构建标准(规范)来实现各个部件的构建过程就⾏了——即实现IBuilder接⼝,例如宝马(BWM)和奔驰(Benz)的构建者对⾃⼰某个车型的构建实现:///<summary>///宝马(BWM)构建者(对各个部件有⾃⼰的⽣产⼯艺)///</summary>public class BwmBuilder : IBuilder{private Car bwmCar = new Car("BWM", "X7");public void BuildBodywork(){Thread.Sleep(150);//模拟耗时bwmCar.Bodywork = new Bodywork(BodyworkStructure.HalfLoad, BodyworkColor.Silvery, 5250, 1902, 1498);}public void BuildChassis(){Thread.Sleep(200);//模拟耗时bwmCar.Chassis = new Chassis(3210, DriveMode.FullTimeAllWheelDrive);}public void BuildEngine(){Thread.Sleep(900);//模拟耗时bwmCar.Engine = new Engine(4, 2, CoolingMode.WaterCooling);}public void BuildGearbox(){Thread.Sleep(500);//模拟耗时bwmCar.GearBox = new Gearbox(GearboxType.Manual);}public void BuildTyre(){Thread.Sleep(300);//模拟耗时bwmCar.Tyres = new List<Tyre>();for (int i = 0; i < 4; i++){Tyre tyre = new Tyre(260, 115, 21, 95, SpeedGrade.ZR, TreadPattern.Mixed);bwmCar.Tyres.Add(tyre);}}public Car GetCar(){return bwmCar;}}///<summary>///奔驰(Benz)构建者(对各个部件有⾃⼰的⽣产⼯艺)///</summary>public class BenzBuilder : IBuilder{private Car benzCar = new Car("Benz", "梅赛德斯-AMG GLC 43 4MATIC");public void BuildBodywork(){Thread.Sleep(100);//模拟耗时benzCar.Bodywork = new Bodywork(BodyworkStructure.Load, BodyworkColor.Black, 4734, 1930, 1588);}public void BuildChassis(){Thread.Sleep(200);//模拟耗时benzCar.Chassis = new Chassis(2873, DriveMode.FullTimeAllWheelDrive);}public void BuildEngine(){Thread.Sleep(1000);//模拟耗时benzCar.Engine = new Engine(6, 2, CoolingMode.WaterCooling);}public void BuildGearbox(){Thread.Sleep(600);//模拟耗时benzCar.GearBox = new Gearbox(GearboxType.Automatic);}public void BuildTyre(){Thread.Sleep(300);//模拟耗时benzCar.Tyres = new List<Tyre>();for (int i = 0; i < 2; i++){Tyre tyre = new Tyre(255, 115, 20, 90, SpeedGrade.ZR, TreadPattern.SingleGuide, TyrePosition.Front);benzCar.Tyres.Add(tyre);}for (int i = 0; i < 2; i++){Tyre tyre = new Tyre(255, 114, 20, 90, SpeedGrade.ZR, TreadPattern.SingleGuide, TyrePosition.Rear);benzCar.Tyres.Add(tyre);}}public Car GetCar(){return benzCar;}} 上述宝马(BWM)和奔驰(Benz)各部件的具体⽣产⼯艺并不相同,这体现了总体的⽣产规范是⼀样的,但具体的实现是可以不⼀样的!构建者模式定义中的后半句——相同的构造过程可以创建不同的表⽰(灵活变化点⼀)。
Cbuilder教程大全
Cbuilder教程⼤全BorlandC++Builder5.0是Interpries(Borland)公司推出的基于C++语⾔的快速应⽤程序开发(RapidApplicationDevelopment,RAD)⼯具,它是最先进的开发应⽤程序的组件思想和⾯向对象的⾼效语⾔C++融合的产物。
C++Builder充分利⽤了已经发展成熟的Delphi的可视化组件库(VisualComponentLibrary,VCL),吸收了BorlandC++5.0这个优秀编译器的诸多优点。
C++Builder结合了先进的基于组件的程序设计技术,成熟的可视化组件库和优秀编译器,调试器。
发展到5.0版本,C++Builder已经成为⼀个⾮常成熟的可视化应⽤程序开发⼯具,功能强⼤⽽且效率⾼。
C++Builder的特⾊:1.C++Builder是⾼性能的C++开发⼯具C++Builder是基于C++的,它具有⾼速的编译,连接和执⾏速度。
同时,C++Builder具有双编译器引擎,不仅可以编译C/C++程序,还能编译ObjectPascal语⾔程序。
2.C++Builder是优秀的可视化应⽤程序开发⼯具C++Builder是⼀完善的可视化应⽤程序开发⼯具,使程序员从繁重的代码编写中解放出来,使他们能将注意⼒重点放在程序的设计上,⽽不是简单的重复的劳动中。
同时,它提供的完全可视的程序界⾯开发⼯具,从⽽使程序员对开发⼯具的学习周期⼤⼤缩短。
3.C++Builder具有强⼤的数据库应⽤程序开发功能C++Builder提供了强⼤的数据库处理功能,它使的程序员不⽤写⼀⾏代码就能开发出功能强⼤的数据库应⽤程序,这些主要依赖于C++Builder众多的数据库感知控件和底层的BDE数据库引擎。
C++Builder除了⽀持Microsoft的ADO(ActiveDataObject)数据库连接技术,还提供了⼀种⾃⼰开发的成熟的数据库连接技术——BDE(BorlandDatabaseEngine)数据库引擎。
c++builder课程设计
自定义组件和控件的优化和改进
自定义组件和控件的测试和调试
自定义组件和控件的示例代码
自定义组件和控件的开发流程
自定义组件和控件的用途
自定义组件和控件的概念
C++Builder应用开发实践
数据库访问技术
C++Builder支持多种数据库类型,如SQL Server、MySQL、Oracle等。
异常处理:try、catch、throw等
模板:函数模板、类模板等
C++的函数和作用域
函数定义:函数是完成特定任务的独立代码块,可以接受参数并返回结果
函数调用:通过函数名和参数列表来调用函数
函数作用域:函数内部定义的变量只能在函数内部访问,称为局部变量
全局作用域:在函数外部定义的变量可以在整个程序中访问,称为全局变量
添加标题
使用C++Builder的ADO技术,可以方便地访问数据库。
添加标题
ADO技术包括ADOConnection、ADOCommand、ADODataSet等对象,用于连接数据库、执行SQL语句、操作数据集等。
添加标题
C++Builder还提供了数据感知控件,如DataGrid、ListView等,可以方便地显示和编辑数据库数据。
多态:同一方法在不同对象中表现出不同的行为
封装和抽象类的理解
添加标题
添加标题
添加标题
添加标题
抽象类:不能实例化,只能作为基类被继承,用于定义公共接口和实现部分功能
封装:将数据和操作数据的方法绑定在一起,隐藏内部实现细节,提供对外接口
封装的好处:提高代码复用性,降低耦合度,提高安全性
c+Builder工程的基本结构
#pragma 预处理指令详解
3.8 #pragma loop_opt(on|off) 激活循环|终止循环优化功能。
3.9 #pragma warn +100 |-100 启用或者禁止:“变量已定义但未使用的”警告信息。
26
#pragma 预处理指令详解
27
#pragma 预处理指令详解
可以用#pragma startup 指定编译优先级,如果使 用了#pragma package(smart_init),BCB就会根据优先 级的大小先后编译。
22
#pragma 预处理指令详解
3.5 resource "*.dfm" 表示把*.dfm文件中的资源加入工程。*.dfm中包括窗
体外观的定义。 3.6 warning( disable: 4507 34; once: 4385; error: 164 )
内存对齐问题 计算机系统对基本类型数据在内存中存放的位置有
限制,要求这些数据的首地址的值是某个数 k(通常它为 4或8)的倍数,这就是内存对齐,而这个 k 则被称为该 数据类型的对齐模数(alignment modulus)。
Win32平台下的微软 C 编译器(cl.exe for 80x86) 在默认情况下采用如下的对齐规则:
#ifdef _X86 #pragma message("_X86 macro activated!") #endif 定义了_X86这个宏以后,应用程序在编译时就会在 编译输出窗口里显示"_86 macro activated!"。就会 知道有没有定义一些特定的宏了。
19
#pragma 预处理指令详解
启动工程。示例代码如下: #include <vcl.h> #pragma hdrstop USEFORM("Unit1.cpp", Form1); WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
Builder(生成器)模式
设计模式----Builder(生成器)模式GoF:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
Builder模式与Absrtact Factory模式非常像。
GoF指出,他们二者的主要区别就在于Builder模式遵循一定的步骤一步一步创建对象。
Builder模式是为了将构建复杂对象的过程和他的部件相分离。
因为一个复杂的对象不但有很多大量的组成部分,还有很多小的零件。
他(复杂对象)本身要靠这些部件和零件来组装。
例如:一座房子,它有很多部件:房间、窗户;还有门窗上的锁和窗户上的插销等小零件。
Builder模式的目的就是为了将部件(门、窗等)和组装过程(整个房子的建造)分开。
现在假设一个房子有多个部件组成的,Builder模式的目的是把复杂对象的创建和部件的创建分别开来。
分别用Builder类和Director类来表示。
下面以建造房子为例:首先定义一个抽象类,它定义如何创建复杂对象的各个部件package Builder;public abstract class HouseBuilder{public abstract void BuildRoom(int roomNo);//构建房间public abstract void BuildDoor(int room1, int room2);//构建门//得到最后的房屋public abstract House getHouse();}//end abstract class HouseBuilder用Director构建复杂对象(房子):package Builder;public class HouseDirector{public void createHouse(HouseBuilder concreteBuilder){concreteBuilder.buildRoom(2);concreteBuilder.buildDoor(3);}//end createHouse(...)}//end class HouseDirectorBuilder的具体实现ConcreteHouseBuilder:通过完成Builder来构建产品(房子)的部件package Builder;public class ConcreteHouseBuilder extends HouseBuilder{private House house;public ConcreteHouseBuilder(){house = new House();}//end ConcreteHouseBuilder()//创建屋子的数量public void buildRoom(int roomNumber){house.roomNumber = roomNumber;}//end BuildRoom//创建门的数量public void buildDoor(int doorNumber){house.doorNumber = doorNumber;}//返回创建好的房屋public House getHouse(){return house;}//end getHouse()}//end class ConcreteHouseBuildera具体的屋子:package Builder;public class House{int roomNumber;int doorNumber;public House(){roomNumber = 0;doorNumber = 0;}//end House()public int getRoomNumber(){return roomNumber;}//end getRoomNumber()public int getDoorNumber(){return doorNumber;}//end getDoorNumber()}//end class HouseBuilder模式的具体运用:/** BuilderPattern.java** Created on 2006年3月28日, 下午10:01** To change this template, choose Tools | Template Manager * and open the template in the editor.*/package Builder;/**** @author Administrator*/public class BuilderPattern{House house;ConcreteHouseBuilder houseBuilder;HouseDirector houseDirecor;public BuilderPattern(){house = new House();houseBuilder = new ConcreteHouseBuilder();houseDirecor = new HouseDirector();}public void createHouse(){houseDirecor.createHouse(houseBuilder);house = houseBuilder.getHouse();System.out.println("My house has room :" + house.getRoomNumber());System.out.println("My house has door :" + house.getDoorNumber());}//end creatHouse()public static void main(String[] args){System.out.println("The Builder Pattern!");BuilderPattern bp = new BuilderPattern();bp.createHouse();}}//end class BuilderPattern最后的结果:My house has room :2My house has door :3最后给出UML图:小结:当一个对象由复杂的部件构成时,我们可以试着去用Builder模式来实现。
c++builder最终课程设计
异常处理和日志记录的重要性: 提高应用程序的稳定性和可靠 性,便于调试和维护
异常处理和日志记录的应用场 景:网络通信、文件操作、数 据库操作等
04 课程设计步骤
确定应用程序的需求和功能模块
需求分析:明确应用程序的目标和用途 功能模块划分:将应用程序划分为多个功能模块 功能模块设计:为每个功能模块设计具体的功能和界面 功能模块测试:对每个功能模块进行测试,确保其正常运行
国际化支持:支持多种语言,如中文、 英文、日文等
实现应用程序的数据持久化,使用数据库进行数据存储和读 取
● 数据持久化:将应用程序中的数据保存到数据库中,以便在应用程序关闭后仍能访问这些数据 ● 数据库类型:SQLite、MySQL、PostgreSQL等 ● 数据库连接:使用C++Builder提供的数据库连接组件,如TADOConnection、TADOQuer y等 ● 数据存储:将应用程序中的数据保存到数据库中,如使用INSERT语句插入数据 ● 数据读取:从数据库中读取数据,如使用SELECT语句查询数据 ● 数据更新:更新数据库中的数据,如使用UPDATE语句更新数据 ● 数据删除:删除数据库中的数据,如使用DELETE语句删除数据
数据性能:优 化数据库性能, 提高查询效率
必须实现异常处理和日志记录功能
异常处理:确保程序在遇到异常情况时能够正确处理,避免程序崩溃
日志记录:记录程序的运行状态和错误信息,便于调试和维护
异常处理和日志记录功能的实现方式:可以使用C++Builder提供的异常处理机制和日志记 录库
异常处理和日志记录功能的测试:编写测试用例,确保异常处理和日志记录功能能够正常工 作
实现应用程序的基本功能,如菜单、工具栏、状态栏等
C++设计模式之建造者模式(Builder)
C++设计模式之建造者模式(Builder)建造者模式与⼯⼚模式最⼤的区别在与建造者模式更注重的是创建的⼀系列过程,如流⽔化作业,⼯⼚模式强调的是区分不同的⼯⼚和产品,⽽建造者模式更注重的统⼀不同产品在流⽔线上的⼯序,达到统⼀作业。
作⽤建造者模式是将⼀个复杂对象和他的构造和组装过程分离,这样再重复创建不同对象时使⽤相同的流程进⾏建造。
对于调⽤者来说,只需要知道产品的类型,⽽不需要知道具体的组装过程。
类视图代码实现class Builder{public:virtual void SelectCpu()= 0;virtual void SelectMatherboard() = 0;virtual void SelectMem() = 0;virtual void SelectDisk() = 0;virtual void SelectPower() = 0;virtual void SelectShell() = 0;};//构造PCclass PCBuilder : public Builder{public:void SelectCpu() { cout<<"Select PC Cpu"<<endl; }void SelectMatherboard() { cout<<"Select PC Matherboard"<<endl; }void SelectMem() { cout<<"Select PC Mem"<<endl; }void SelectDisk() { cout<<"Select PC Disk"<<endl; }void SelectPower() { cout<<"Select PC Power"<<endl; }void SelectShell() { cout<<"Select PC Shell"<<endl; }};//构造Notebookclass NoteBookBuilder : public Builder{public:void SelectCpu() { cout<<"Select NoteBook Cpu"<<endl; }void SelectMatherboard() { cout<<"Select NoteBook Matherboard"<<endl; }void SelectMem() { cout<<"Select NoteBook Mem"<<endl; }void SelectDisk() { cout<<"Select NoteBook Disk"<<endl; }void SelectPower() { cout<<"Select NoteBook Power"<<endl; }void SelectShell() { cout<<"Select NoteBook Shell"<<endl; }};//构造的指挥官class Director{private:Builder *m_pBuilder;public:Director(Builder *builder) { m_pBuilder = builder; }void Create(){m_pBuilder->SelectCpu();m_pBuilder->SelectMatherboard();m_pBuilder->SelectMem();m_pBuilder->SelectDisk();m_pBuilder->SelectPower();m_pBuilder->SelectShell();}};//调⽤int main(){NoteBookBuilder thin;Director director(&thin);director.Create();return 0;}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
C#设计模式系列:建造者模式(Builder)
C#设计模式系列:建造者模式(Builder)11.1 定义 建造者模式(Builder)将复杂的构建与其表⽰相分离,使得同样的构建过程可以创建不同的表⽰。
1.2 使⽤频率 中低22.1 结构图2.2 参与者 建造者模式参与者: ◊ Builder:为创建⼀个Product对象的各个部件指定抽象接⼝; ◊ ConcreteBuilder ° 实现Builder的接⼝以构造和装配该产品的各个部件 ° 定义并明确它所创建的表⽰ ° 提供⼀个检索Product的接⼝ ◊ Director:构造⼀个使⽤Builder接⼝的对象; ◊ Product ° 表⽰被构造的复杂对象。
ConcreteBuilder创建该产品的内部表⽰并定义它的装配过程 ° 包含定义组成部件的类,包括将这些部件装配成最终产品的接⼝ 在建造者模式中,Director规定了创建⼀个对象所需要的步骤和次序,Builder则提供了⼀些列完成这些步骤的⽅法,ConcreteBuilder给出了这些⽅法的具体实现,是对象的直接创建者。
3 建造者模式结构实现 Product.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural{public class Product{private List<string> _parts = new List<string>();public void Add(string part){_parts.Add(part);}public void Show(){Console.WriteLine("Product Parts");foreach (string part in _parts){Console.WriteLine(part);}}}} Builder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public abstract class Builder{public abstract void BuildPartA();public abstract void BuildPartB();public abstract Product GetResult();}} ConcreteBuilder1.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public class ConcreteBuilder1 : Builder{private Product _product = new Product();public override void BuildPartA(){_product.Add("PartA");}public override void BuildPartB(){_product.Add("PartB");}public override Product GetResult(){return _product;}}} ConcreteBuilder2.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public class ConcreteBuilder2 : Builder{private Product _product = new Product();public override void BuildPartA(){_product.Add("PartX");}public override void BuildPartB(){_product.Add("PartY");}public override Product GetResult(){return _product;}}} Director.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public class Director{///<summary>/// Builder uses a complex series of steps///</summary>public void Construct(Builder builder){builder.BuildPartA();builder.BuildPartB();}}} Program.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using DesignPatterns.BuilderPattern.Structural; namespace DesignPatterns.BuilderPattern{class Program{static void Main(string[] args){// Create director and buildersDirector director = new Director();Builder b1 = new ConcreteBuilder1();Builder b2 = new ConcreteBuilder2();// Construct two productsdirector.Construct(b1);Product p1 = b1.GetResult();p1.Show();director.Construct(b2);Product p2 = b2.GetResult();p2.Show();}}} 运⾏输出:Product PartsPartAPartBProduct PartsPartXPartY请按任意键继续. . .4、建造者模式实践应⽤ Vehicle.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{///<summary>/// The 'Product' class///</summary>public class Vehicle{private string _vehicleType;private Dictionary<string, string> _parts = new Dictionary<string, string>();///<summary>/// Constructor///</summary>public Vehicle(string vehicleType){this._vehicleType = vehicleType;}///<summary>/// Indexer///</summary>public string this[string key]{get { return _parts[key]; }set { _parts[key] = value; }}public void Show(){Console.WriteLine("\n---------------------------");Console.WriteLine("Vehicle Type: {0}", _vehicleType);Console.WriteLine(" Frame : {0}", _parts["frame"]);Console.WriteLine(" Engine : {0}", _parts["engine"]);Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);Console.WriteLine(" #Doors : {0}", _parts["doors"]);}}} VehicleBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{///<summary>/// The 'Builder' abstract class///</summary>public abstract class VehicleBuilder{protected Vehicle vehicle;// Gets vehicle instancepublic Vehicle Vehicle{get { return vehicle; }}// Abstract build methodspublic abstract void BuildFrame();public abstract void BuildEngine();public abstract void BuildWheels();public abstract void BuildDoors();}} MotorCycleBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{public class MotorCycleBuilder : VehicleBuilder {public MotorCycleBuilder(){vehicle = new Vehicle("MotorCycle");}public override void BuildFrame(){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";}}} CarBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical {public class CarBuilder : VehicleBuilder{public CarBuilder(){vehicle = new Vehicle("Car");}public override void BuildFrame(){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";}}} ScooterBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical {public class ScooterBuilder : VehicleBuilder{public ScooterBuilder(){vehicle = new Vehicle("Scooter");}public override void BuildFrame(){vehicle["frame"] = "Scooter Frame";}public override void BuildEngine(){vehicle["engine"] = "50 cc";}public override void BuildWheels(){vehicle["wheels"] = "2";}public override void BuildDoors(){vehicle["doors"] = "0";}}} Shop.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{public class Shop{public void Construct(VehicleBuilder vehicleBuilder) {vehicleBuilder.BuildFrame();vehicleBuilder.BuildEngine();vehicleBuilder.BuildWheels();vehicleBuilder.BuildDoors();}}} Program.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using DesignPatterns.BuilderPattern.Practical; namespace DesignPatterns.BuilderPattern{class Program{static void Main(string[] args){VehicleBuilder builder;// Create shop with vehicle buildersShop shop = new Shop();// Construct and display vehiclesbuilder = new ScooterBuilder();shop.Construct(builder);builder.Vehicle.Show();builder = new CarBuilder();shop.Construct(builder);builder.Vehicle.Show();builder = new MotorCycleBuilder();shop.Construct(builder);builder.Vehicle.Show();}}} 运⾏输出:---------------------------Vehicle Type: ScooterFrame : Scooter FrameEngine : 50 cc#Wheels: 2#Doors : 0---------------------------Vehicle Type: CarFrame : Car FrameEngine : 2500 cc#Wheels: 4#Doors : 4---------------------------Vehicle Type: MotorCycleFrame : MotorCycle FrameEngine : 500 cc#Wheels: 2#Doors : 0请按任意键继续. . .5 建造者模式适⽤情形: ◊ 需要⽣成的产品对象有复杂的内部结构 ◊ 需要⽣成的产品对象的属性相互依赖,建造者模式可以强迫⽣成顺序 ◊ 在对象创建过程中会使⽤到系统中的⼀些其他对象,这些对象在产品对象的创建过程中不易得到 建造者模式特点: ◊ 建造者模式的使⽤使得产品的内部表对象可以独⽴地变化。
生成器模式(Builder)解析例子
⽣成器模式(Builder)解析例⼦原创作品,允许转载,转载时请务必以超链接形式标明⽂章、作者信息和本声明。
否则将追究法律责任。
⽣成器模式属于对象结构型模式,其意图是将⼀个复杂对象的构建与他的表⽰分离,使得同样的构建创建过程可以创建不同的表⽰。
适⽤性:1.当创建复杂对象的算法应该独⽴于该对象的组成部分以及他们的装配⽅式时2.当构造过程必须允许被构造的对象有不同的表⽰时。
参与者:⽣成器Builder:为创建⼀个Product对象的各个部件指定抽象接⼝(AnimalBuilder)。
具体⽣成器ConcreteBuilder:实现Builder接⼝⼀构造和装配该产品的各个部件。
定义并明确他所创建的表⽰,提供⼀个检索产品的接⼝(getAnimal)。
导向器:构建⼀个适⽤Builder对象的接⼝。
Product(Checken,pig):表⽰被构造的复杂对象。
ConcreteBuilder创建该产品的内部表⽰并定义它的装配过程,包含定义组成部件的类,包括将这些部件装配成最终的产品。
650) this.width=650;">图1当客户需要⼀个产品时,把需要的参数传递个导向器,导向器根据传递的参数调⽤具体的⽣成器,具体的⽣成器通过⼀系列的操作(getAnimal()通过调⽤其它的接⼝⽅法实现)最会返回⼀个产品。
Bridge模式的优点:1.它使你可以改变⼀个产品的内部表⽰,Builder对象提供给导向器⼀个构造产品的抽象接⼝,该接⼝使得⽣成器可以隐藏这个产品的表⽰和内部结构,他同时也隐藏了该产品是如何装配的,因为产品时通过抽象接⼝构造的(注:本例⼦把接⼝的实现放在具体类中了),你在改变该产品的内部表⽰时所要做的只是定义⼀个新的⽣成器。
2.他将构造代码和表⽰代码分开,这有点类似于模板模式。
所不同的是模版模式最终是完成复杂的⼯作,⽽⽣成器的⽬的是要⽣成⼀个复杂的对象。
3.他使得你对构造过程进⾏更加精细的控制。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
C++模式设计之Builder
2002-07-23 13:12作者:出处:COM集中营责任编辑:
一、功能
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
二、结构图
各类之间的交互关系如下图所示:
三、示例代码
namespace DesignPattern_Builder
{
class Product1 { /*...*/ } ;
class Product2 { /*...*/ } ;
// class Builder
class Builder //抽象基类
{
public:
virtual void BuilderPartA() {} //提供缺省实现
virtual void BuilderPartB() {}
virtual void BuilderPartC() {}
protected:
Builder() {}
} ;
// class ConcreteBuilder1
class ConcreteBuilder1 : public Builder //创建Product1
{
public:
ConcreteBuilder1() : _product(NULL) {}
virtual void BuilderPartA() { /*...*/ }
virtual void BuilderPartB() { /*...*/ }
virtual void BuilderPartC() { /*...*/ }
virtual Product1* GetProduct1() { return _product ; } //返回创建的Product1对象
private:
Product1 *_product ;
} ;
// class ConcreteBuilder2
class ConcreteBuilder2 : public Builder //创建Product2
{
public:
ConcreteBuilder2() : _product(NULL) {}
virtual void BuilderPartA() { /*...*/ }
virtual void BuilderPartB() { /*...*/ }
virtual void BuilderPartC() { /*...*/ }
virtual Product2* GetProduct2() { return _product ; } //返回创建的Product2对象
private:
Product2 *_product ;
} ;
// class Director
class Director
{
public:
//创建对象(Director并不知道具体创建出来的对象是什么样的,只有调用该函数的
client知道)
void Construct(Builder *builder)
{
builder->BuilderPartA() ;
builder->BuilderPartB() ;
builder->BuilderPartC() ;
}
} ;
}
客户端代码:
{
using namespace DesignPattern_Builder ;
Director director ;
// 创建第一种对象
ConcreteBuilder1 *pBuilder1 = new ConcreteBuilder1() ; director.Construct(pBuilder1) ;
Product1 *product1 = pBuilder1->GetProduct1() ;
// 创建第二种对象
ConcreteBuilder2 *pBuilder2 = new ConcreteBuilder2() ; director.Construct(pBuilder2) ;
Product2 *product2 = pBuilder2->GetProduct2() ;
}
四、实例
(1)例子一。
如下图所示:
上图的功能是是把一个RTF文件转换为多种正文格式。
RTFReader进行语法分析,然后将所有的token串逐一转换。
可见builder就是一步步地把各个部分组装为一个整体。
它封闭了组装的方法,组装出来的对象也大相径庭。