设计模式之C++版
C#设计模式(3)
C#设计模式三、依赖倒置原则(DIP)依赖倒置(Dependence Inversion Principle)原则讲的是:要依赖于抽象,不要依赖于具体。
简单的说,依赖倒置原则要求客户端依赖于抽象耦合。
原则表述:抽象不应当依赖于细节;细节应当依赖于抽象;要针对接口编程,不针对实现编程。
反面例子:缺点:耦合太紧密,Light发生变化将影响ToggleSwitch。
解决办法一:将Light作成Abstract,然后具体类继承自Light。
优点:ToggleSwitch依赖于抽象类Light,具有更高的稳定性,而BulbLight与TubeLight 继承自Light,可以根据"开放-封闭"原则进行扩展。
只要Light不发生变化,BulbLight与TubeLight的变化就不会波及ToggleSwitch。
缺点:如果用ToggleSwitch控制一台电视就很困难了。
总不能让TV继承自Light吧。
优点:更为通用、更为稳定。
结论:使用传统过程化程序设计所创建的依赖关系,策略依赖于细节,这是糟糕的,因为策略受到细节改变的影响。
依赖倒置原则使细节和策略都依赖于抽象,抽象的稳定性决定了系统的稳定性。
四、接口隔离原则(ISP)接口隔离原则(Interface Segregation Principle)讲的是:使用多个专门的接口比使用单一的总接口总要好。
换而言之,从一个客户类的角度来讲:一个类对另外一个类的依赖性应当是建立在最小接口上的。
过于臃肿的接口是对接口的污染。
不应该强迫客户依赖于它们不用的方法。
My object-oriented umbrella(摘自Design Patterns Explained)Let m e tell you about m y great um brella. It is large enough to get into! In fact, three or four other people can get in it with m e. While we are in it, staying out of the rain, I can m ove it from one place to another. It has a stereo system to keep me entertained while I stay dry. Am azingly enough, it can also condition the air to m ake it warm er or colder. It is one cool um brella.My umbrella is convenient. It sits there waiting for me. It has wheels on it so that I do not have to carry it around. I don't even have to push it because it can propel itself. Som etimes, I will open the top of m y umbrella to let in the sun. (Why I am using m y umbrella when it is sunny outside is beyond me!)In Seattle, there are hundreds of thousands of these umbrellas in all kinds of colors. Most people call them cars.1、使用委托分离接口2、使用多重继承分离接口五、合成/聚合复用原则(CARP)合成/聚合复用原则(Composite/Aggregate Reuse Principle或CARP)经常又叫做合成复用原则(Composite Reuse Principle或CRP),就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新对象通过向这些对象的委派达到复用已有功能的目的。
c设计模式之装饰者模式(decoratorpattern)
C# 设计模式之装饰者模式(Decorator Pattern)1.概述装饰者模式,英文名叫做Decorator Pattern 。
装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。
它是通过创建一个包装对象,也就是装饰来包裹真实的对象。
2.特点(1)装饰对象和真实对象有相同的接口。
这样客户端对象就可以和真实对象相同的方式和装饰对象交互。
(2 )装饰对象包含一个真实对象的引用(reference )(3)装饰对象接受所有来自客户端的请求。
它把这些请求转发给真实的对象。
( 4 )装饰对象可以在转发这些请求以前或以后增加一些附加功能。
这样就确保了在运行时,不用修改给定对象的结构就可以在外部增加附加的功能。
在面向对象的设计中,通常是通过继承来实现对给定类的功能扩展。
3.应用范围1.需要扩展一个类的功能,或给一个类添加附加职责。
2.需要动态的给一个对象添加功能,这些功能可以再动态的撤销。
3.需要增加由一些基本功能的排列组合而产生的非常大量的功能,从而使继承关系变的不现实4.当不能采用生成子类的方法进行扩充时。
一种情况是,可能有大量独立的扩展,为支持每一种组合将产生大量的子类,使得子类数目呈爆炸性增长。
另一种情况可能是因为类定义被隐藏,或类定义不能用于生成子类。
4.优点1.Decorator 模式与继承关系的目的都是要扩展对象的功能,但是Decorator 可以提供比继承更多的灵活性。
2.通过使用不同的具体装饰类以及这些装饰类的排列组合,设计师可以创造出很多不同行为的组合。
(这一条更能体现)5.缺点1. 这种比继承更加灵活机动的特性,也同时意味着更加多的复杂性。
2. 装饰模式会导致设计中出现许多小类,如果过度使用,会使程序变得很复杂。
3.装饰模式是针对抽象组件 ( Component )类型编程。
但是,如果你要针对具体组件编程时,就应该重新思考你的应用架构,以及装饰者是否合适。
当然也可以改变Component 接口,增加新的公开的行为,实现“半透明”的装饰者模式。
C 设计模式整理
C#设计模式学习笔记概述 (2)创建型模式 (2)Abstract Factory Method (2)Builder (6)Factory Method (9)Singleton (13)Prototype (15)结构型模式 (17)Adapter (17)Bridge (20)Composite (23)Decorator (28)Facade (31)Flyweight (34)Proxy (37)行为型模式 (40)Chain Of Responsibility (40)Command (44)Interperter (47)Iterator (50)Mediator (54)Memento (57)Template Method (60)State (63)Strategy (67)Visitor (69)Observer (72)总结 (76)设计模式的点滴 (76)概述设计模式(Design Pattern)使人们可以更加简单方便地复用成功的设计和体系结构。
将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。
Gof中,把设计模式分为3大类共23种。
参考资料:✧Microsoft Webcast :/china/msdn/events/webcasts/shared/webcast/ consyscourse/CsharpOOD.aspx✧网上一份23中模式的C# code✧《C#设计模式》创建型模式创建型(Creational)模式:负责对象创建Abstract Factory Method✓名称:Abstract Factory Method,抽象工厂模式(创建型模式)✓问题(动机-Motivation):✧在软件系统中,经常面临着“一系列相互依赖的对象”的创建工作;同时,由于需求的变化,往往存在更多系列对象的创建工作。
✧如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合?✓意图(Intent):✧提供一个接口,让该接口负责创建一系列“相关或者相互依赖的对象”,无需指定它们具体的类。
C语言设计模式
目录1.C语言设计模式(开篇) (2)2.C语言和设计模式(继承、封装、多态) (3)2.1继承性 (3)2.2封装性 (4)2.3多态 (4)3.单件模式 (4)4.工厂模式 (5)5.抽象工厂模式 (6)6.访问者模式 (8)7.状态模式 (9)8.命令模式 (9)9.解释器模式 (10)10.备忘录模式 (11)11.观察者模式 (12)12.桥接模式 (12)13.建造者模式 (13)14.中介者模式 (14)15.策略模式 (15)16.适配器模式 (16)17.装饰模式 (17)18.亨元模式 (17)19.代理模式 (18)20.外观模式 (19)21.迭代器模式 (20)22.责任链模式 (21)23.模版模式 (22)24.组合模式 (24)25.原型模式 (25)1.C语言设计模式(开篇)关于软件设计方面的书很多,比如《重构》,比如《设计模式》。
至于软件开发方式,那就更多了,什么极限编程、精益方法、敏捷方法。
随着时间的推移,很多的方法又会被重新提出来。
其实,就我个人看来,不管什么方法都离不开人。
一个人写不出二叉树,你怎么让他写?敏捷吗?你写一行,我写一行。
还是迭代?写三行,删掉两行,再写三行。
项目的成功是偶然的,但是项目的失败却有很多原因,管理混乱、需求混乱、设计低劣、代码质量差、测试不到位等等。
就软件企业而言,没有比优秀的文化和出色的企业人才更重要的了。
从软件设计层面来说,一般来说主要包括三个方面:(1)软件的设计受众,是小孩子、老人、女性,还是专业人士等等;(2)软件的基本设计原则,以人为本、模块分离、层次清晰、简约至上、适用为先、抽象基本业务等等;(3)软件编写模式,比如装饰模式、责任链、单件模式等等。
从某种意义上说,设计思想构成了软件的主题。
软件原则是我们在开发中的必须遵循的准绳。
软件编写模式是开发过程中的重要经验总结。
灵活运用设计模式,一方面利于我们编写高质量的代码,另一方面也方便我们对代码进行维护。
C语言设计模式
C++有三个最重要的特点,即继承、封装、多态。
我发现其实C语言也是可以面向对象的,也是可以应用设计模式的,关键就在于如何实现面向对象语言的三个重要属性。
(1)继承性[cpp]view plaincopy1.typedef struct _parent2.{3.int data_parent;4.5.}Parent;6.7.typedef struct _Child8.{9.struct _parent parent;10.int data_child;11.12.}Child;在设计C语言继承性的时候,我们需要做的就是把基础数据放在继承的结构的首位置即可。
这样,不管是数据的访问、数据的强转、数据的访问都不会有什么问题。
(2)封装性[cpp]view plaincopy1.struct _Data;2.3.typedef void (*process)(struct _Data* pData);4.5.typedef struct _Data6.{7.int value;8. process pProcess;9.10.}Data;封装性的意义在于,函数和数据是绑在一起的,数据和数据是绑在一起的。
这样,我们就可以通过简单的一个结构指针访问到所有的数据,遍历所有的函数。
封装性,这是类拥有的属性,当然也是数据结构体拥有的属性。
(3)多态[cpp]view plaincopy1.typedef struct _Play2.{3.void* pData;4.void (*start_play)(struct _Play* pPlay);5.}Play;多态,就是说用同一的接口代码处理不同的数据。
比如说,这里的Play结构就是一个通用的数据结构,我们也不清楚pData是什么数据,start_play是什么处理函数?但是,我们处理的时候只要调用pPlay->start_play(pPlay)就可以了。
剩下来的事情我们不需要管,因为不同的接口会有不同的函数去处理,我们只要学会调用就可以了。
C设计模式大全
C设计模式大全一、 C# 面向对象程序设计复习 (4)二、设计模式举例 (5)三、先有鸡还是先有蛋? (7)四、大瓶子套小瓶子还是小瓶子套大瓶子? (8)五、 .net本质 (9)一、"开放-封闭"原则(OCP) (11)二、里氏代换原则(LSP) (12)三、依赖倒置原则(DIP) (19)四、接口隔离原则(ISP) (21)五、合成/聚合复用原则(CARP) (21)六、迪米特法则(LoD) (23)一、简单工厂(Simple Factory)模式 (24)二、 Simple Factory模式角色与结构: (24)三、程序举例: (25)四、 Simple Factory模式演化 (27)五、优点与缺点: (30)一、工厂方法(Factory Method)模式 (31)二、 Factory Method模式角色与结构: (31)三、程序举例: (32)四、工厂方法模式与简单工厂模式 (34)五、 Factory Method模式演化 (35)六、 Factory Method模式与其它模式的关系 (36)七、另外一个例子 (36)一、抽象工厂(Abstract Factory)模式 (40)二、 Abstract Factory模式的结构: (41)三、程序举例: (42)四、在什么情形下使用抽象工厂模式: (46)五、抽象工厂的起源 (46)六、 Abstract Factory模式在实际系统中的实现 (48)七、 "开放-封闭"原则 (52)一、单例(Singleton)模式 (53)二、 Singleton模式的结构: (53)三、程序举例: (53)四、在什么情形下使用单例模式: (55)五、 Singleton模式在实际系统中的实现 (55)六、 C#中的Singleton模式 (58)一、建造者(Builder)模式 (59)二、 Builder模式的结构: (60)三、程序举例: (61)四、建造者模式的活动序列: (64)五、建造者模式的实现: (65)六、建造者模式的演化 (70)七、在什么情况下使用建造者模式 (72)一、原型(Prototype)模式 (73)C#对原型模式的支持 (73)二、 Prototype模式的结构: (73)三、程序举例: (74)四、带Prototype Manager的原型模式 (76)五、浅拷贝与深拷贝 (80)六、 Prototype模式的优点与缺点 (82) Prototype模式的优点包括 (82)一、适配器(Adapter)模式 (84)二、类的Adapter模式的结构: (84)三、类的Adapter模式示意性实现: (85)四、对象的Adapter模式的结构: (87)五、对象的Adapter模式示意性实现: (87)六、在什么情况下使用适配器模式 (89)七、一个实际应用Adapter模式的例子 (89)八、关于Adapter模式的讨论 (91)一、合成(Composite)模式 (92)二、合成模式概述 (92)三、安全式的合成模式的结构 (94)四、安全式的合成模式实现 (94)五、透明式的合成模式结构 (97)六、透明式的合成模式实现 (98)七、使用合成模式时考虑的几个问题 (101)八、和尚的故事 (102)九、一个实际应用Composite模式的例子 (102)一、装饰(Decorator)模式 (105)二、装饰模式的结构 (106)三、装饰模式示例性代码 (107)四、装饰模式应当在什么情况下使用 (110)五、装饰模式实际应用的例子 (110)六、使用装饰模式的优点和缺点 (115)七、模式实现的讨论 (115)八、透明性的要求 (116)九、装饰模式在.NET中的应用 (117)一、代理(Proxy)模式 (118)二、代理的种类 (118)三、远程代理的例子 (119)四、代理模式的结构 (119)五、代理模式示例性代码 (120)六、高老庄悟空降八戒 (122)七、不同类型的代理模式 (124)八、代理模式实际应用的例子 (125)一、享元(Flyweight)模式 (127)二、单纯享元模式的结构 (128)三、单纯享元模式的示意性源代码 (129)四、复合享元模式的结构 (131)五、一个咖啡摊的例子 (132)六、咖啡屋的例子 (135)七、享元模式应当在什么情况下使用 (139)八、享元模式的优点和缺点 (139)一、门面(Facade)模式 (139)二、门面模式的结构 (140)三、门面模式的实现 (141)四、在什么情况下使用门面模式 (141)五、一个例子 (141)六、使用门面模式的设计 (146)一、桥梁(Bridge)模式 (150)二、桥梁模式的结构 (151)三、桥梁模式的示意性源代码 (152)四、调制解调器问题 (155)BRIDGE模式 (158)五、另外一个实际应用Bridge模式的例子 (160)六、在什么情况下应当使用桥梁模式 (164)一、职责链(Chain of Responsibility)模式 (166)二、责任链模式的结构 (166)三、责任链模式的示意性源代码 (167)四、纯的与不纯的责任链模式 (170)五、责任链模式的实际应用案例 (170)六、责任链模式的实现 (174)一、命令(Command)模式 (175)二、命令模式的结构 (175)三、命令模式的示意性源代码 (176)四、玉帝传美猴王上天 (179)五、命令模式的实现 (179)六、命令模式的实际应用案例 (180)七、在什么情况下应当使用命令模式 (184)八、使用命令模式的优点和缺点 (185)一、观察者(Observer)模式 (186)二、观察者模式的结构 (186)三、观察者模式的示意性源代码 (188)四、 C#中的Delegate与Event (191)五、一个实际应用观察者模式的例子 (195)六、观察者模式的优缺点 (199)一、访问者(Visitor)模式 (200)二、访问者模式的结构 (201)三、示意性源代码 (202)四、一个实际应用Visitor模式的例子 (206)五、在什么情况下应当使用访问者模式 (210)六、使用访问者模式的优点和缺点 (211)一、模板方法(T emplate Method)模式 (212)二、模版方法模式的结构 (213)三、模板方法模式的示意性代码 (214)四、继承作为复用的工具 (215)五、一个实际应用模板方法的例子 (216)六、模版方法模式中的方法 (219)七、重构的原则 (219)一、策略(Strategy)模式 (220)二、策略模式的结构 (221)三、示意性源代码 (222)四、何时使用何种具体策略角色 (224)五、一个实际应用策略模式的例子 (224)六、在什么情况下应当使用策略模式 (227)七、策略模式的优点和缺点 (228)八、其它 (228)使用接口排序(1).cs求质数.cs冒泡法排序.cs九九表.cs静态与非静态.cs构造函数.cs方法重载.cs多态性.cs递归求阶乘.cs打印三角形.cs传值调用与引用调用.cs二、设计模式举例在设计模式中有一种模式叫Builder模式,其原理如下:我们可以将Builder理解成电饭锅,给这个Builder放进去米和水,经过Builder 的Build后,我们就可以取出香喷喷的米饭了。
设计模式C#案例
设计模式C#案例GRASP-通用责任分配软件模式,GoF-“四人帮”设计模式。
以下案例,JAVA和VC++程序员请分别采用JAVA和VC++程序实现。
为减少测试代码量,采用了C#控制台应用程序;编程环境为微软VS .Net 2008。
1. GRASP模式:多态– C#案例学习多态以及集合类(Main方法中List<T>和Array类)的用法。
多态案例:Person类有虚方法Show(),该类派生出2个子类:Student、Teacher。
1.1 设计类图1.2 案例代码public class Person{public Person() { }public Person(string name, string sex){ = name;this.Sex = sex;}public override string ToString(){return"name " + Name + ", sex " + Sex + ";";}public virtual void Show() //C#虚方法{Console.WriteLine("Person: " + this.ToString());}public string Name { get; set; }public string Sex { get; set; }}public class Student : Person{public Student() { }public Student(string name, string sex,string studentNo,string classname) { = name;this.Sex = sex;this.StudentNO = studentNo;this.Classname = classname;}public override string ToString(){return base.ToString() + " student NO " + StudentNO + ", class " + Classname + ";";}public override void Show(){Console.WriteLine("Student: " + this.ToString());}public string StudentNO { get; set; }public string Classname { get; set; }}public class Teacher : Person{public Teacher() { }public Teacher(string name, string sex, string department, string professionalTitle){ = name;this.Sex = sex;this.Department = department;this.ProfessionalTitle = professionalTitle;}public override string ToString(){return base.ToString() + " department "+ Department + ", professional title " + ProfessionalTitle + ";";}public override void Show(){Console.WriteLine("Teacher: " + this.ToString());}public string Department { get; set; }public string ProfessionalTitle { get; set; }}class Program{static void Main(string[] args){Console.WriteLine("Test classSystem.Collections.Generic.List<T> ..");List<Person> persons = new List<Person>();//Person家族(Person及其子孙类)类对象均可存入其中Person p1 = new Person("张三", "男");persons.Add(p1); //List<T>.Add()方法persons.Add(new Person("李丽", "女"));persons.Add(new Student("张强", "男", "201201189","计科1201"));persons.Add(new Person("Jack", "man"));persons.Add(new Teacher("田建华", "男", "电信学院", "讲师"));persons.Add(new Teacher("包小军", "男", "计科院", "副教授"));foreach (Person p in persons) p.Show();//此时调用的是哪个类的Show()方法?persons.Remove(p1); //List<T>.Remove()方法foreach (Person p in persons) p.Show();Console.WriteLine("\nTest class System.Array ..");Array arrPerson = Array.CreateInstance(typeof(Person),persons.Count);int i = 0;foreach (Person p in persons) { arrPerson.SetValue(p, i); i++; }//Array.SetValue()foreach (Person p in arrPerson) p.Show();Console.WriteLine("\nAfter Array.Reverse() ..");Array.Reverse(arrPerson); //静态方法,通过类名引用,而不是对象名引用for (i = 0; i < arrPerson.Length; i++){Person p = (Person)arrPerson.GetValue(i); //Array.GetValue()p.Show();}}}1.3 练习与思考(1)申明Person P; 则P可以引用Person、Student、Teacher等3个类的任意对象吗?若可以,则P.Show() 调用的又是哪个类的Show()方法?(2)对家族类对象中的抽象方法(及C# Virtual方法)的多态性有何体会和认识?(3)集合类(C#的List<T>,Array等)是家族类对象的容器,这2个集合类有何区别?试一试其它成员函数,以及其它C#集合类。
01 C设计模式-设计模式概述
引言
不够灵活的影院售票系统
实例说明
• 某软件公司为某电影院开发了一套影院售票系统,在该系统中 需要为不同类型的用户提供不同的电影票打折方式,具体打折 方案如下: • (1) 学生凭学生证可享受票价8折优惠; • (2) 年龄在10周岁及以下的儿童可享受每张票减免10元的优 惠(原始票价需大于等于20元); • (3) 影院VIP用户除享受票价半价优惠外还可进行积分,积 分累计到一定额度可换取电影院赠送的奖品。
• Context(模式可适用的前提条件) • Theme或Problem(在特定条件下要解决的目标问题) • Solution(对目标问题求解过程中各种物理关系的记述)
设计模式的诞生与发展
Christopher Alexander
Richard Helm
Ralph Johnson
John Vlissides
设计模式的诞生与发展
软件模式概述
软件模式:在一定条件下的软件开发问题及其解法 • 问题描述 • 前提条件(环境或约束条件) • 解法
• 效果
设计模式的诞生与发展
引言
庞大的跨平台图像浏览系统
初始设计方案
Image {abstract}
BMPImage
JPGImage
GIFImage
PNGImage
BMPWindowsImp BMPLinuxImp BMPUnixImp
GIFWindowsImp
GIFLinuxImp
GIFUnixImp
设计模式的诞生与发展
Gang of Four (GoF)
设计模式的诞生与发展
Gang of Four
【精选】设计模式之C 版
这里,对设计模式的概念就不细说了,凡是用过或者看过这方面书籍的都应该有所了解。
鄙人认为正是设计模式的出现,使得C++的三大性质——封装、继承和多态发挥的淋漓尽致。
尤其是多态性质,可以说是面向对的精髓所在。
封装性是为了很好的管理数据和方法;继承是为了提高代码的重用;而多态的出现,使得执行过程中,出现多样性,调用一个方法时,可以从父类跳到子类执行,又从子类调用父类的方法等等,函数调用过程呈现曲线形式。
总之,执行期,表现出多样化。
所以,要想很好的掌握设计模式,必须对多态性有很深的了解,再则,对类与类之间的关系有个清晰的认识,类与类之间的关系,无非6大关系——继承和实现、依赖和关联、组合和聚合。
每个模式都是对类之间的这6种关系进行组合,呈现出不同的表现形式,下面,一一介绍23种设计模式,用到的类之间的关系和C++代码(在VS2008调试没问题的)。
先说创建型模式:1、Factory Pattern 工厂模式使用到的类关系:继承和依赖图 1 工厂模式UML图Head.h#ifndef_FACTORY_HEAD_#define_FACTORY_HEAD_#include<iostream>using std::cout;using std::endl;class CProduct;class CFactory{private:public:CFactory(){}~CFactory(){}public:virtual CProduct* CreateProduct() = 0; };class CConcreteFactory : public CFactory {private:public:CConcreteFactory();~CConcreteFactory();public:virtual CProduct* CreateProduct(); };class CProduct{private:public:CProduct(){}~CProduct(){}public:virtual void Operation()=0;};class CConcreteProduct1 : public CProduct {private:public:CConcreteProduct1();~CConcreteProduct1();public:virtual void Operation();};class CConcreteProduct2 : public CProduct {private:public:CConcreteProduct2();~CConcreteProduct2();public:virtual void Operation();};#endifMain.cpp#include"Head.h"CConcreteFactory::CConcreteFactory(){}CConcreteFactory::~CConcreteFactory(){}CProduct* CConcreteFactory::CreateProduct(){return new CConcreteProduct2();}////////////////////////////////////////////////////////// CConcreteProduct1::CConcreteProduct1(){}CConcreteProduct1::~CConcreteProduct1(){}void CConcreteProduct1::Operation(){cout<<"CConcreteProduct1 Operation!"<<endl; }////////////////////////////////////////////////////// CConcreteProduct2::CConcreteProduct2(){}CConcreteProduct2::~CConcreteProduct2(){}void CConcreteProduct2::Operation(){cout<<"CConcreteProduct2 Operation!"<<endl; }int main(){CFactory* pFac = new CConcreteFactory();CProduct* pPro = pFac->CreateProduct();if (pPro != NULL)pPro->Operation();delete pPro;delete pFac;return 0;}2、AbstractFactory Pattern 抽象工厂模式使用到的类关系:继承和依赖图2 抽象工厂模式Head.h#ifndef_ABSTRACT_FACTORY_HEAD_#define_ABSTRACT_FACTORY_HEAD_#include<iostream>using std::cout;using std::endl;class CProductA;class CProductB;class CAbstractFactory{private:public:CAbstractFactory(){}~CAbstractFactory(){}public:virtual CProductA* CreateProductA() = 0;virtual CProductB* CreateProductB() = 0;};class CConcreteAbstractFactory1 : public CAbstractFactory {private:public:CConcreteAbstractFactory1();~CConcreteAbstractFactory1();public:virtual CProductA* CreateProductA();virtual CProductB* CreateProductB();};class CConcreteAbstractFactory2 : public CAbstractFactory {private:public:CConcreteAbstractFactory2();~CConcreteAbstractFactory2();public:virtual CProductA* CreateProductA();virtual CProductB* CreateProductB();};class CProductA{private:public:CProductA(){}~CProductA(){}public:virtual void Operation()=0;};class CConcreteProductA1 : public CProductA{private:public:CConcreteProductA1();~CConcreteProductA1();public:virtual void Operation();};class CConcreteProductA2 : public CProductA{private:public:CConcreteProductA2();~CConcreteProductA2();public:virtual void Operation();class CProductB{private:public:CProductB(){}~CProductB(){}public:virtual void Operation()=0;};class CConcreteProductB1 : public CProductB{private:public:CConcreteProductB1();~CConcreteProductB1();public:virtual void Operation();};class CConcreteProductB2 : public CProductB{private:public:CConcreteProductB2();~CConcreteProductB2();public:virtual void Operation();};#endifMain.cpp#include"Head.h"CConcreteAbstractFactory1::CConcreteAbstractFactory1() {}CConcreteAbstractFactory1::~CConcreteAbstractFactory1() {}CProductA* CConcreteAbstractFactory1::CreateProductA() {return new CConcreteProductA1();}CProductB* CConcreteAbstractFactory1::CreateProductB() {return new CConcreteProductB1();}CConcreteAbstractFactory2::CConcreteAbstractFactory2(){}CConcreteAbstractFactory2::~CConcreteAbstractFactory2(){}CProductA* CConcreteAbstractFactory2::CreateProductA(){return new CConcreteProductA2();}CProductB* CConcreteAbstractFactory2::CreateProductB(){return new CConcreteProductB2();}//////////////////////CConcreteProductA1/////////////////////////////////// CConcreteProductA1::CConcreteProductA1(){}CConcreteProductA1::~CConcreteProductA1(){}void CConcreteProductA1::Operation(){cout<<"CConcreteProductA1 Operation!"<<endl;}//////////////////////CConcreteProductA2/////////////////////////////////// CConcreteProductA2::CConcreteProductA2(){}CConcreteProductA2::~CConcreteProductA2(){}void CConcreteProductA2::Operation(){cout<<"CConcreteProductA2 Operation!"<<endl;}//////////////////////CConcreteProductB1/////////////////////////////////// CConcreteProductB1::CConcreteProductB1(){}CConcreteProductB1::~CConcreteProductB1(){}void CConcreteProductB1::Operation(){cout<<"CConcreteProductB1 Operation!"<<endl;}//////////////////////CConcreteProductB2/////////////////////////////////// CConcreteProductB2::CConcreteProductB2(){}CConcreteProductB2::~CConcreteProductB2(){}void CConcreteProductB2::Operation(){cout<<"CConcreteProductB2 Operation!"<<endl;}int main(){CAbstractFactory* pFac = new CConcreteAbstractFactory1();CProductA* pProA1 = pFac->CreateProductA();if (pProA1 != NULL)pProA1->Operation();CProductB* pProB1 = pFac->CreateProductB();if (pProB1 != NULL)pProB1->Operation();delete pProA1;delete pProB1;delete pFac;return 0;}3、单例模式使用到的类关系:无单例模式很简单,目的就是只创建一个实例,关键是他的构造函数私有的,所以在外部是不能被调用的,只能使用自己的实例化函数进行构造,而实例化函数中,保证了只创建一个实例,下次在调用,如果判断已经创建了一个实例,则只返回已创建的实例,详看程序。
C#设计模式学习
C#设计模式1、设计模式之开篇很长时间没有写文章了,前段时间写的C#语法糖分享得到有很多朋友支持,这个也使得我有信心继续分享下去,在这里非常感谢大家!这次开始给大家分享一下设计模式,我个人觉得设计模式也对于我们提高个人技术水平来说也是一个必不可少的知识点,最近我有重新温习了一下设计模式,今天把我学习时的心得给大家分享一下。
有些朋友会分不清设计模式是什么,它是框架吗?在这里我简单的分享一下我的个人理解,有些不对地方请大家谅解和指正,废话不多说,直接进入主题:设计模式和框架的区别:设计模式是针对某一类问题的最佳解决方案,而且已经成功应用于许多系统的设计中,它解决了在某种特定情景中重复发生的某个问题,因此,可以这样定义设计模式:“设计模式是从许多优秀的软件系统中总结出的成功的可复用的设计方案。
框架不是模式,框架是针对某个领域,提供用于开发应用系统的类的集合。
程序设计者可以使用框架提供的类设计一个应用程序,而在设计应用程序时可以针对特定的问题使用某个模式。
一个框架往往会包括多个设计模式,他们是面向对象系统获得最大复用的方式。
设计模式分类如下图所示:这次分享主要给大家分享设计模式和框架的区别及设计模式的分类,下次开始分享具体的设计模式。
希望给大家带来帮助!谢谢。
2、设计模式之设计原则我们这次分享讲解具体设计模式之前给大家分享一下设计模式原则,很多人有可能会疑惑为什么要用设计模式啊?设计模式有什么好处,设计模式就是很多前辈们在他们设计软件时在大量的编码中总结出来的一些思路,因为大家都知道有一个好的框架思路是一个软件成功与否的关键。
个人理解设计模式是面向对象的更优的代码风格及封装。
我们平时编码时会遇到如下一些问题:1)系统僵化,不可修改或不可扩展(修改难或者扩展难)。
2)过分复杂或者重复代码太多,往往看代码时不知道从哪里看起,也不知道程序会跑到哪里。
3)不可复用,公共部分剥离不出来,只能到处拷贝。
4)不够稳定:经常出错,然后修改,再出错,继续改。
C语言设计模式
目录1.C语言设计模式(开篇) (2)2.C语言和设计模式(继承、封装、多态) (3)2.1继承性 (3)2.2封装性 (4)2.3多态 (4)3.单件模式 (4)4.工厂模式 (5)5.抽象工厂模式 (6)6.访问者模式 (8)7.状态模式 (9)8.命令模式 (9)9.解释器模式 (10)10.备忘录模式 (11)11.观察者模式 (12)12.桥接模式 (12)13.建造者模式 (13)14.中介者模式 (14)15.策略模式 (15)16.适配器模式 (16)17.装饰模式 (17)18.亨元模式 (17)19.代理模式 (18)20.外观模式 (19)21.迭代器模式 (20)22.责任链模式 (21)23.模版模式 (22)24.组合模式 (24)25.原型模式 (25)1.C语言设计模式(开篇)关于软件设计方面的书很多,比如《重构》,比如《设计模式》。
至于软件开发方式,那就更多了,什么极限编程、精益方法、敏捷方法。
随着时间的推移,很多的方法又会被重新提出来。
其实,就我个人看来,不管什么方法都离不开人。
一个人写不出二叉树,你怎么让他写?敏捷吗?你写一行,我写一行。
还是迭代?写三行,删掉两行,再写三行。
项目的成功是偶然的,但是项目的失败却有很多原因,管理混乱、需求混乱、设计低劣、代码质量差、测试不到位等等。
就软件企业而言,没有比优秀的文化和出色的企业人才更重要的了。
从软件设计层面来说,一般来说主要包括三个方面:(1)软件的设计受众,是小孩子、老人、女性,还是专业人士等等;(2)软件的基本设计原则,以人为本、模块分离、层次清晰、简约至上、适用为先、抽象基本业务等等;(3)软件编写模式,比如装饰模式、责任链、单件模式等等。
从某种意义上说,设计思想构成了软件的主题。
软件原则是我们在开发中的必须遵循的准绳。
软件编写模式是开发过程中的重要经验总结。
灵活运用设计模式,一方面利于我们编写高质量的代码,另一方面也方便我们对代码进行维护。
设计模式--MVC(C++版)
设计模式--MVC(C++版)MVC 模式代表 Model-View-Controller(模型-视图-控制器)模式。
这种模式⽤于应⽤程序的分层开发。
Model(模型)-是应⽤程序中⽤于处理应⽤程序数据逻辑的部分。
通常模型对象负责在数据库中存取数据。
View(视图) -是应⽤程序中处理数据显⽰的部分。
通常视图是依据模型数据创建的。
Controller(控制器) - 是应⽤程序中处理⽤户交互的部分。
通常控制器负责从视图读取数据,控制⽤户输⼊,并向模型发送数据。
MVC 分层有助于管理复杂的应⽤程序,因为您可以在⼀个时间内专门关注⼀个⽅⾯。
例如,您可以在不依赖业务逻辑的情况下专注于视图设计。
同时也让应⽤程序的测试更加容易。
MVC 分层同时也简化了分组开发。
不同的开发⼈员可同时开发视图、控制器逻辑和业务逻辑。
以C++代码为例,设计英雄(Hero)对战demo。
Hero1对Hero2进⾏攻击,Hero2不断掉⾎,UI同步更新。
主要三个类,分别为Hero(英雄数据类),HeroView(英雄UI类,如⾎条)和HeroController(英雄控制器类,Hero管理类)。
Hero类:1#pragma once23class Hero4 {5public:6 Hero();7 ~Hero();8//be attacked9void beAttack(int att);10//is dead?11bool dead() { return m_nHp == 0; }12public:13//set no14void setNo(std::string no) { m_sNo = no; }15//get no16 std::string getNo() { return m_sNo; }1718//set name19void setName(std::string name) { m_sName = name; }20//get name21 std::string getName() { return m_sName; }2223//get hp24void setHp(int hp) { m_nHp = hp; }25//set hp26int getHp() { return m_nHp; }2728//set att29void setAtt(int att) { m_nAtt = att; }30//get att31int getAtt() { return m_nAtt; }32private:3334 std::string m_sName;//姓名35 std::string m_sNo;//游戏场号码3637int m_nHp;//⾎量38int m_nAtt;//攻击⼒39 };Hero.h1 #include "stdafx.h"2 #include "Hero.h"34//ctor5 Hero::Hero()6 {7 }89//Destructor10 Hero::~Hero()11 {1213 }1415void Hero::beAttack(int att)16 {17if (att <= 0) throw"Att Number <= 0";//safe check18 m_nHp -= att;19 m_nHp = m_nHp < 0 ? 0 : m_nHp;//safe check20 }Hero.cppHeroView类:1#pragma once2class HeroView3 {4public:5 HeroView();6 ~HeroView();78//show hero UI data;9void show(string no, string name,int att, int hp);10//show hero dead UI;11void dead(string no, string name);12//show heor winned UI;13void winned(string no, string name);14private:15//Hero* m_hero;16 };HeroView.h1 #include "stdafx.h"2 #include "HeroView.h"3456 HeroView::HeroView()7 {8 }910 HeroView::~HeroView()11 {12 }1314void HeroView::show(string no,string name, int att, int hp)15 {16 cout << "Hero info:"<<"(no:"<<no<<",name:"<<name<<",att:"<<att<<",hp:"<<hp<<")" << endl;17 }1819void HeroView::dead(string no, string name)20 {21 cout << "Hero Dead:" << "(no:" << no << ",name:"<<name << ")" << endl;22 }2324void HeroView::winned(string no, string name)25 {26 cout << "Hero Winned:" << "(no:" << no << ",name:" << name << ")" << endl;2728 }HeroView.cppHeroController类:1#pragma once2class HeroController3 {4public:5 HeroController(string no, string name);6 ~HeroController();7void setHeroHp(int hp);//set hero hp8void setHeroAtt(int att);//set hero att9void show();//show hero info10void beAttack(int att);//be attacked by hero11void dead();//dead12void winned();//winned13public :14 Hero* getHero() { return m_hero; }//get hero1516private:17 Hero * m_hero;//hero18 HeroView * m_heroView;//hero view19 };HeroController.h1 #include "stdafx.h"2 #include "HeroController.h"345 HeroController::HeroController(string no, string name)6 {7 m_heroView = new HeroView();8 m_hero = new Hero();9 m_hero->setNo(no);10 m_hero->setName(name);11 }121314 HeroController::~HeroController()15 {16 }171819void HeroController::setHeroHp(int hp)20 {21 m_hero->setHp(hp);22 }2324void HeroController::setHeroAtt(int att)25 {26 m_hero->setAtt(att);27 }2829void HeroController::show()30 {31 m_heroView->show(m_hero->getNo(), m_hero->getName(),m_hero->getAtt(), m_hero->getHp());32 }3334void HeroController::beAttack(int att)35 {36 m_hero->beAttack(att);37 }3839void HeroController::dead()40 {41 m_heroView->dead(m_hero->getNo(),m_hero->getName());42 }4344void HeroController::winned()45 {46 m_heroView->winned(m_hero->getNo(), m_hero->getName());47 }HeroController.cppmain() 测试:1// ConsoleApplication_C++1.cpp: 主项⽬⽂件。
c模板设计模式
c,,,模板,设计模式篇一:C_设计模式(23种设计模式)C#设计模式(23种设计模式)创建型:1. 单件模式(Singleton Pattern)2. 抽象工厂(Abstract Factory)3. 建造者模式(Builder)4. 工厂方法模式(Factory Method)5. 原型模式(Prototype)结构型:6. 适配器模式(Adapter Pattern)7. 桥接模式(Bridge Pattern)8. 装饰模式(Decorator Pattern)9. 组合模式(Composite Pattern)10. 外观模式(Facade Pattern)11. 享元模式(Flyweight Pattern)12. 代理模式(Proxy Pattern)13. 模板方法(Template Method)14. 命令模式(Command Pattern)15. 迭代器模式(Iterator Pattern)行为型:16. 观察者模式(Observer Pattern)17. 解释器模式(Interpreter Pattern)18. 中介者模式(Mediator Pattern)19. 职责链模式(Chain of Responsibility Pattern)20. 备忘录模式(Memento Pattern)21. 策略模式(Strategy Pattern)22. 访问者模式(Visitor Pattern)23. 状态模式(State Pattern)C#设计模式(23种设计模式)篇二:23种设计模式---大牛笔记设计模式(Design Patterns)——可复用面向对象软件的基础设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。
C设计模式大全
C#设计模式(1) ...................................................................... 错误!未定义书签。
一、 C# 面向对象程序设计复习....................................... 错误!未定义书签。
二、设计模式举例 ............................................................... 错误!未定义书签。
三、先有鸡还是先有蛋?................................................... 错误!未定义书签。
四、大瓶子套小瓶子还是小瓶子套大瓶子?................... 错误!未定义书签。
五、本质 ............................................................................... 错误!未定义书签。
C#设计模式(2) ...................................................................... 错误!未定义书签。
一、"开放-封闭"原则(OCP) ........................................ 错误!未定义书签。
二、里氏代换原则(LSP).............................................. 错误!未定义书签。
C#设计模式(3) ...................................................................... 错误!未定义书签。
三、依赖倒置原则(DIP) .................................................. 错误!未定义书签。
c#设计模式之:外观模式(Facade)
c#设计模式之:外观模式(Facade)在软件开发过程中,客户端程序经常会与复杂系统的内部⼦系统进⾏耦合,从⽽导致客户端程序随着⼦系统的变化⽽变化,然⽽为了将复杂系统的内部⼦系统与客户端之间的依赖解耦,从⽽就有了外观模式,也称作 ”门⾯“模式。
下⾯就具体介绍下外观模式。
2.1定义外观模式提供了⼀个统⼀的接⼝,⽤来访问⼦系统中的⼀群接⼝。
外观定义了⼀个⾼层接⼝,让⼦系统更容易使⽤。
使⽤外观模式时,我们创建了⼀个统⼀的类,⽤来包装⼦系统中⼀个或多个复杂的类,客户端可以直接通过外观类来调⽤内部⼦系统中⽅法,从⽽外观模式让客户和⼦系统之间避免了紧耦合。
2.2 外观模式的结构图介绍了外观模式的定义之后,让我们具体看看外观模式的由来以及实现,下⾯与学校中⼀个选课系统为例来解释外观模式,例如在选课系统中,有注册课程⼦系统和通知⼦系统,在不使⽤外观模式的情况下,客户端必须同时保存注册课程⼦系统和通知⼦系统两个引⽤,如果后期这两个⼦系统发⽣改变时,此时客户端的调⽤代码也要随之改变,这样就没有很好的可扩展性,下⾯看看不使⽤外观模式下选课系统的实现⽅式和客户端调⽤代码:/// <summary>/// 不使⽤外观模式的情况/// 此时客户端与三个⼦系统都发送了耦合,使得客户端程序依赖与⼦系统/// 为了解决这样的问题,我们可以使⽤外观模式来为所有⼦系统设计⼀个统⼀的接⼝/// 客户端只需要调⽤外观类中的⽅法就可以了,简化了客户端的操作/// 从⽽让客户和⼦系统之间避免了紧耦合/// </summary>class Client{static void Main(string[] args){SubSystemA a = new SubSystemA();SubSystemB b = new SubSystemB();SubSystemC c = new SubSystemC();a.MethodA();b.MethodB();c.MethodC();Console.Read();}}// ⼦系统Apublic class SubSystemA{public void MethodA(){Console.WriteLine("执⾏⼦系统A中的⽅法A");}}// ⼦系统Bpublic class SubSystemB{public void MethodB(){Console.WriteLine("执⾏⼦系统B中的⽅法B");}}// ⼦系统Cpublic class SubSystemC{public void MethodC(){Console.WriteLine("执⾏⼦系统C中的⽅法C");}}View Code然⽽外观模式可以解决我们上⾯所说的问题,下⾯具体看看使⽤外观模式的实现:234567891011/// <summary>/// 以学⽣选课系统为例⼦演⽰外观模式的使⽤/// 学⽣选课模块包括功能有:/// 验证选课的⼈数是否已满/// 通知⽤户课程选择成功与否/// 客户端代码/// </summary>class Student{private static RegistrationFacade facade = new RegistrationFacade();static void Main(string[] args){if (facade.RegisterCourse("设计模式", "Learning Hard")){Console.WriteLine("选课成功");}else{Console.WriteLine("选课失败");}Console.Read();}}// 外观类public class RegistrationFacade{private RegisterCourse registerCourse;private NotifyStudent notifyStu;public RegistrationFacade(){registerCourse = new RegisterCourse();notifyStu = new NotifyStudent();}public bool RegisterCourse(string courseName, string studentName){if (!registerCourse.CheckAvailable(courseName)){return false;}return notifyStu.Notify(studentName);}}#region ⼦系统// 相当于⼦系统Apublic class RegisterCourse{public bool CheckAvailable(string courseName){Console.WriteLine("正在验证课程 {0}是否⼈数已满", courseName);return true;}}// 相当于⼦系统B// 相当于⼦系统Bpublic class NotifyStudent{public bool Notify(string studentName){Console.WriteLine("正在向{0}发⽣通知", studentName);return true;}}#endregionView Code使⽤了外观模式之后,客户端只依赖与外观类,从⽽将客户端与⼦系统的依赖解耦了,如果⼦系统发⽣改变,此时客户端的代码并不需要去改变。
设计模式之C#简单工厂模式
前言:设计模式是软件开发领域的精髓之一。
学好设计模式是目前每一个开发人员的必修课。
目前关于设计模式的书很多,其中比较好的有GOF那本的中译本,但并不很适合初学者。
还有一本是《JAVA与模式》,比较适合初学者使用,在此强烈推荐。
但这本书的不足之处是一些地方讲的过于繁琐,很多地方只须简单说明一下即可,却大费笔墨,使得书籍很厚,看起来费力。
而且是用JAVA描述的,这使得一些只懂C#的人无从下手。
我是一个.net的拥护者,为了看这本书我特意看了些JAVA的书,感觉JAVA在书籍的多样性方面比 .net好很多,而且不少书籍的质量很高。
可能是现在JAVA已经比较成熟的原因吧。
为了方便.net的爱好者学习设计模式,在此把我学习《JAVA与模式》这本书的学习笔记发出来,并用C#语言重新描述,希望能对初学者有所帮助。
其实设计模式也并不是什么高深的理论,个人认为并不是象一些人所说的“没写过10万代码就不要谈设计模式”,只要用心学习与实践是完全能够掌握的。
简单工厂模式是类的创建模式,又叫做静态工厂方法模式。
就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。
一般涉及到三种角色(如下图):工厂类:担任这个角色的是工厂方法模式的核心,含有与应用紧密相关的商业逻辑。
工厂类在客户端的直接调用下创建产品对象,它往往由一个具体的类实现。
抽象产品角色:担任这个角色的类是由工厂方法模式所创建的对象的父类,或她们共同拥有的接口。
一般由接口或抽象类实现。
具体产品角色:工厂方法模式所创建的任何对象都是这个角色的实例,由具体类实现。
简单工厂模式优缺点:模式的核心是工厂类,这个类负责产品的创建,而客户端可以免去产品创建的责任,这实现了责任的分割。
但由于工厂类集中了所有产品创建逻辑的,如果不能正常工作的话会对系统造成很大的影响。
如果增加新产品必须修改工厂角色的源码。
以园丁种植水果为例讨论该模式的具体实现:Fruit 水果接口,规定水果具有的一些共同特性Apple 苹果类派生自Fruit接口Strawberry 草莓类派生自Fruit接口FruitGardener 园丁类负责草莓与苹果的创建工作。
深入浅出《设计模式》之工厂模式(C++)
深⼊浅出《设计模式》之⼯⼚模式(C++)前⾔模式介绍在之前简单⼯⼚模式中,我们介绍了简单⼯⼚模式的缺陷是违背了开放-封闭原则。
如果在⾯馆中添加了烤海参,那将会修改waiter⼯⼚类。
违背了类内封闭原则。
还以⾯馆为例,现在两种⾯,⽤⼀个服务员来卖就可以,如果这个服务员不⼲了,后⾯卖⾯的厨师需要兼职顶替服务员,但是厨师⼜不能离开灶台,就将模式改成了窗⼝排队式,⼀队海参炒⾯,另⼀队辣根汤⾯。
每个窗⼝分别有⼀个厨师放饭,⼀个会做海参炒⾯,另⼀个会做辣根汤⾯。
⽼板觉得这种模式挺好,万⼀来了⼀个会做烤海参的,就只需要开⼀个烤海参的窗⼝就好了,不需要重新要服务员学习,因为烤海参的就会卖。
这就变成了⼯⼚模式。
UML类图这⾥涉及到2种类①我,客户端,排队买饭。
②做饭厨师类,⼯⼚类,为我⽣成饭。
③菜品类,⽣成菜品类。
具体关系如下UML类图:代码实例下⾯是noodle类,是为⼯⼚类使⽤的,继承他就可以扩展noodle类别:#ifndef NOODLE_H#define NOODLE_Hclass noodle{public:noodle() {}~noodle() {}virtual void eating() = 0;};#endif // NOODLE_H下⾯是海参炒⾯类,继承了noodle,实现eating⽅法,吃海参炒⾯:#ifndef HAISHENNOODLE_H#define HAISHENNOODLE_H#include "noodle.h"class haishennoodle : public noodle{public:haishennoodle();~haishennoodle();virtual void eating();};#endif // HAISHENNOODLE_H#include <iostream>#include "haishennoodle.h"haishennoodle::haishennoodle(){}haishennoodle::~haishennoodle(){}void haishennoodle::eating(){std::cout << "我是海参炒⾯,⾥⾯没有海参哦!!吃的时候注意!" << std::endl;}下⾯是辣根汤⾯,继承了noodle,实现eating⽅法,吃辣根汤⾯:#ifndef LAGENNOODLE_H#define LAGENNOODLE_H#include "noodle.h"class lagennoodle : public noodle{public:lagennoodle();~lagennoodle();virtual void eating();};#endif // LAGENNOODLE_H#include <iostream>#include "lagennoodle.h"lagennoodle::lagennoodle(){}lagennoodle::~lagennoodle(){}void lagennoodle::eating(){std::cout << "我是辣根汤⾯,吃完呛的哼啊!!!" << std::endl;}下⾯是waiter⼯⼚的基类。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
这里,对设计模式的概念就不细说了,凡是用过或者看过这方面书籍的都应该有所了解。
鄙人认为正是设计模式的出现,使得C++的三大性质——封装、继承和多态发挥的淋漓尽致。
尤其是多态性质,可以说是面向对的精髓所在。
封装性是为了很好的管理数据和方法;继承是为了提高代码的重用;而多态的出现,使得执行过程中,出现多样性,调用一个方法时,可以从父类跳到子类执行,又从子类调用父类的方法等等,函数调用过程呈现曲线形式。
总之,执行期,表现出多样化。
所以,要想很好的掌握设计模式,必须对多态性有很深的了解,再则,对类与类之间的关系有个清晰的认识,类与类之间的关系,无非6大关系——继承和实现、依赖和关联、组合和聚合。
每个模式都是对类之间的这6种关系进行组合,呈现出不同的表现形式,下面,一一介绍23种设计模式,用到的类之间的关系和C++代码(在VS2008调试没问题的)。
先说创建型模式:1、Factory Pattern 工厂模式使用到的类关系:继承和依赖图 1 工厂模式UML图Head.h#ifndef_FACTORY_HEAD_#define_FACTORY_HEAD_#include<iostream>using std::cout;using std::endl;class CProduct;class CFactory{private:public:CFactory(){}~CFactory(){}public:virtual CProduct* CreateProduct() = 0; };class CConcreteFactory : public CFactory {private:public:CConcreteFactory();~CConcreteFactory();public:virtual CProduct* CreateProduct(); };class CProduct{private:public:CProduct(){}~CProduct(){}public:virtual void Operation()=0;};class CConcreteProduct1 : public CProduct {private:public:CConcreteProduct1();~CConcreteProduct1();public:virtual void Operation();};class CConcreteProduct2 : public CProduct {private:public:CConcreteProduct2();~CConcreteProduct2();public:virtual void Operation();};#endifMain.cpp#include"Head.h"CConcreteFactory::CConcreteFactory(){}CConcreteFactory::~CConcreteFactory(){}CProduct* CConcreteFactory::CreateProduct(){return new CConcreteProduct2();}////////////////////////////////////////////////////////// CConcreteProduct1::CConcreteProduct1(){}CConcreteProduct1::~CConcreteProduct1(){}void CConcreteProduct1::Operation(){cout<<"CConcreteProduct1 Operation!"<<endl; }////////////////////////////////////////////////////// CConcreteProduct2::CConcreteProduct2(){}CConcreteProduct2::~CConcreteProduct2(){}void CConcreteProduct2::Operation(){cout<<"CConcreteProduct2 Operation!"<<endl; }int main(){CFactory* pFac = new CConcreteFactory();CProduct* pPro = pFac->CreateProduct();if (pPro != NULL)pPro->Operation();delete pPro;delete pFac;return 0;}2、AbstractFactory Pattern 抽象工厂模式使用到的类关系:继承和依赖图2 抽象工厂模式Head.h#ifndef_ABSTRACT_FACTORY_HEAD_#define_ABSTRACT_FACTORY_HEAD_#include<iostream>using std::cout;using std::endl;class CProductA;class CProductB;class CAbstractFactory{private:public:CAbstractFactory(){}~CAbstractFactory(){}public:virtual CProductA* CreateProductA() = 0;virtual CProductB* CreateProductB() = 0;};class CConcreteAbstractFactory1 : public CAbstractFactory {private:public:CConcreteAbstractFactory1();~CConcreteAbstractFactory1();public:virtual CProductA* CreateProductA();virtual CProductB* CreateProductB();};class CConcreteAbstractFactory2 : public CAbstractFactory {private:public:CConcreteAbstractFactory2();~CConcreteAbstractFactory2();public:virtual CProductA* CreateProductA();virtual CProductB* CreateProductB();};class CProductA{private:public:CProductA(){}~CProductA(){}public:virtual void Operation()=0;};class CConcreteProductA1 : public CProductA{private:public:CConcreteProductA1();~CConcreteProductA1();public:virtual void Operation();};class CConcreteProductA2 : public CProductA{private:public:CConcreteProductA2();~CConcreteProductA2();public:virtual void Operation();class CProductB{private:public:CProductB(){}~CProductB(){}public:virtual void Operation()=0;};class CConcreteProductB1 : public CProductB{private:public:CConcreteProductB1();~CConcreteProductB1();public:virtual void Operation();};class CConcreteProductB2 : public CProductB{private:public:CConcreteProductB2();~CConcreteProductB2();public:virtual void Operation();};#endifMain.cpp#include"Head.h"CConcreteAbstractFactory1::CConcreteAbstractFactory1() {}CConcreteAbstractFactory1::~CConcreteAbstractFactory1() {}CProductA* CConcreteAbstractFactory1::CreateProductA() {return new CConcreteProductA1();}CProductB* CConcreteAbstractFactory1::CreateProductB() {return new CConcreteProductB1();}CConcreteAbstractFactory2::CConcreteAbstractFactory2(){}CConcreteAbstractFactory2::~CConcreteAbstractFactory2(){}CProductA* CConcreteAbstractFactory2::CreateProductA(){return new CConcreteProductA2();}CProductB* CConcreteAbstractFactory2::CreateProductB(){return new CConcreteProductB2();}//////////////////////CConcreteProductA1/////////////////////////////////// CConcreteProductA1::CConcreteProductA1(){}CConcreteProductA1::~CConcreteProductA1(){}void CConcreteProductA1::Operation(){cout<<"CConcreteProductA1 Operation!"<<endl;}//////////////////////CConcreteProductA2/////////////////////////////////// CConcreteProductA2::CConcreteProductA2(){}CConcreteProductA2::~CConcreteProductA2(){}void CConcreteProductA2::Operation(){cout<<"CConcreteProductA2 Operation!"<<endl;}//////////////////////CConcreteProductB1/////////////////////////////////// CConcreteProductB1::CConcreteProductB1(){}CConcreteProductB1::~CConcreteProductB1(){}void CConcreteProductB1::Operation(){cout<<"CConcreteProductB1 Operation!"<<endl;}//////////////////////CConcreteProductB2/////////////////////////////////// CConcreteProductB2::CConcreteProductB2(){}CConcreteProductB2::~CConcreteProductB2(){}void CConcreteProductB2::Operation(){cout<<"CConcreteProductB2 Operation!"<<endl;}int main(){CAbstractFactory* pFac = new CConcreteAbstractFactory1();CProductA* pProA1 = pFac->CreateProductA();if (pProA1 != NULL)pProA1->Operation();CProductB* pProB1 = pFac->CreateProductB();if (pProB1 != NULL)pProB1->Operation();delete pProA1;delete pProB1;delete pFac;return 0;}3、单例模式使用到的类关系:无单例模式很简单,目的就是只创建一个实例,关键是他的构造函数私有的,所以在外部是不能被调用的,只能使用自己的实例化函数进行构造,而实例化函数中,保证了只创建一个实例,下次在调用,如果判断已经创建了一个实例,则只返回已创建的实例,详看程序。