C++简单工厂模式幻灯片

合集下载

第4章 简单工厂模式

第4章 简单工厂模式

简单工厂模式
模式实例与解析
实例一:简单电视机工厂
HaierTV + play () : void ...
TV + play () : void ...
TVFactory + produceTV (String brand) : TV ...
HisenseTV + play () : vo析
实例一:简单电视机工厂
• 某电视机厂专为各知名电视机品牌代工生产各类电视机,当需 要海尔牌电视机时只需要在调用该工厂的工厂方法时传入参数 “Haier”,需要海信电视机时只需要传入参数“Hisense”,工厂 可以根据传入的不同参数返回不同品牌的电视机。现使用简单 工厂模式来模拟该电视机工厂的生产过程。
本章小结
简单工厂模式的要点在于:当你需要什么,只需要传入一 个正确的参数,就可以获取你所需要的对象,而无须知道 其创建细节。 简单工厂模式最大的优点在于实现对象的创建和对象的使 用分离,将对象的创建交给专门的工厂类负责,但是其最 大的缺点在于工厂类不够灵活,增加新的具体产品需要修 改工厂类的判断逻辑代码,而且产品较多时,工厂方法代 码将会非常复杂。 简单工厂模式适用情况包括:工厂类负责创建的对象比较 少;客户端只知道传入工厂类的参数,对于如何创建对象 不关心。
简单工厂模式
模式优缺点
简单工厂模式的优点
• 工厂类含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类 的实例,客户端可以免除直接创建产品对象的责任,而仅仅“消费” 产品;简单工厂模式通过这种做法实现了对责任的分割,它提供了专 门的工厂类用于创建对象。 • 客户端无须知道所创建的具体产品类的类名,只需要知道具体产品类 所对应的参数即可,对于一些复杂的类名,通过简单工厂模式可以减 少使用者的记忆量。 • 通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增 加新的具体产品类,在一定程度上提高了系统的灵活性。

简约风C语言程序设计PPT模板

简约风C语言程序设计PPT模板

3、计算机数值表示
• 十进制转换为R进制:整数和小数分别进行转换,再组合起来。 • 整数部分的转换:采取除R取余法 • 小数部分的转换:采取乘R取整法
3、计算机数值表示
计算机中正负数的表示: 数据在内存中是以二进制形式存放的
例如:3 =(0000000000000011)2 要区别:+3 和 -3 方法是:将符号也数码化,并且将其放在第一位。
正的符号 +用 0 表示 负的符号 -用 1 表示 数值是以补码表示的。 正数的补码和其原码的形式相同。 负数的补码:将该数的绝对值的二进制形式,按位取反 再加1 ,因此有如下表示:
4、计算机软件系统
软件是指为了运行、管理和维护计算机而编 制的各种程序、数据、文档的总称。 计算机软件按功能分为系统软件和应用软件。
6
000101
0000001100 打印
7
000110
停机
5、计算机中的程序语言C
• 计算机语言: • 汇编语言:采用助记符代替机器语言中的指令和数据。面向机
器,速度快;占用存储空间小,但是必须通过汇编程序翻译成 机器语言。缺点同样是通用性和可移植性差。 • mov ax,1 • mov bx,1 • add ax,bx
3、计算机数值表示
书写规则: 在数字后面加写相应英文字母作为标识: B(Binary) -- 二进制1100可表示为1100B O(Octonary) -- 八进制172可表示为172O D(Decimal)-- 十进制95可表示为95D H(Hexadecimal)--十六进制6FA2可写成6FA2H
开始学习前的问题
• 怎样算学好了《C语言程序设计》? • 答: • 1、会看懂C语言程序是已入皮毛 • 2、会写正确的C语言程序是基本入门 • 3、会用C语言程序解决一些实际问题是基本掌握 • 4、用规范的C语言代码写通用算法是掌握了C语言 • 5、用规范的C语言代码写成库供第三人使用算是熟练 • 6、用规范的C语言代码、模块化的思想、遵守软件工程的规范写成商业软

C#设计模式工厂模式

C#设计模式工厂模式

∙简单工厂(Simple Factory)模式∙工厂方法(Factory Method)模式∙抽象工厂(Abstract Factory)模式一、简单工厂(Simple Factory)模式Simple Factory模式根据提供给它的数据,返回几个可能类中的一个类的实例。

通常它返回的类都有一个公共的父类和公共的方法。

Simple Factory模式实际上不是GoF 23个设计模式中的一员。

二、 Simple Factory模式角色与结构:工厂类角色Creator (LightSimpleFactory):工厂类在客户端的直接控制下(Create方法)创建产品对象。

抽象产品角色Product (Light):定义简单工厂创建的对象的父类或它们共同拥有的接口。

可以是一个类、抽象类或接口。

具体产品角色ConcreteProduct (BulbLight, TubeLight):定义工厂具体加工出的对象。

三、程序举例:using System;public abstract class Light{public abstract void TurnOn();public abstract void TurnOff();}public class BulbLight : Light{public override void TurnOn(){Console.WriteLine("Bulb Light is Turned on");}public override void TurnOff(){Console.WriteLine("Bulb Light is Turned off");}}public class TubeLight : Light{public override void TurnOn(){Console.WriteLine("Tube Light is Turned on");}public override void TurnOff(){Console.WriteLine("Tube Light is Turned off");}}public class LightSimpleFactory{public Light Create(string LightType){if(LightType == "Bulb")return new BulbLight();else if(LightType == "Tube")return new TubeLight();elsereturn null;}}public class Client{public static void Main(){LightSimpleFactory lsf = new LightSimpleFactory();Light l = lsf.Create("Bulb");l.TurnOn();l.TurnOff();Console.WriteLine("-----------------");l = lsf.Create("Tube");l.TurnOn();l.TurnOff();}}四、 Simple Factory模式演化Simple Factory模式演化(一)除了上面的用法外,在有些情况下Simple Factory可以由抽象产品角色扮演,一个抽象产品类同时是子类的工厂。

工厂PPT模板

工厂PPT模板

设备选型与配置
02
根据生产工艺要求,选择合适的生产设备,并进行合理的配置
和布局,提高生产效率和质量。
设备维护与保养
03
建立完善的设备维护和保养制度,确保设备处于良好状态,延
长设备使用寿命,减少故障率。
产品质量检测与控制
质量检测标准
制定严格的产品质量检测标准,明确各项质量指标和检测方法。
质量控制措施
组织结构图
以图表形式展示工厂的组 织架构,包括各部门和岗 位的职责与关系
管理团队
介绍工厂的管理团队成员 及其背景和专业领域
员工队伍
概述工厂的员工队伍情况, 包括人数、学历、技能水 平等
02 工厂生产流程
原材料采购与库存管理
1 2 3
原材料采购策略 根据生产计划和需求预测,制定合理的原材料采 购策略,包括供应商选择、采购周期、采购数量 等。
成本控制
建立全面的成本管理体系,包括原材料采购、生产过程中的各项费 用以及销售和管理费用等,确保成本控制在合理范围内。
质量管理
强化质量意识,建立完善的质量管理体系,提高产品质量,减少废品 率和返工率,降低质量成本。
设备维护与保养管理
设备日常维护
建立设备日常维护制度,定期对设备进行检查、清洁、润滑等保 养工作,确保设备处于良好状态。
人工智能与机器学习
随着人工智能和机器学习技术的不断 发展,工厂将实现更高程度的自动化 和智能化。
5G与工业互联网融合
5G技术的普及将为工业互联网提供 更高速、更可靠的数据传输服务,促 进工业互联网的深入应用。
数字孪生与虚拟仿真
数字孪生和虚拟仿真技术将帮助工厂 实现更精准的生产计划和优化,提高 生产效率和质量。

C++------简单工厂模式,工厂方法模式和抽象工厂模式

C++------简单工厂模式,工厂方法模式和抽象工厂模式

C++------简单⼯⼚模式,⼯⼚⽅法模式和抽象⼯⼚模式1,设计模式 设计模式是软件开发⼈员在软件开发过程中⾯临的⼀般问题的解决⽅案。

这些解决⽅案是众多软件开发⼈员经过相当长的⼀段时间的试验和错误总结出来的。

2.设计模式原则 1)开闭原则(Open Close Principle) 开闭原则的意思是:对扩展开放,对修改关闭。

在程序需要进⾏拓展的时候,不能去修改原有的代码。

2)⾥⽒代换原则(Liskov Substitution Principle) ⾥⽒代换原则是⾯向对象设计的基本原则之⼀。

⾥⽒代换原则中说,任何基类可以出现的地⽅,⼦类⼀定可以出现。

LS⾥⽒代换原则是对开闭原则的补充。

实现开闭原则的关键步骤就是抽象化,⽽基类与⼦类的继承关系就是抽象化的具体实现,所以⾥⽒代换原则是对实现抽象化的具体步骤的规范。

3)依赖倒转原则(Dependence Inversion Principle) 这个原则是开闭原则的基础,具体内容:针对接⼝编程,依赖于抽象⽽不依赖于具体。

4)接⼝隔离原则(Interface Segregation Principle) 使⽤多个隔离的接⼝,⽐使⽤单个接⼝要好。

它还有另外⼀个意思是:降低类之间的耦合度。

由此可见,其实设计模式就是从⼤型软件架构出发、便于升级和维护的软件设计思想,它强调降低依赖,降低耦合。

5)迪⽶特法则,⼜称最少知道原则(Demeter Principle) 最少知道原则是指:⼀个实体应当尽量少地与其他实体之间发⽣相互作⽤,使得系统功能模块相对独⽴。

6)合成复⽤原则(Composite Reuse Principle) 合成复⽤原则是指:尽量使⽤合成/聚合的⽅式,⽽不是使⽤继承。

.3.简单⼯⼚模式 简单⼯⼚模式是由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例。

例如: 有⼀家⽣产处理核的⼚家,它只有⼀个⼯⼚,能够⽣产两种型号的处理器核。

客户需要什么样的处理器,⼀定要显⽰地告诉⽣产⼯⼚。

《工厂方法模式》PPT课件

《工厂方法模式》PPT课件

17
简单工厂法实现雷锋工厂的UML类图
精选PPT
18
工厂方法实现雷锋工厂的UML类图
精选PPT
19
简单工厂VS工厂方法
简单工厂模式优点:
☞工厂类含有必要的判断逻辑,可以决定在什么 时候创建哪一个产品类的实例,客户端可以免除 直接创建产品对象的责任,而仅仅“消费”产品。 ☞简单工厂模式通过这种做法实现了对责任的 分割。
有特征
虚拟的,表示此 方法是虚方法, 可以被子类重写
方法重写,表示覆盖 父类中相应的成员方

精选PPT
8
工厂方法模式(Factory Method)
定义一个用于创建对象的接口, 让子类决定实例化哪一个类。 工厂方法使一个类的实例化延迟到其子类。
___《设计模式》GoF
精选PPT
9
定义:
工厂方法模式又称为工厂模式,也叫虚拟构造器 (Virtual Constructor)模式或者多态工厂 (Polymorphic Factory)模式,它属于对象创建 型模式。在工厂方法模式中,工厂父类负责定义 创建产品对象的公共接口,而工厂子类则负责生 产具体的产品对象,这样做的目的是将产品类的 实例化操作延迟到工厂子类中完成,即通过工厂 子类来确定究竟应该实例化哪一个具体产品类。
精选PPT
10
工厂方法模式(Factory Method)结构图
定义工厂方法所创建的对 象的借口
声明工厂方法,该方法返回一个Product 类型的对象
具体的产品,实现了 Product借口
精选PPT
重定义工厂方法以返回一个 ConcreteProduct 实例
11
接口:
看似是:声明了一个类,而且类的成员都具有“行为”

工厂模式(简单工厂、工厂方法、抽象工厂)

工厂模式(简单工厂、工厂方法、抽象工厂)

工厂模式(简单工厂、工厂方法、抽象工厂)简单工厂模式从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactory Method)模式,但不属于23种GOF设计模式之一。

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。

简单工厂模式的一般结构,如图所示:上门2个图片有对简单工厂模式的理解,来源《java与模式》使用场景工厂类负责创建的对象比较少。

客户端只知道传入工厂类的参数,对于如何创建对象并不关心。

l 工厂角色l 抽象产品角色l 具体产品角色其实角色这个词用的比较确切,能够让我们理解到,每个角色的不是单纯地指一个类,可能是一组类所构成了这个角色。

下面对三个角色进行描述:1. 工厂角色工厂角色负责产品的生产工作。

在简单工厂模式中,工厂类是一个具体的实现类,在系统设计中工厂类负责实际对象的创建工作。

工厂类(Factory)的特点是:它知道系统中都存在哪些能够创建对象的具体类(ConcreteProduct),也知道该如何将创建的对象,以某种能够屏蔽具体类实现细节的方式(AbstractProduct)提供给所需要的其他角色来使用该对象提供的数据和服务。

2.抽象产品角色抽象产品角色是具体的产品的抽象。

抽象就是将产品的共性抽取出来,可以直接暴露给客户端(需要使用具体产品的角色),对所有的客户端来说,从工厂中直接获取到的原始产品的外部形态都是相同的,没有任何的差别,包括数据和服务。

这也就是说,具体客户端应该“秘密”掌握着某一个或一些具体产品的详细资料(具体产品类型、数据和服务),然后根据具体客户端(任何一个需要使用某种具体产品的数据和服务的实现类)需要什么样的附加数据和服务,进行类类型转换后,通过借助于对应的具体产品对象来完成其职责。

抽象产品角色,在实际系统中可以定义为接口或者抽象类。

C#设计模式——简单工厂模式、工厂模式和抽象工厂模式

C#设计模式——简单工厂模式、工厂模式和抽象工厂模式

C#设计模式——简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式⼀:简单⼯⼚模式 1:描述:简单⼯⼚模式是由⼀个⼯⼚对象根据接收到的消息决定要创建哪⼀个类的对象事例。

2:优点:⼯⼚类中有相关逻辑判断,可以根据需要动态创建相关的对象事例,⽽客户端只需要告诉⼯⼚类创建什么对象事例,⽽不关⼼怎么创建,当需要引⼊新产品就不需要修改客户端的代码,只需要添加相应的产品类并修改⼯⼚类就可以,所以从产品的⾓度上简单⼯⼚模式是符合“开-闭”原则的。

3:缺点:很容易违反⾼内聚低耦合的原则,⼀旦添加新产品就不得不修改⼯⼚逻辑,当产品类型较多时,有可能造成⼯⼚逻辑⽐较复杂,不利于系统的扩展和维护,所以从⼯⼚的⾓度来说简单⼯⼚模式是不符合“开-闭”原则的。

4:例⼦:namespace SimpleFactoryDemo{class Program{static void Main(string[] args){ShapeFactory shapeFactory = new ShapeFactory();shapeFactory.getShape("circle").draw();shapeFactory.getShape("rectangle").draw();shapeFactory.getShape("square").draw();Console.ReadKey();}}public interface IShape{void draw();//默认公共⽅法}public class Circle : IShape{public void draw(){Console.WriteLine("画个圆");}}public class Rectangle : IShape{public void draw(){Console.WriteLine("画个长⽅形");}}public class Square : IShape{public void draw(){Console.WriteLine("画个正⽅形");}}public class ShapeFactory//形状⼯⼚{public IShape getShape(string type){if ("circle".Equals(type)){return new Circle();}else if ("rectangle".Equals(type)){return new Rectangle();}else if ("square".Equals(type)){return new Square();}else{return null;}}}}⼆:⼯⼚模式 1:描述:定义⼀个创建对象的⼯⼚接⼝,让⼦类决定实例化哪个类,将实际创建⼯作推迟到⼦类中。

C#设计模式之简单工厂模式

C#设计模式之简单工厂模式

C#设计模式之简单⼯⼚模式设计模式分类:创建型模式。

结构型模式。

⾏为模式。

23种设计模式,如何记。

⾯向对象的系统中有很多对象,创建型模式解决的问题就是如何创建对象,何时创建对象,它努⼒的让代码不要太多的关注对象的具体类型,不⽤关注对象的创建细节,⽽知需要了解对象的抽象类型,创建对象的⼯作由创建对象的⼯⼚来实现。

⾯向对象的系统中,对象如何组织,采⽤什么样的结构组织⽐较合理,这个是由结构型模式来处理的。

合理的使⽤结构型模式可以使系统具备更好的灵活性、扩展性和维护性。

⾏为模式规定了各个对象间的应该具备的职责。

严格来说,简单⼯⼚模式并不是23种标准模式之⼀,它是⼯⼚家族中最简单的模式,使⽤这个模式可以把对象的创建和对象的使⽤分离开,⼯⼚只负责对象的创建,客户端程序调⽤和使⽤对象,客户端程序⽆需创建对象。

这样对象的创建放在⼀起,⽅便维护和扩展。

现实中⽣产鞋⼦的⼯⼚负责⽣产鞋⼦,我们不需要知道⽣产的鞋⼦的具体类型。

如图所⽰:右上⾓是⼀个产品接⼝,我们可以使⽤接⼝或抽象类来定义⼀个产品对象。

Animal类中有⼀个⾏为吃,Animal类派⽣出两个⼦类:Dog、Penguin。

这两个类分别实现了吃的动作,这两个动物其实是简单⼯⼚中具体的产品,通过他们实现抽象的产品;这些动物该如何去创建呢,我们可以⽤动物⼯⼚AnimalFactory来创建具体的动物,AnimalFactory类中有⼀个GetAnimal的⽅法,在这个⽅法⾥我们可以根据传进去的参数来创建具体的产品,⼯⼚类和产品类是依赖的关系。

在客户端,它关联了抽象的产品类Animal和⼯⼚类AnimalFactory,对客户来说,他不需要了解具体的产品,只需要告诉⼯⼚,需要什么具体的动物,动物⼯⼚就会根据客户端的要求来创建某个动物,通过简单⼯⼚模式,使客户端程序与具体的产品之间减少耦合度。

⽰例:抽象动物类:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace 简单⼯⼚模式{/*动物抽象类* 抽象产品*/public abstract class Animal{public abstract void Eat();}}具体动物狗类:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace 简单⼯⼚模式{/*具体的产品类,实现抽象产品类*/public class Dog:Animal{// 实现抽象⽅法public override void Eat(){Console.WriteLine("狗在吃饭!");}}}具体动物企鹅类:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace 简单⼯⼚模式{/*具体产品类,实现抽象产品类*/public class Penguin :Animal{// 实现抽象⽅法public override void Eat(){Console.WriteLine("企鹅在吃饭!");}}}动物⼯⼚类:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace 简单⼯⼚模式{/*动物⼯⼚类:实现具体的动物*/public class AnimalFactory{/// <summary>/// 根据客户的选择创建动物对象/// </summary>/// <param name="witch">动物编号</param> /// <returns></returns>public Animal GetAnimal(int witch){Animal am = null;switch (witch){case 1:am = new Dog();break;case 2:am = new Penguin();break;}return am;}}}主程序调⽤测试using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace 简单⼯⼚模式{class Program{static void Main(string[] args){// 得到具体的动物 (⾥⽒替换原则)Animal am = new AnimalFactory().GetAnimal(1);// 调⽤Eat()⽅法am.Eat(); // 输出狗在吃饭Console.ReadKey();}}}测试结果:使⽤接⼝实现简单⼯⼚模式需求:使⽤⾯向对象的⽅式设计⼀个系统,描述使⽤卡车从事货运,使⽤公共汽车从事客运。

C++设计模式之一工厂模式(简单工厂、工厂和抽象工厂)

C++设计模式之一工厂模式(简单工厂、工厂和抽象工厂)

C++设计模式之⼀⼯⼚模式(简单⼯⼚、⼯⼚和抽象⼯⼚)今天开始这个系列之前,⼼⾥有些恐慌,毕竟园⼦⾥的⾼⼿关于设计模式的经典⽂章很多很多,特别是⼤侠、⽼师的⽂章更是堪称经典。

他们的⽂笔如⾏云流⽔,例⼦活泼⽣动,讲解深⼊浅出。

好在他们都是⽤C#描述,也没有提供必要的源码下载,所以我这⾥⽤C++实现。

⾸先我想声明的是我的⽂笔绝对不如他们的好,例⼦也没有他们的形象,不过我打算把C++的代码实现和类图提供给⼤家,就算作为⼀种补充吧。

开始设计模式⾃然⽽然到提到⼏个原则:I、开闭法则(OCP);II、⾥⽒代换法则(LSP);III、依赖倒置法则(DIP);IV、接⼝隔离法则(ISP);V、合成/聚合复⽤原则(CARP);VI、迪⽶特法则(LoD),这⼏个法则在⽼师的和中有⾮常详尽的阐述和深⼊浅出的举例分析。

有兴趣的朋友打开链接看⼀下就可以了。

补充说明:我这⾥所以代码都是⽤VS2005的C++编译器实现。

所以不能保证在其他IDE中能顺利编译,但是我想如果你使⽤其他编译器,也应该不会有太⼤问题,主要也应该是stdafx.h⽂件中包含的头⽂件问题。

⾥⾯出⾏的结构图都是⽤微软的Visio2003 绘制,⼤家下载后可以直接⽤Visio打开。

在以后所有的模式例⼦中都有客户程序,客户程序这个⾓⾊不是模式本⾝的内容,它是模式之外的部分,但是正是这个客户程序完成了对模式的使⽤,模式本⾝的结构是讲解的重点,但是客户程序如何使⽤模式也是理解模式的⼀个重要⽅⾯,因此在我后续的介绍中都有客户程序这个⾓⾊,并会说明究竟调⽤模式中的哪些⾓⾊完成对模式的使⽤。

简单⼯⼚模式⽣活例⼦吃饭是⼈的基本需求,如果⼈类不需要吃饭,可能我们就能活得清闲许多,也就不需要像现在⼀样没⽇没夜的⼯作,学习。

我们学习是为了找到更好的⼯作,好⼯作为了赚更多的钱,最终为了吃饱饭,吃好饭。

因此可以说吃饭是与⼈息息相关,下⾯就从吃饭的例⼦来引⼊⼯⼚模式的学习。

如果你想吃饭了,怎么办⾃⼰做吗?⾃⼰做就相当于程序中直接使⽤new。

工厂模式(C++实现)

工厂模式(C++实现)

⼯⼚模式(C++实现) 没事捣⿎了下相对⽽⾔⽐较简单的⼯⼚模式,然后写了个⼩Demo,记录下,等⼗年后看到也是种回忆哈....... ⼯⼚模式⼀般分为三种:简单⼯⼚模式、⼯⼚⽅法模式、抽象⼯⼚模式。

⼀、简单⼯⼚模式: 简单⼯⼚模式,⼯⼚类是创建产品的,它决定创建哪⼀种产品,就像领导决定采⽤那种技术⽅案样。

举个例⼦,现在有宝马车和奔驰车两种车需要⽣产,但是只有⼀个⼯⼚,且只能在同⼀时间⽣产⼀种车,这时就有⼯⼚决定⽣产那种车了。

例⼦虽然不是⼗分恰当,但是会其意即可。

我们直接看UML类图和代码吧。

看代码就⼀⽬了然了:#include <iostream>using namespace std;enum CarType{BENZ, BMW};class Car//车类{public:virtual void createdCar(void) = 0;};class BenzCar : public Car //奔驰车{public:BenzCar(){cout<<"Benz::Benz()"<<endl;}virtual void createdCar(void){cout<<"BenzCar::createdCar()"<<endl;}~BenzCar(){}};class BmwCar : public Car //宝马车{public:BmwCar(){cout<<"Bmw::Bmw()"<<endl;}virtual void createdCar(void){cout<<"BmwCar::createdCar()"<<endl;}};class CarFactory //车⼚{public:Car* createSpecificCar(CarType type){switch(type){case BENZ://⽣产奔驰车return (new BenzCar());break;case BMW://⽣⾠宝马车return (new BmwCar());break;default:return NULL;break;}}};int main(int argc, char** argv){CarFactory carfac;Car* specificCarA = carfac.createSpecificCar(BENZ);//看到⽹上众多⽰例在new后没有delete,感觉不是特别严谨Car* specificCarB = carfac.createSpecificCar(BMW);delete specificCarA; delete specificCarB;return0;}输出结果如下: 简单⼯⼚模式在每次增加新的车型时,需要修改⼯⼚类,这就违反了开放封闭原则:软件实体(类、模块、函数)可以扩展,但是不可修改。

C#设计模式——工厂模式

C#设计模式——工厂模式

C#设计模式——⼯⼚模式。

⼯⼚模式同样是项⽬中最常⽤的设计模式,⼯⼚模式中⼜分为简单⼯⼚,⼯⼚⽅法,抽象⼯⼚。

下⾯我们由简单的开始逐⼀介绍。

1.简单⼯⼚模式 简单⼯⼚⼜被称为静态⼯⼚,在设计模式中属于创建型模式。

主要解决的问题是封装了实例化的过程,通过传⼊参数来获不同实例。

下⾯我们举⼀个项⽬中可能会⽤到的例⼦。

假设我们程序的数据保存在⼏个不同的数据库中,有MySql,SQLServer和MongoDB。

数据库都有增删改查的操作,我们就声明⼀个接⼝定义这些操作。

1public interface IDatabase2 {3void Insert();4void Delete();5 } 然后我们让三个数据库类分别实现这个接⼝。

1public class SqlServer : IDatabase2 {3public void Delete()4 {5 Console.WriteLine("delete data from sqlserver");6 }78public void Insert()9 {10 Console.WriteLine("insert data to sqlserver");11 }12 }1314public class MySql : IDatabase15 {16public void Delete()17 {18 Console.WriteLine("delete data from mysql");19 }2021public void Insert()22 {23 Console.WriteLine("insert data to mysql");24 }25 }2627public class MongoDB : IDatabase28 {29public void Delete()30 {31 Console.WriteLine("delete data from mongoDb");32 }3334public void Insert()35 {36 Console.WriteLine("insert data to mongoDb");37 }38 } 之后我们再声明⼀个⼯⼚类,这个类中的静态⽅法可以根据传⼊不同的参数来创建不同的实例。

c++设计模式:简单工厂模式(SimpleFactoryPattern)

c++设计模式:简单工厂模式(SimpleFactoryPattern)

c++设计模式:简单⼯⼚模式(SimpleFactoryPattern)定义:从设计模式的类型上来说,简单⼯⼚模式是属于创建型模式,⼜叫做静态⼯⼚⽅法(StaticFactory Method)模式,但不属于23种GOF设计模式之⼀。

简单⼯⼚模式是由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例。

简单⼯⼚模式是⼯⼚模式家族中最简单实⽤的模式,可以理解为是不同⼯⼚模式的⼀个特殊实现。

场景:我们要开⼀家⽐萨商店,定义了⼀个简单的披萨⼯⼚,可以根据客户的需要制作芝⼠披萨、辣肠⽐萨、蛤蜊披萨、素⾷披萨。

根据传⼊的披萨类型从披萨⼯⼚⽣产出客户所需要的披萨。

类图:c++代码如下:#include <iostream>#include <string>#include <vector>using namespace std;class PizzaType{public:enum EPizzaType{cheese,pepperoni,clam,veggie};};class Pizza{public:virtual ~Pizza() {};string getName();void prepare();void bake();void cut();void box();protected:string name;string dough;string sauce;vector<string> toppings;};class CheesePizza : public Pizza{public:CheesePizza();};class PepperoniPizza : public Pizza{public:PepperoniPizza();};class ClamPizza : public Pizza{public:ClamPizza();};class VeggiePizza : public Pizza{public:VeggiePizza();};class SimplePizzaFactory{public:Pizza* createPizza(PizzaType::EPizzaType type);};class PizzaStore{private:SimplePizzaFactory factory;public:Pizza* orderPizza(PizzaType::EPizzaType type);};string Pizza::getName(){return name;}void Pizza::prepare(){printf("Preparing %s\n",name.c_str());}void Pizza::bake(){printf("Baking %s\n",name.c_str());}void Pizza::cut(){printf("Cutting %s\n",name.c_str());}void Pizza::box(){printf("Boxing %s\n",name.c_str());}CheesePizza::CheesePizza(){name = "Cheese Pizza";dough = "Regular Crust";sauce = "Marinara Pizza Sauce";toppings.push_back("Fresh Mozzarella");toppings.push_back("Parmesan");}PepperoniPizza::PepperoniPizza(){name = "Pepperoni Pizza";dough = "Crust";sauce = "Marinara sauce";toppings.push_back("Sliced Pepperoni");toppings.push_back("Sliced Onion");toppings.push_back("Grated parmesan cheese");}ClamPizza::ClamPizza(){name = "Clam Pizza";dough = "Thin crust";sauce = "White garlic sauce";toppings.push_back("Clams");toppings.push_back("Grated parmesan cheese");}VeggiePizza::VeggiePizza(){name = "Veggie Pizza";dough = "Crust";sauce = "Marinara sauce";toppings.push_back("Shredded mozzarella");toppings.push_back("Grated parmesan");toppings.push_back("Diced onion");toppings.push_back("Sliced mushrooms");toppings.push_back("Sliced red pepper");toppings.push_back("Sliced black olives");}Pizza* SimplePizzaFactory::createPizza(PizzaType::EPizzaType type) {Pizza* pizza = NULL;if (PizzaType::cheese == type){pizza = new CheesePizza();}else if (PizzaType::pepperoni == type){pizza = new PepperoniPizza();}else if (PizzaType::clam == type){pizza = new ClamPizza();}else if (PizzaType::veggie == type){pizza = new VeggiePizza();}return pizza;}Pizza* PizzaStore::orderPizza(PizzaType::EPizzaType type){Pizza* pizza = NULL;pizza = factory.createPizza(type);pizza->prepare();pizza->bake();pizza->cut();pizza->box();return pizza;}int main(){PizzaStore pizzaStore;Pizza* pCheesePizza = pizzaStore.orderPizza(PizzaType::cheese);Pizza* pPepperoniPizza = pizzaStore.orderPizza(PizzaType::pepperoni); Pizza* pClamPizza = pizzaStore.orderPizza(PizzaType::clam);Pizza* pVeggiePizza = pizzaStore.orderPizza(PizzaType::veggie);delete pCheesePizza;delete pPepperoniPizza;delete pClamPizza;delete pVeggiePizza;return0;}运⾏后结果如下:Preparing Cheese PizzaBaking Cheese PizzaCutting Cheese PizzaBoxing Cheese PizzaPreparing Pepperoni PizzaBaking Pepperoni PizzaCutting Pepperoni PizzaBoxing Pepperoni PizzaPreparing Clam PizzaBaking Clam PizzaCutting Clam PizzaBoxing Clam PizzaPreparing Veggie PizzaBaking Veggie PizzaCutting Veggie PizzaBoxing Veggie Pizza参考图书:《Head First 设计模式》。

C#设计模式(1)——简单工厂模式

C#设计模式(1)——简单工厂模式

C#设计模式(1)——简单⼯⼚模式1.什么是简单⼯⼚ 现实中的⼯⼚负责⽣产产品,顾名思义,编程中的简单⼯⼚就是⼀个⽣产对象的类,它的主要作⽤是创建具体的产品类实例。

我们以⼀个⽣产⿏标为例来分析简单⼯⼚的作⽤,⿏标有两种:戴尔⿏标和惠普⿏标,代码如下://⿏标抽象类public abstract class Mouse{public abstract void Print();}//戴尔⿏标public class DellMouse : Mouse{public override void Print(){Console.WriteLine("⽣产了⼀个Dell⿏标!");}}//惠普⿏标public class HpMouse : Mouse{public override void Print(){Console.WriteLine("⽣产了⼀个惠普⿏标!");}}客户端代码:class Program{static void Main(string[] args){Mouse mouse1 = new DellMouse();Mouse mouse2 = new DellMouse();Mouse mouse3 = new DellMouse();Mouse mouse4 = new DellMouse();Mouse mouse5 = new DellMouse();mouse1.Print();}}程序运⾏如下: 我们可以看到程序运⾏没有问题,通过new⼀个DellMouse我们可以创建⼀个戴尔的⿏标,这时有⼀个问题,如果我们不想要戴尔⿏标了,要全部⽣产惠普⿏标怎么办呢?最简单直接的⽅法就是把new DellMouse全部替换成new HpMouse 。

如果我们的软件中new了100个DellMouse实例呢?⼀个⼀个地去替换会是⼀个巨⼤的⼯作量,同时通过new的⽅式来创建戴尔⿏标的实例,会让DellMouse类和客户端产⽣强耦合关系,这时候使⽤简单⼯⼚就可以帮助我们降低耦合,减少⼯作量了。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
2、基本思路 、
用户/客户不需要亲自去观测各 用户 客户不需要亲自去观测各 种水果的生长、收获和种植情况, 种水果的生长、收获和种植情况, 他只需要向农场主管部门打听就行 了,农场主管部门依据客户需要的 水果种类, 水果种类,发送水果情况单到农场 具体水果部门, 具体水果部门,由具体水果部门填 水果情况单, 水果情况单,最后信息由农场主管 部门返回到客户手中 。
一、简单工厂模式的概念与结 简单工厂模式的概念与结 构 二、简单工厂模式规范描述 简单工厂模式规范描述 简单工厂模式设计中用到 三、简单工厂模式设计中用到 的设计原则
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
1、问题的提出 、
某农场种植并向市场销售葡萄、 某农场种植并向市场销售葡萄、草莓和 苹果这三种水果, 苹果这三种水果,现客户要向该农场了解某 水果的生长、收获和种植情况, 水果的生长、收获和种植情况,当用户输入 某水果时即可查询相应该水果具体情况, 某水果时即可查询相应该水果具体情况,请 设计并实现该程序。。 设计并实现该程序。。
Void harvest () { Printf (“grape is harvesting ……\n”);}
Void plant () { Printf (“grape is planting ……\n”);}
………… }
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、GarderPlantFruit工厂方法代码分析 、GarderPlantFruit工厂方法代码分析
二、简单工厂模式规范描述 简单工厂模式规范描述
适用性 :
依据参数自动创建对象,是对象创建 依据参数自动创建对象, 的真正工厂。 的真正工厂。
二、简单工厂模式规范描述 简单工厂模式规范描述
结构 :
Factory Abstract Product +CreateProduct() +Operation()
二、简单工厂模式规范描述 简单工厂模式规范描述
实现 :
采用一个标识要被创建的对象种类的参数来创建多种产 品。 Class Creator { Public: Virtual Product * Create (ProductID);}
Product * Creator :: Create (ProductID) { If (ProductID=MINE) return new MyProduct; If (ProductID=YOURS) return newYourProduct; Return 0;}
Void plant () { Printf (“Strawberry is planting ……\n”);}
………… }
具体产品
Class grape: public Fruit { grape () {} Void grow () {
实现实体类(子类) 实现实体类(子类)
Printf (“grape is growing ……\n”);}
具体产品
{ Strawberry () {} Void grow () {
实现实体类(子类) 实现实体类(子类)
Class Strawberry: public Fruit
Printf (“Strawberry is growing ……\n”);}
Void harvest () { Printf (“Strawberry is harvesting ……\n”);}
+Operation()
+Operation()
+Operation()
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、简单工厂模式的概念与结构 、
基本结构
Factory 类实现 工厂角色 与应用程序无关,任何模式中创建的对象的工厂 与应用程序无关, 类必须实现这个接口。 类必须实现这个接口。 Class Factory { Public: Static AbstractProduct factory () {Return new ConcreteProduct (); }}
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、简单工厂模式的概念与结构 、
基本结构
Factory Abstract Product +CreateProduct() +Operation()
Concrete Product3
Concrete Product3
Concrete Product3
具体各角色UML关系图: 关系图: 具体各角色 关系图
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
3、GarderPlantFruit 工厂方法具体实现 、
编程完成。 由Visual c++ 6.0 编程完成。
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、GarderPlantFruit工厂方法代码分析 、GarderPlantFruit工厂方法代码分析
4、简单工厂模式的概念与结构 、简单工厂模式的概念与结构
系统仅有一个具体产品角色
二、简单工厂模式规范描述 简单工厂模式规范描述
模式名和分类 :
简单工厂模式
二、简单工厂模式规范描述 简单工厂模式规范描述
意图 :
定义一个创建对象的接口, 定义一个创建对象的接口,根据所提 供的参数决定创建出哪一个实体类的 一个实例。 一个实例。简单工厂模式封装了对象 创建的过程。 创建的过程。
实现实体类(子类) 实现实体类(子类)
Class Apple: public Fruit
Printf (“Apple is growing ……\n”);}
Void harvest () { Printf (“Apple is harvesting ……\n”);}
Void plant () { ………… } Printf (“Apple is planting ……\n”);}
抽象产品
Class Fruit { Public: Virtual void grow () =0; Virtual void harvest () =0; Virtual void plant () =0; }
抽象接口类(父类) 抽象接口类(父类)
具体产品
{ Apple () {} Void grow () {
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、简单工厂模式的概念与结构 、
基本结构
AbstractProduct 抽象角色 Class AbstractProduct { Public: };
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、简单工厂模式的概念与结构 、
基本结构
Concrete Product
+Operation()
二、简单工厂模式规范描述 简单工厂模式规范描述
参与者 :
AbstractProduct 定义简单工厂方法所创建 的对象的接口 ConcreteProduct 实现AbstractProduct接口 实现 接口 Factory 定义简单工厂方法, 定义简单工厂方法,返回一个 ConcreteProduct实例 实例
二、简单工厂模式规范描述 简单工厂模式规范பைடு நூலகம்述
别名 :
静态工厂
二、简单工厂模式规范描述 简单工厂模式规范描述
动机 :
为了提高内聚和松耦合, 为了提高内聚和松耦合,我们经常会抽 象出一些类的公共接口, 象出一些类的公共接口,以形成抽象基类或 接口, 接口,这样我们可以通过声明一个指向基类 的指针来指实实际的子类实现, 的指针来指实实际的子类实现,达到了多态 的目的,但这容易出现一个问题: 的目的,但这容易出现一个问题:大量的子 类继承抽象基类, 类继承抽象基类,我们不得不在每次要用到 子类的地方就编写诸如“ ×××; 子类的地方就编写诸如“new ×××;”的 代码,进而又带来两个问题: 代码,进而又带来两个问题:
二、简单工厂模式规范描述 简单工厂模式规范描述
协作 :
Creator依赖于它的子类定义的工厂方法, Creator依赖于它的子类定义的工厂方法, 依赖于它的子类定义的工厂方法 它返回一个适当的ConcreteProduct ConcreteProduct实例 它返回一个适当的ConcreteProduct实例
一、工厂方法模式的概念与结构
4、简单工厂模式的概念与结构 、
概念
定义一个创建对象的接口, 定义一个创建对象的接口,根据提供 给它的数据, 给它的数据 , 返回几个可能实体类中的 一个类的实例, 一个类的实例 , 由工厂类根据传入的参 量决定创建出哪一种产品类的实例, 量决定创建出哪一种产品类的实例 , 是 一个静态接口, 又叫静态工厂方法模式。 一个静态接口 , 又叫静态工厂方法模式 。
工厂 构造类接口
把和数据相关的问题与类的其它方法隔离
一、简单工厂模式的概念与结构 简单工厂模式的概念与结构
4、GarderPlantFruit简单工厂代码分析 、GarderPlantFruit简单工厂代码分析
客户对工厂的使用 引用 调用 Int main ( int argc , char * argv[] ) { FruitGardener * frgd = new FruitGardener; frgaFruit * afruit = frga->factory (“Apple”); aFruitaFruit->grow (); aFruiaFrui->harvest (); aFruiaFrui-> plant (); }
二、简单工厂模式规范描述 简单工厂模式规范描述
相关文档
最新文档