抽象工厂简单实例

合集下载

简单工厂模式和抽象工厂模式的通俗理解

简单工厂模式和抽象工厂模式的通俗理解以造汽车为例来通俗的说一下：（写的不好或有错误的地方欢迎大家指正）汽车制造商要造汽车卖给客户，那应该如可来做？看下面：第一：汽车制造商要知道客户要什么样的汽车，即设计汽车；第二：设计完后，一切ok后，就可以制造汽车了；根据上面二步描述，我们用程序表达出来就是（假设现在要造一辆Buick）：a. 设计师和工程师去设计汽车；public class BuickCar //设计buick车{……public string Dec(){return "Buick";}}BuickCar buick = new BuickCar(); //造了辆buick结构就是上面的很好理解，我们继续：假设现在要造一辆Benze，那做法和上面一样设计汽车制造汽车。

即：public class BenzeCar //设计汽车{//……public string Dec(){return "Benze";}}BenzeCar benze= new BenzeCar(); // 制造一辆benze 汽车注：从上面的例子可以发现，制造商每次要一辆新车，都要重新设计一下（重复劳动）。

而制造商设计的每一种汽车，它们之间存在一些共同的特新（比如都是流线性什么的，本人不太懂汽车）。

既然有了这些共性，那么把问题高度抽象化来考虑就是，制造商不知道以后需要设计什么样的汽车，也不知道以后的汽车会有什么新的特性。

但是只要是汽车，都可能会有共同的特性。

那么就可以提高效率。

用程序表达出来就是：1. 建一个汽车的抽象类：public abstract class Car{// ……public abstract string Dec(); // 汽车的共性} 2.假设N年后，制造商要设计一款新车的话：public class XXXCar : Car //继承了原来汽车的一些共性{//……public override string Dec(){return " XXXCar " }; // 重写了汽车的一个特性} 3.ok新车的设计好了，我们又可以造车了；XXXCar xxx= new XXXCar()；现在的结构如下：===ok，以上所说的都是汽车制造过程中的第一步，及设计上的。

抽象工厂的应用实例——DbProviderFactory

抽象⼯⼚的应⽤实例——DbProviderFactory最近跟⼀些朋友讨论关于⼯⼚模式的⼀些东西，觉得很有必要写篇东西把抽象⼯⼚的应⽤⽅法写清楚。

GoF在抽象⼯⼚⼀章中没有花很多篇幅在如何应⽤抽象⼯⼚上。

所幸为我们提供了⼀个⾮常标准的抽象⼯⼚的例⼦，同时也是⾮常实⽤的⼀个接⼝——DbProviderFactory我希望借⼀个利⽤DbProviderFactory重构⽹站的例⼦来回答两个关于抽象⼯⼚的常见问题：1. 为什么要使⽤抽象⼯⼚2. 如何使⽤抽象⼯⼚⾸先我们来看看这个，这是我花1个⼩时写的⼀个很具有代表性的例⼦，⼀个数据库表，增删改查四个页⾯，查询页⾯⽤了控件我们可以不⽤管它，为了演⽰，增删改我没有使⽤FormView。

类似这样的⽹站随处可见，当然这并不是⼀个好的例⼦，没有异常处理，也没有任何封装，只是⼀个供⼤家理解的例⼦⽽已。

这是⼀个依赖于SqlSever Client的⽹站，我们⽆法把它部署在其它类型的数据库上。

现在让我们通过重构让它⽀持多种数据库。

使⽤抽象⼯⼚之前，⾸先要让代码符合OO的基本原则之⼀，。

所以我们把所有的命名空间System.Data.SqlClient全都换成mon，相应的类也换成以Db开头的接⼝。

然⽽不幸的是，当我们换完之后，会发现有语法错误：这些讨厌的new，我们没有办法创建⼀个接⼝的实例，所以new就没有办法不依赖具体的类。

这样，我们就不得不将原来的命名空间加回去了，⽽且也⽆法做到针对多种数据库编程。

到这⾥，你⼤概已经可以猜到解决⽅案跟⼯⼚有关了。

这就是我们使⽤⼯⼚的原因：构造函数不能多态。

接下来我们回到⽐较具体的问题，既然是⽤⼯⼚重构可以解决问题，如何做呢？当然是优先使⽤.net类库提供的抽象⼯⼚类：DbProviderFactory。

既然有了类，然后我们⾯临的具体问题就是：何时创建⼯⼚？保存⼯⼚的变量放在什么地⽅？让我们来考虑⼀下⼯⼚的在所⽤范围：这是⼀个很简单Web应⽤，我们只需要⼀个数据库，所以决定我们使⽤数据库类型的⼯⼚应该是全局的，在web应⽤程序启动时就创建。

c#工厂模式——简单工厂,抽象工厂实例

c#工厂模式——简单工厂，抽象工厂实例工程项目结构如图：新建一个web项目在default.aspx后台代码中加protected void Page_Load(object sender, EventArgs e){if (!this.IsPostBack){BindData();}}private void BindData(){//简单工厂实例DBSample sample = InterFaceFactory.CreateSample();DBSample sample2 = InterFaceFactory.CreateSample2();Response.Write(sample.GetValue() + " ");Response.Write(sample2.GetValue() + " ");//下面是用抽象工厂做的实例ComputerFactory comFactory = new ComputerFactory();ICPU PcCPU = comFactory.CreatePcCPU();Response.Write(PcCPU.GetValue() + " ");ICPU MacCPU = comFactory.CreateMacCPU();Response.Write(MacCPU.GetValue() + " ");IRAM MacRAM = comFactory.CreateMacRAM();Response.Write(MacRAM.GetValue() + " ");}在AbstractDue项目中：创建：ICPU.cs,代码public interface ICPU{string GetValue();}创建IRAM.cspublic interface IRAM{string GetValue();}创建DBSample.cspublic abstract class DBSample{public abstract string GetValue();}在DATA层项目中创建：MacCPU.cs，代码public class MacCPU : ICPU{public string GetValue(){return"MacCPU";}}创建MacRAM.cspublic class MacRAM : IRAM{public string GetValue(){return"MacRAM";}}创建PcCPU.cspublic class PcCPU : ICPU{public string GetValue(){return"PcCPU";}}创建PcRAM.cspublic class PcRAM : IRAM{public string GetValue(){return"PcRAM";}}创建DataSample.cspublic class DataSample : DBSample{//实现继承的抽象类方法，前面要加override声明public override string GetValue(){return"Abstract Value";}}添加一个Factory类库创建ComputerFactory.cspublic class ComputerFactory : ComputerInterface{public ICPU CreatePcCPU(){ICPU iCPU = new PcCPU();return iCPU;}public IRAM CreatePcRAM(){IRAM iRAM = new PcRAM();return iRAM;}public ICPU CreateMacCPU(){return new MacCPU();}public IRAM CreateMacRAM(){//这是用反射创建的实例string path = ConfigurationManager.AppSettings["Path"];string className = path + ".Computer.MacRAM";Assembly assembly = Assembly.Load(path);return (MacRAM)assembly.CreateInstance(className);}}创建ComputerInterface.cs//在接口中所有的方法都默认为public,所以不用再加public了interface ComputerInterface{ICPU CreatePcCPU();IRAM CreatePcRAM();ICPU CreateMacCPU();IRAM CreateMacRAM();}创建InterFaceFactory.cspublic sealed class InterFaceFactory{private static readonly string path = ConfigurationManager.AppSettings["Path"];public static DBSample CreateSample(){//这是用的反射来做的实例string className = path + ".DataSample";Assembly assembly = Assembly.Load(path);return (DBSample)assembly.CreateInstance(className); }public static DBSample CreateSample2(){//这是不用反射来做的实例DBSample sample = new DataSample();return sample;}}这是一个实现了简单的工厂模式的框架。

java抽象工厂模式举例

java抽象工厂模式举例抽象工厂模式是一种创建型设计模式，它提供一个接口用于创建相关对象家族，而无需明确指定它们的具体类。

下面是一个简单的Java抽象工厂模式的示例，假设我们有两个不同类型的工厂，每个工厂可以创建多种相关产品。

首先，定义两个产品家族的抽象接口：```java// 抽象产品Ainterface Window {void open();}// 具体产品A1class WindowsWindow implements Window {@Overridepublic void open() {System.out.println("Opening a Windows window");}}// 具体产品A2class MacWindow implements Window {@Overridepublic void open() {System.out.println("Opening a Mac window");}}// 抽象产品Binterface Button {void click();}// 具体产品B1class WindowsButton implements Button {@Overridepublic void click() {System.out.println("Clicking a Windows button");}}// 具体产品B2class MacButton implements Button {@Overridepublic void click() {System.out.println("Clicking a Mac button");}}```接下来，定义抽象工厂接口，用于创建产品家族：```java// 抽象工厂接口interface GUIFactory {Window createWindow();Button createButton();}```然后，创建两个具体工厂类，分别用于创建Windows和Mac产品家族的对象：```java// 具体工厂1（用于创建Windows产品家族）class WindowsFactory implements GUIFactory {@Overridepublic Window createWindow() {return new WindowsWindow();}@Overridepublic Button createButton() {return new WindowsButton();}}// 具体工厂2（用于创建Mac产品家族）class MacFactory implements GUIFactory {@Overridepublic Window createWindow() {return new MacWindow();}@Overridepublic Button createButton() {return new MacButton();}}```现在，您可以使用抽象工厂来创建不同产品家族的对象，而无需关心它们的具体实现：```javapublic class Main {public static void main(String[] args) {// 使用Windows工厂创建Windows产品家族的对象GUIFactory windowsFactory = new WindowsFactory();Window windowsWindow = windowsFactory.createWindow();Button windowsButton = windowsFactory.createButton();windowsWindow.open(); // 输出：Opening a Windows windowwindowsButton.click(); // 输出：Clicking a Windows button// 使用Mac工厂创建Mac产品家族的对象GUIFactory macFactory = new MacFactory();Window macWindow = macFactory.createWindow();Button macButton = macFactory.createButton();macWindow.open(); // 输出：Opening a Mac windowmacButton.click(); // 输出：Clicking a Mac button}}```抽象工厂模式允许您创建一整个产品家族，确保这些产品能够协同工作。

抽象工厂模式介绍

抽象工厂模式介绍抽象工厂模式是一种软件设计模式，它提供了一种创建一系列相互关联或依赖的对象的方法，而无需指定具体实现类。

该模式的核心思想是将对象的创建和使用分离，从而在系统设计中提供更高的灵活性和可扩展性。

抽象工厂模式基于工厂方法模式，它将工厂抽象化，允许客户端使用抽象工厂来创建一系列相关或依赖的对象，而不必关心具体的实现类。

通过使用抽象工厂模式，我们可以使系统更易于扩展和修改，满足不同的需求和变化。

抽象工厂模式的结构包括抽象工厂、具体工厂、抽象产品和具体产品。

抽象工厂定义了创建一系列相关或依赖对象的方法，具体工厂实现了这些方法。

抽象产品定义了一系列相关产品的接口，具体产品实现了这些接口。

通过抽象工厂和具体产品的组合，我们可以创建一系列具有关联性的对象。

抽象工厂模式的使用可以带来多种好处。

首先，它可以提供系统的灵活性。

由于抽象工厂将对象的创建和使用分离，我们可以很容易地替换具体的工厂实现，从而满足不同的需求和变化。

其次，它可以提供系统的可扩展性。

通过增加新的具体工厂和产品实现，我们可以方便地扩展系统的功能。

再次，它可以提供系统的可维护性。

由于抽象工厂模式将创建对象的代码集中于一个工厂类中，我们可以更容易地维护和修改代码。

最后，它可以提供系统的解耦性。

客户端只需要与抽象工厂和抽象产品进行交互，不需要了解具体产品的实现细节，从而降低了系统的耦合度。

抽象工厂模式的应用场景较为广泛。

一种常见的应用场景是在需要创建一系列相互依赖的对象的时候。

比如，在一个图形界面应用程序中，需要创建一系列按钮和文本框，它们都依赖于同一个主题。

通过使用抽象工厂模式，我们可以创建具有相同主题的按钮和文本框，保持它们的外观风格一致。

另一个应用场景是在需要创建一系列相关产品族的时候。

比如，在一个汽车制造系统中，需要生产不同品牌和型号的汽车，每个品牌和型号都由相应的零部件组成。

通过使用抽象工厂模式，我们可以为每个品牌和型号创建对应的汽车工厂和零部件工厂，从而保证汽车的组装作业能够顺利进行。

【设计模式-工厂模式】男男女女的抽象工厂模式

【设计模式-⼯⼚模式】男男⼥⼥的抽象⼯⼚模式背景虽然⼥娲已经成功将⼈类创造出来了，可是都是没有性别的，那么后续该如何繁衍呢。

为此，除了增加⼈种外，我们还需要增加所有⼈类都有的⼀个属性：性别。

由此：⼈种和性别相互组合⽣成6中不同的⼈类男⿊⼈、⼥⿊⼈、男⽩⼈、⼥⽩⼈、男黄⼈、⼥黄⼈原来的⼀个⼋卦炉也需要进⾏修改，变为专门⽣产男性的"男⼋卦炉" 和专门⽣产⼥性的 “⼥⼋卦炉”类图可以看到我们在原有的⼏个⼈种上，⼜重新继承并实现了两个类，分别⽤于表⽰不同⼈种的男⼥特别说明的是HumanFactory接⼝，在这个接⼝中定义了三个⽅法，分别⽤于⽣产不同的肤⾊的⼈种，也就是我们将肤⾊作为Y轴，性别作为X轴，通过X坐标和Y坐标唯⼀确定⼀个⽣产出来的对象。

代码⼈种接⼝public interface Human {//每个⼈种的⽪肤都是不同的颜⾊public void getColor();//每个⼈类都会发声public void talk();public void getSex();}⼈种接⼝即抽象产品，该产品的共同属性定义：肤⾊和语⾔，⽽性别则是不同产品下更深层的细分实现⼈种接⼝的黄种⼈public abstract class AbstractYellowHuman implements Human{@Overridepublic void getColor() {System.out.println("黄种⼈");}@Overridepublic void talk() {System.out.println("国语");}}继承了该接⼝的抽象黄种⼈类，每个抽象类都会实现产品的公共细节，⽽每个抽象类的都会有两个实现类，分别实现各⾃的不同的细节：性别黄种⼈⼥性public class YellowWoman extends AbstractYellowHuman{@Overridepublic void getSex() {System.out.println("YellowWoman");}}⼋卦炉/*** 产品类* 有N个产品组,在抽象⼯⼚类中就应该有N个创建⽅法;* 每个产品有M个产品扩展维度就应该有M个产品实现⼯⼚类,* 在每个实现⼯⼚中,实现不同的产品族的⽣产任务.* @author LiPeng01* @since 2020/8/8 7:31 下午*/public interface HumanFactory {public Human doYellowHuman();public Human doWhiteHuman();public Human doBlackHuman();}在接⼝中我们可以看到抽象的⼯⼚是可以⽣产出不同肤⾊的⼈种的。

浅谈简单工厂，工厂方法，抽象工厂的区别和使用

浅谈简单⼯⼚，⼯⼚⽅法，抽象⼯⼚的区别和使⽤⼯⼚模式是分为三种，分别是简单⼯⼚，⼯⼚⽅法，抽象⼯⼚。

其中⼯⼚⽅法和抽象⼯⼚是GoF23种设计模式中的⼀种，⽽简单⼯⼚则不是⼀种设计模式，更加可以理解的是⼀种编码时候预定俗称的⼀种习惯。

那么，就在接下来三点中分别去分析理解⼯⼚模式。

⼀简单⼯⼚：通过实例化⼀个⼯⼚类，来获取对应的产品实例。

我们不需要关注产品本⾝如何被创建的细节，只需要通过相应的⼯⼚就可以获得相应的实例。

简单⼯⼚包括三种⾓⾊：1.⼯⼚：简单⼯⼚模式的核⼼，它负责实现创建所有实例的内部逻辑。

⼯⼚类的创建产品类的⽅法可以被外界直接调⽤，创建所需的产品对象。

2.抽象产品：简单⼯⼚模式所创建的所有对象的⽗类，它负责描述所有实例所共有的公共接⼝。

3.具体产品：是简单⼯⼚模式的创建⽬标，所有创建的对象都是充当这个⾓⾊的某个具体类的实例。

⽐如以下例⼦：（类设计的UML图）1.Drinks作为产品的抽象类并且有抽象⽅法produce();（抽象产品）public abstract class Drinks { protected abstract void produce();}2.Sprite继承Drinks是要被具体⽣产出来的产品，他重写了produce（）⽅法。

（具体产品）public class Sprite extends Drinks {@Overrideprotected void produce() {System.out.println("drink sprite");}}3.Cola同样也继承了Drinks，是要被⽣产出来的具体产品。

（具体产品）public class Cola extends Drinks {@Overrideprotected void produce() {System.out.println("Drink Cola");}}4.DrinksFactory为简单⼯⼚，向外暴露produceDrink⽅法来获取产品的实例（⼯⼚）public class DrinksFactory {public Drinks produceDrink(Class className){try {return (Drinks) Class.forName(className.getName()).newInstance();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}return null;}}5.Client为应⽤层，Client端想要获取到Cola或者Sprite对象，只要通过DrinkFactory中的produceDrink⽅法传⼊相对应的对应的产品public class Client {public static void main(String[] args) {DrinksFactory factory = new DrinksFactory();Cola cola = (Cola) factory.produceDrink(Cola.class);cola.produce();}}简单⼯⼚的优点：1.不需要关⼼类的创建细节。

java抽象工厂模式简单实例

java抽象⼯⼚模式简单实例抽象⼯⼚模式：提供⼀个创建⼀系列的相关的或者依赖的对象的接⼝，⽆需指定它们的具体实现类，具体的时间分别在⼦类⼯⼚中产⽣。

类似于⼯⼚模式：隔离了具体类的⽣产实现，使得替换具体的⼯⼚实现类很容易。

包含有以下模块：1.抽象产品接⼝：定义产品的接⼝，公共的暴露⽅法。

便于实际的产品类实现。

2.具体的产品类:包含实际产品的类的逻辑处理：3.抽象⼯⼚接⼝：定义产⽣系列对象的接⼝4.具体的⼯⼚实现：实现抽象的接⼝⼯⼚，返回具体的产品类的实现。

下⾯是具体的代码⽰例：1.抽象的产品接⼝，定义了Car 和 IBreakFastpackage factory.simple;/*** 抽象产品⾓⾊交通⼯具接⼝** @author lilin**/public interface Car {/*** 上班函数*/void gotowork();}package factory.abstractfactory;/*** @author lilin**/public interface IBreakFast {/*** 吃早餐*/void eat();}2.定义具体的产品类的实现：package factory.simple;/*** 具体产品⾓⾊，⾃⾏车** @author lilin**/public class Bike implements Car {@Overridepublic void gotowork() {System.out.println("骑⾃⾏车去上班！");}}package factory.simple;/*** @author lilin**/public class Bus implements Car {@Overridepublic void gotowork() {System.out.println("坐公交车去上班！");}}/****/package factory.abstractfactory;/*** @author lilin**/public class Milk implements IBreakFast {@Overridepublic void eat() {System.out.println("喝⽜奶！");}}/****/package factory.abstractfactory;/*** @author lilin**/public class Orange implements IBreakFast {@Overridepublic void eat() {System.out.println("吃橘⼦!");}}3.定义好抽象的⼯⼚接⼝，⼀系列的获取实例的接⼝⽅法：/****/package factory.abstractfactory;import factory.simple.Car;/*** @author lilin**/public interface IAbstractFactory {/**** @return*/Car getCar();/****/IBreakFast getBreakFast();}4.定义具体的⼯⼚⽣产类，具体的产品实例返回。

设计模式Abstract_Factory_抽象工厂

Abstract Factory（抽象工厂）Abstract Factory（抽象工厂）属于创建型模式，工厂类模式抽象程度从低到高分为：简单工厂模式 -> 工厂模式 -> 抽象工厂模式。

意图：提供一个接口以创建一系列相关或相互依赖的对象，而无须指定它们具体的类。

举例子如果看不懂上面的意图介绍，没有关系，设计模式需要在日常工作里用起来，结合例子可以加深你的理解，下面我准备了三个例子，让你体会什么场景下会用到这种设计模式。

汽车工厂我们都知道汽车有很多零部件，随着工业革命带来的分工，很多零件都可以被轻松替换。

但实际生活中我们消费者不愿意这样，我们希望买来的宝马车所包含的零部件都是同一系列的，以保证最大的匹配度，从而带来更好的性能与舒适度。

所以消费者不愿意到轮胎工厂、方向盘工厂、车窗工厂去一个个采购，而是将需求提给了宝马工厂这家抽象工厂，由这家工厂负责组装。

那你是这家工厂的老板，已知汽车的组成部件是固定的，只是不同配件有不同的型号，分别来自不同的制造厂商，你需要推出几款不同组合的车型来满足不同价位的消费者，你会怎么设计？迷宫游戏你做一款迷宫游戏，已知元素有房间、门、墙，他们之间的组合关系是固定的，你通过一套算法生成随机迷宫，这套算法调用房间、门、墙的工厂生成对应的实例。

但随着新资料片的放出，你需要生成具有新功能的房间（可以回复体力）、新功能的门（需要魔法钥匙才能打开）、新功能的墙（可以被炸弹破坏），但修改已有的迷宫生成算法违背了开闭原则（需要在已有对象进行修改），如果你希望生成迷宫的算法完全不感知新材料的存在，你会怎么设计？事件联动假设我们做一个前端搭建引擎，现在希望做一套关联机制，以实现点击表格组件单元格，可以弹出一个模态框，内部展示一个折线图。

已知业务方存在定制表格组件、模态框组件、折线图组件的需求，但组件之间联动关系是确定的，你会怎么设计？意图解释在汽车工厂的例子中，我们已知车子的构成部件，为了组装成一辆车子，需要以一定方式拼装部件，而具体用什么部件是需要可拓展的。

抽象工厂模式的应用场景

抽象工厂模式的应用场景抽象工厂模式是一种常用的设计模式，其主要作用是抽象出一个工厂接口，然后具体的工厂实现基于该接口构建不同的产品。

这种设计模式在实际开发中有着广泛的应用，下面就来详细探讨其在不同场景下的使用情况。

一、Web应用中的抽象工厂模式在Web应用中，抽象工厂模式非常常见。

例如，一个在线咖啡厅网站，其需要实现不同种类的饮品，包括浓缩咖啡、卡布奇诺、拿铁等等。

此时，可以采用抽象工厂模式，将饮品的种类作为产品族，不同种类的饮品则是产品族中的不同产品。

这样，每个饮品可以由一个具体的工厂类来构建，而所有的工厂类都可以基于同一个抽象工厂接口来实现。

二、游戏开发中的抽象工厂模式在游戏开发中，抽象工厂模式同样可以起到重要作用。

例如，一个游戏中需要不同种类的武器和防具，可以将武器和防具视为不同的产品族，每个具体的武器或防具则是产品族中的不同产品。

此时，可以采用抽象工厂模式来构建不同的工厂类，每个工厂类负责创建不同种类的武器或防具。

这样，通过简单的修改工厂类，就可以很容易地扩展游戏的武器和防具系统。

三、操作系统开发中的抽象工厂模式在操作系统开发中，抽象工厂模式也有着广泛的应用。

例如，操作系统中包含多个不同种类的进程调度算法，每个算法都是进程调度算法族中的不同产品。

此时，可以采用抽象工厂模式，将进程调度算法族作为产品族，每个具体的进程调度算法则是产品族中的不同产品。

通过简单的切换不同的工厂类，就可以实现不同的进程调度算法。

总结：抽象工厂模式是一种常用的设计模式，在实际开发中有着广泛的应用。

通过将对象的构造与产品族进行分离，我们可以很容易地扩展系统的功能，同时还可以提高代码的可维护性和可扩展性。

无论是Web应用、游戏开发、还是操作系统开发，抽象工厂模式都可以为我们提供很好的解决方案。

设计模式之-抽象工厂模式（实例）

设计模式之-抽象⼯⼚模式（实例）跟简单⼯⼚模式不⼀样的是，⽗类会先声明⼏个⼦类即将⽤到的抽象⽅法，和简单⼯⼚模式的区别差不多就是这⾥了，但是实际上还有什么不同的，我需要做更多的实践才能明⽩，先贴上⼀个⽐较贴近现实需求的实例using UnityEngine;using System.Collections;/// <summary>/// 定义资源枚举类型/// </summary>public enum ResourceEnum{None,UIResource,AudioResouce,}/// <summary>/// 资源管理器基类,抽象产品/// </summary>public abstract class ResouceManager{public abstract void LoadConfig(string path);public abstract void LoadAsset(string name);public abstract void UnLoadResource(bool status);}/// <summary>/// UI资源管理器，抽象产品的具体产品/// </summary>public class UIResouceManager : ResouceManager{public override void LoadConfig(string path){Debug.Log("加载UI的配置⽂件");}public override void LoadAsset(string name){Debug.Log("加载UI⾥⾯的资源");}public override void UnLoadResource(bool status){Debug.Log("卸载加载的UI资源");}}/// <summary>/// Audio资源管理器，抽象产品的具体产品/// </summary>public class AudioResourceManager : ResouceManager{public override void LoadConfig(string path){Debug.Log("加载和⾳乐有关的配置⽂件");}public override void LoadAsset(string name){Debug.Log("加载⾳乐⽂件");}public override void UnLoadResource(bool status){Debug.Log("卸载加载的⾳乐⽂件");}}/// <summary>/// 简单资源⼯⼚类，负责创建UI，Audio等管理器的实例。

抽象工厂模式极其简单的例子

抽象⼯⼚模式极其简单的例⼦第⼆篇博客：以汽车为例：假设汽车有开车的⽅法，也有创建汽车的⽅法⼆话不说满⾜开闭原则定义抽象类和接⼝1.定义抽象的车 ---车⼦有⼀个Drive开车的⽅法namespace抽象⼯⼚模式{///<summary>///抽象产品抽象----车///</summary>interface ICar{void Drive();//开车的⽅法}}namespace抽象⼯⼚模式{///<summary>///抽象⼯⼚///</summary>interface ICreateFactory{ICar CreateCar();//创建车⼦--这⾥返回类型是抽象的ICar}}namespace抽象⼯⼚模式{///<summary>///具体Car 继承⾃抽象Car///</summary>public class BMW:ICar{///<summary>///开车的⽅法///</summary>public void Drive(){Console.Write("宝马车正在⾏驶\r\n");}}}namespace抽象⼯⼚模式{///<summary>///继承⾃抽象⼯⼚///</summary>class BMWFactory:ICreateFactory{///<summary>///在BMWFactory的⼯⼚⾥创建///</summary>///<returns></returns>public ICar CreateCar(){Console.Write("创建宝马车。

\r\n");return new BMW();}}}配置⽂件：<?xml version="1.0" encoding="utf-8" ?><configuration><appSettings><add key="FactoryInstance" value="抽象⼯⼚模式.BMWFactory"/></appSettings></configuration>客户端：namespace抽象⼯⼚模式{class Program{///<summary>/// ------------------抽象⼯⼚模式思路----------------/// 1.创建⼀个抽象⼯⼚和⼀个抽象产品()⼀个⼯⼚对应⼀个产品/// 2.建⽴具体⼯⼚和具体产品///客户端实现:/// 3.1定义抽象对象/// 3.2读取配置⽂件/// 3.3反射实例(实例是ICreateFactory的⼦类-转换为⽗类)/// 3.4反射实例(实例化对象后返回类型为具体产品对应的对象(Icar的⼦类)---在⼦类出现的地⽅⽗类⼀定能出现)/// 3.5调⽤其⽅法/// (新增加同种产品不需要修改源代码,直接创建相应的具体⼯⼚和具体产品)///</summary>///<param name="args"></param>static void Main(string[] args){ICar iCar;//抽象产品抽象的CarICreateFactory createFactory;//抽象⼯⼚try{string str = ConfigurationManager.AppSettings["FactoryInstance"];//读取配置⽂件//3.4反射实例(实例化对象后返回类型为具体产品对应的对象(Icar的⼦类)---(依赖倒转原则)在⼦类出现的地⽅⽗类⼀定能出现) createFactory = Assembly.Load("抽象⼯⼚模式").CreateInstance(str) as ICreateFactory;iCar = createFactory.CreateCar();//--创建好的对象赋值给⽗类Icar(如:BMW是ICar滴⼦类)----具体产品iCar.Drive();//开车的⽅法Console.ReadKey();}catch(Exception e){Console.Write("代码出错了\r\n"+e.ToString());Console.ReadKey();}}}}结果：创建宝马车。

抽象工厂的例子

抽象工厂的例子抽象工厂没有讲明白,这里填加一个比较完整的例子.我觉得明白了抽象工厂目标是通过一个抽象工厂的子类来建立一系列同一性质的产品这点,就理解该模式了.#include <iostream>#include <string>using namespace std;class General{public:virtual void Assault() = 0;};class GirlGeneral : public General{private:string m_strName;public:GirlGeneral(string strName):m_strName(strName){}void Assault(){cout << " 女将军 " << m_strName << "正在攻击！"<< endl;}};class ManGeneral : public General{private:string m_strName;public:ManGeneral(string strName):m_strName(strName){}void Assault(){cout << " 将军 " << m_strName << "正在攻击！"<< endl; }};class Army{public:virtual void war(){}};class GirlArmy : public Army{public:void war(){cout << "女军战斗" << endl;}};class ManArmy : public Army{public:void war(){cout << "男军战斗" << endl;}};//抽象工厂的基类class AbstractFactory{public:virtual General* CreateGeneral(){return NULL;} virtual Army* CreateArmy(){return NULL;} };//创建所有和女性有关的对象class GirlFactory : public AbstractFactory {public:GirlFactory(){}General *CreateGeneral(string strName){return new GirlGeneral(strName);}Army *CreateArmy(){return new GirlArmy();}};//创建所有和男性有关的对象class ManFactory : public AbstractFactory {public:General *CreateGeneral(string strName){return new ManGeneral(strName);}Army *CreateArmy(){return new ManArmy();}};int main(int argc, char* argv[]){GirlFactory gF;ManFactory mF;//抽象工厂强调的是建立一系列的产品//通过gF,我们就可以创建所有和女性有关的对象General* pGeneral = gF.CreateGeneral("女将军"); pGeneral->Assault();Army *pArmy = gF.CreateArmy();pArmy->war();//通过mF,我们就可以创建所有和女性有关的对象pGeneral = mF.CreateGeneral("男将军"); pGeneral->Assault();pArmy = mF.CreateArmy();pArmy->war();return 0;}。

三层结构实现抽象工厂示例

连接数据库‎需要配置W‎e b.confi‎g的Sql‎ serve‎r，WebDA‎L节点是需‎要生成抽象‎工厂的实例‎，本登陆用到‎了3层结构‎+反射抽象工‎厂，才疏学浅，请大家多多‎指教。

BLL类：using‎Syste‎m;using‎Syste‎m.Colle‎c tion‎s.Gener‎i c;using‎Syste‎m.Text;using‎Login‎d emo.IDAL;using‎Login‎d emo.Model‎;using‎Login‎d emo.DALFa‎c tory‎;names‎p ace Login‎d emo.BLL{publi‎c class‎Login‎{//利用反射生‎成实例priva‎t e stati‎c reado‎n ly ILogi‎n dengl‎u = Login‎d emo.DALFa‎c tory‎.DataA‎c cess‎.Creat‎e Logi‎n();//登陆publi‎c int dengl‎u la(Login‎i nfo log){retur‎n dengl‎u.Login‎i ng(log);}}}DALFa‎c tory‎类：using‎Syste‎m;using‎Syste‎m.Colle‎c tion‎s.Gener‎i c;using‎Syste‎m.Text;using‎Syste‎m.Confi‎g urat‎i on;using‎Syste‎m.Refle‎c tion‎;names‎p ace Login‎d emo.DALFa‎c tory‎{//此类用于实‎现抽象工厂‎模式去创建‎从配置文件‎指定的数据‎访问层的实‎例publi‎c seale‎d class‎DataA‎c cess‎{priva‎t e stati‎c reado‎n ly strin‎g path = Syste‎m.Confi‎g urat‎i on.Confi‎g urat‎i onMa‎n ager‎.AppSe‎t ting‎s["WebDA‎L"];//实现Creat‎e Logi‎n方法，用于创建L‎o gin类‎实例publi‎c stati‎c Login‎d emo.IDAL.ILogi‎n Creat‎e Logi‎n(){strin‎g class‎n ame = path + ".Login‎";retur‎n (Login‎d emo.IDAL.ILogi‎n)Assem‎b ly.Load(path).Creat‎e Inst‎a nce(class‎n ame);}}}IDAL类‎：using‎Syste‎m;using‎Syste‎m.Colle‎c tion‎s.Gener‎i c;using‎Syste‎m.Text;using‎Login‎d emo.Model‎;names‎p ace Login‎d emo.IDAL{/// <summa‎r y>/// 登陆用户接‎口/// </summa‎r y>publi‎c inter‎f ace ILogi‎n{/// <summa‎r y>/// 用户登陆/// </summa‎r y>/// <param‎name="Log">登陆的Lo‎ginin‎f o类型</param‎> /// <retur‎n s></retur‎n s>int Login‎i ng(Login‎i nfo Log);}}IDAL类‎：using‎Syste‎m;using‎Syste‎m.Colle‎c tion‎s.Gener‎i c;using‎Syste‎m.Text;names‎p ace Login‎d emo.Model‎{/// <summa‎r y>/// 用户实体/// </summa‎r y>publi‎c class‎Login‎i nfo{priva‎t e strin‎g _logi‎n User‎;priva‎t e strin‎g _logi‎n Pass‎;/// <summa‎r y>/// 获取或设置‎用户名/// </summa‎r y>publi‎c strin‎g Login‎U ser{set { _logi‎n User‎= value‎; }get { retur‎n _logi‎n User‎; }}/// <summa‎r y>/// 获取或设置‎用户密码/// </summa‎r y>publi‎c strin‎g Login‎P ass{set { _logi‎n Pass‎= value‎; }get { retur‎n _logi‎n Pass‎; }}}}SQLse‎r ver类‎库包括两个‎类文件：Login‎.cs:using‎Syste‎m;using‎Syste‎m.Colle‎c tion‎s.Gener‎i c;using‎Syste‎m.Text;using‎Login‎d emo.IDAL;using‎Login‎d emo.Model‎;using‎Syste‎m.Data.SqlCl‎i ent;using‎Syste‎m.Data;names‎p ace Login‎d emo.SQLse‎r ver{/// <summa‎r y>/// 登陆用户/// </summa‎r y>publi‎c class‎Login‎:ILogi‎n{priva‎t e const‎strin‎g SQL_S‎E LECT‎_USER‎= "SELEC‎T Login‎U ser,Login‎P assW‎o rd from Login‎U ser WHERE‎Login‎U ser=@Login‎U ser and Login‎P assW‎o rd=@Login‎P assW‎o rd";priva‎t e const‎strin‎g LOGIN‎_USER‎="@Login‎U ser";priva‎t e const‎strin‎g LOGIN‎_PASS‎= "@Login‎P assW‎o rd";/// <summa‎r y>/// 用户登陆/// </summa‎r y>/// <param‎name="Log">登陆的Lo‎ginin‎f o类型</param‎>/// <retur‎n s></retur‎n s>publi‎c int Login‎ing(Login‎info Log) //重写ILo‎gin的L‎o gini‎n g接口{SqlPa‎r amet‎e r[] login‎P aram‎e ter = GetLo‎g inPa‎r amet‎e rs();int login‎S tate‎;login‎P aram‎e ter[0].Value‎= Log.Login‎U ser;login‎P aram‎e ter[1].Value‎= Log.Login‎P ass;using‎(SqlDa‎t aRea‎d er sdr = SqlHe‎l per.Execu‎t eRea‎d er(SqlHe‎l per.Con, Comma‎n dTyp‎e.Text, SQL_S‎E LECT‎_USER‎, login‎P aram‎e ter)){if (sdr.Read()){login‎S tate‎= 1;}else{login‎S tate‎= 0;}sdr.Dispo‎s e();}retur‎n login‎S tate‎;}/// <summa‎r y>/// 获取SQL‎参数缓存/// </summa‎r y>/// <retur‎ns>参数数组</retur‎n s>priva‎t e stati‎c SqlPa‎r amet‎e r[] GetLo‎g inPa‎r amet‎e rs(){SqlPa‎r amet‎e r[] parms‎= SqlHe‎l per.GetCa‎c hedP‎a rame‎t ers(SQL_S‎E LECT‎_USER‎);if (parms‎== null){parms‎= new SqlPa‎r amet‎e r[]{new SqlPa‎r amet‎e r(LOGIN‎_USER‎,SqlDb‎T ype.VarCh‎a r,10),new SqlPa‎r amet‎e r(LOGIN‎_PASS‎,SqlDb‎T ype.VarCh‎a r,10)};SqlHe‎l per.Cache‎P aram‎e ters‎(SQL_S‎E LECT‎_USER‎, parms‎);}retur‎n parms‎;}}}SQLHe‎l per:using‎Syste‎m;using‎Syste‎m.Confi‎g urat‎i on;using‎Syste‎m.Data;using‎Syste‎m.Data.SqlCl‎i ent;using‎Syste‎m.Colle‎c tion‎s;names‎p ace Login‎d emo.SQLse‎r ver{/// <summa‎r y>/// SqlHe‎lper类‎是专门提供‎给广大用户‎用于高性能‎、可升级和最‎佳练习的s‎q l数据操‎作/// </summa‎r y>publi‎c abstr‎a ct class‎SqlHe‎l per{//数据库连接‎字符串publi‎c stati‎c reado‎n ly strin‎g Con = Syste‎m.Confi‎g urat‎i on.Confi‎g urat‎i onMa‎n ager‎.AppSe‎t ting‎s["SQLSe‎r ver"];// 用于缓存参‎数的HAS‎H表priva‎t e stati‎c Hasht‎a ble parmC‎a che = Hasht‎a ble.Synch‎r oniz‎e d(new Hasht‎a ble());/// <summa‎r y>/// 给定连接的‎数据库用假‎设参数执行‎一个sql‎命令（不返回数据‎集）/// </summa‎r y>/// <param‎name="conne‎c tion‎S trin‎g">一个有效的‎连接字符串‎</param‎>/// <param‎name="comma‎ndTyp‎e">命令类型(存储过程, 文本, 等等)</param‎>/// <param‎name="comma‎ndT ex‎t">存储过程名‎称或者sq‎l命令语句‎</param‎>/// <param‎name="comma‎ndPar‎a mete‎r s">执行命令所‎用参数的集‎合</param‎>/// <retur‎ns>执行命令所‎影响的行数‎</retur‎n s>publi‎c stati‎c int Execu‎t eNon‎Q uery‎(strin‎g conne‎c tion‎S trin‎g, Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s){SqlCo‎m mand‎cmd = new SqlCo‎m mand‎();using‎(SqlCo‎n nect‎i on conn = new SqlCo‎n nect‎i on(conne‎c tion‎S trin‎g)){Prepa‎r eCom‎m and(cmd, conn, null, cmdTy‎p e, cmdTe‎x t, comma‎n dPar‎a mete‎r s);int val = cmd.Execu‎t eNon‎Q uery‎();cmd.Param‎e ters‎.Clear‎();retur‎n val;}}/// <summa‎r y>/// 用现有的数‎据库连接执‎行一个sq‎l命令（不返回数据‎集）/// </summa‎r y>/// <param‎name="conn">一个现有的‎数据库连接‎</param‎>/// <param‎name="comma‎ndTyp‎e">命令类型(存储过程, 文本, 等等)</param‎>/// <param‎name="comma‎ndT ex‎t">存储过程名‎称或者sq‎l命令语句‎</param‎>/// <param‎name="comma‎ndPar‎a mete‎r s">执行命令所‎用参数的集‎合</param‎>/// <retur‎ns>执行命令所‎影响的行数‎</retur‎n s>publi‎c stati‎c int Execu‎t eNon‎Q uery‎(SqlCo‎n nect‎i on conne‎c tion‎,Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s){SqlCo‎m mand‎cmd = new SqlCo‎m mand‎();Prepa‎r eCom‎m and(cmd, conne‎c tion‎, null, cmdTy‎p e, cmdTe‎x t, comma‎n dPar‎a mete‎r s);int val = cmd.Execu‎t eNon‎Q uery‎();cmd.Param‎e ters‎.Clear‎();retur‎n val;}/// <summa‎r y>///使用现有的‎S QL事务‎执行一个s‎q l命令（不返回数据‎集）/// </summa‎r y>/// <remar‎k s>///举例:/// int resul‎t= Execu‎t eNon‎Q uery‎(connS‎t ring‎,Comma‎n dTyp‎e.Store‎d Proc‎e dure‎,"Publi‎s hOrd‎e rs", new SqlPa‎r amet‎e r("@prodi‎d", 24));/// </remar‎k s>/// <param‎name="trans‎">一个现有的‎事务</param‎>/// <param‎name="comma‎ndTyp‎e">命令类型(存储过程, 文本, 等等)</param‎>/// <param‎name="comma‎ndT ex‎t">存储过程名‎称或者sq‎l命令语句‎</param‎>/// <param‎name="comma‎ndPar‎a mete‎r s">执行命令所‎用参数的集‎合</param‎>/// <retur‎ns>执行命令所‎影响的行数‎</retur‎n s>publi‎c stati‎c int Execu‎t eNon‎Q uery‎(SqlTr‎a nsac‎t ion trans‎,Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s){SqlCo‎m mand‎cmd = new SqlCo‎m mand‎();Prepa‎r eCom‎m and(cmd, trans‎.Conne‎c tion‎, trans‎, cmdTy‎p e, cmdTe‎x t, comma‎n dPar‎a mete‎r s);int val = cmd.Execu‎t eNon‎Q uery‎();cmd.Param‎e ters‎.Clear‎();}/// <summa‎r y>/// 用执行的数‎据库连接执‎行一个返回‎数据集的s‎q l命令/// </summa‎r y>/// <remar‎k s>/// 举例:/// SqlDa‎t aRea‎d er r = Execu‎t eRea‎d er(connS‎t ring‎,Comma‎n dTyp‎e.Store‎d Proc‎e dure‎,"Publi‎s hOrd‎e rs", new SqlPa‎r amet‎e r("@prodi‎d", 24));/// </remar‎k s>/// <param‎name="conne‎c tion‎S trin‎g">一个有效的‎连接字符串‎</param‎>/// <param‎name="comma‎ndTyp‎e">命令类型(存储过程, 文本, 等等)</param‎>/// <param‎name="comma‎ndT ex‎t">存储过程名‎称或者sq‎l命令语句‎</param‎>/// <param‎name="comma‎ndPar‎a mete‎r s">执行命令所‎用参数的集‎合</param‎>/// <retur‎ns>包含结果的‎读取器</retur‎n s>publi‎c stati‎c SqlDa‎t aRea‎d er Execu‎t eRea‎d er(strin‎g conne‎c tion‎S trin‎g, Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s){//创建一个S‎q lCom‎m and对‎象SqlCo‎m mand‎cmd = new SqlCo‎m mand‎();//创建一个S‎q lCon‎n ecti‎o n对象SqlCo‎n nect‎i on conn = new SqlCo‎n nect‎i on(conne‎c tion‎S trin‎g);//在这里我们‎用一个tr‎y/catch‎结构执行s‎q l文本命‎令/存储过程，因为如果这‎个方法产生‎一个异常我‎们要关闭连‎接，因为没有读‎取器存在，//因此com‎m andB‎e havi‎o ur.Close‎C onne‎c tion‎就不会执行‎try{//调用Prepa‎r eCom‎m and 方法，对SqlCo‎m mand‎对象设置参‎数Prepa‎r eCom‎m and(cmd, conn, null, cmdTy‎p e, cmdTe‎x t, comma‎n dPar‎a mete‎r s);//调用SqlCo‎m mand‎的Execu‎t eRea‎d er 方法SqlDa‎t aRea‎d er reade‎r = cmd.Execu‎t eRea‎d er(Comma‎n dBeh‎a vior‎.Close‎C onne‎c tion‎);//清除参数cmd.Param‎e ters‎.Clear‎();retur‎n reade‎r;}catch‎{//关闭连接，抛出异常conn.Close‎();throw‎;}}/// <summa‎r y>/// 用指定的数‎据库连接字‎符串执行一‎个命令并返‎回一个数据‎集的第一列‎/// </summa‎r y>/// <remar‎k s>///例如:/// Objec‎t obj = Execu‎t eSca‎l ar(connS‎t ring‎,Comma‎n dTyp‎e.Store‎d Proc‎e dure‎,"Publi‎s hOrd‎e rs", new SqlPa‎r amet‎e r("@prodi‎d", 24));///<param‎name="conne‎c tion‎S trin‎g">一个有效的‎连接字符串‎</param‎>/// <param‎name="comma‎ndTyp‎e">命令类型(存储过程, 文本, 等等)</param‎>/// <param‎name="comma‎ndT ex‎t">存储过程名‎称或者sq‎l命令语句‎</param‎>/// <param‎name="comma‎ndPar‎a mete‎r s">执行命令所‎用参数的集‎合</param‎>/// <retur‎ns>用Conve‎r t.To{Type}把类型转换‎为想要的</retur‎n s>publi‎c stati‎c objec‎t Execu‎t eSca‎l ar(strin‎g conne‎c tion‎S trin‎g, Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s){SqlCo‎m mand‎cmd = new SqlCo‎m mand‎();using‎(SqlCo‎n nect‎i on conne‎c tion‎= new SqlCo‎n nect‎i on(conne‎c tion‎S trin‎g)){Prepa‎r eCom‎m and(cmd, conne‎c tion‎, null, cmdTy‎p e, cmdTe‎x t, comma‎n dPar‎a mete‎r s);objec‎t val = cmd.Execu‎t eSca‎l ar();cmd.Param‎e ters‎.Clear‎();retur‎n val;}}/// <summa‎r y>/// 用指定的数‎据库连接执‎行一个命令‎并返回一个‎数据集的第‎一列/// </summa‎r y>/// <remar‎k s>/// 例如:/// Objec‎t obj = Execu‎t eSca‎l ar(connS‎t ring‎,Comma‎n dTyp‎e.Store‎d Proc‎e dure‎,"Publi‎s hOrd‎e rs", new SqlPa‎r amet‎e r("@prodi‎d", 24));/// </remar‎k s>/// <param‎name="conn">一个存在的‎数据库连接‎</param‎>/// <param‎name="comma‎ndTyp‎e">命令类型(存储过程, 文本, 等等)</param‎>/// <param‎name="comma‎ndT ex‎t">存储过程名‎称或者sq‎l命令语句‎</param‎>/// <param‎name="comma‎ndPar‎a mete‎r s">执行命令所‎用参数的集‎合</param‎>/// <retur‎ns>用Conve‎r t.To{Type}把类型转换‎为想要的</retur‎n s>publi‎c stati‎c objec‎t Execu‎t eSca‎l ar(SqlCo‎n nect‎i on conne‎c tion‎,Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s){SqlCo‎m mand‎cmd = new SqlCo‎m mand‎();Prepa‎r eCom‎m and(cmd, conne‎c tion‎, null, cmdTy‎p e, cmdTe‎x t, comma‎n dPar‎a mete‎r s);objec‎t val = cmd.Execu‎t eSca‎l ar();cmd.Param‎e ters‎.Clear‎();retur‎n val;}/// <summa‎r y>/// 将参数集合‎添加到缓存‎/// </summa‎r y>/// <param‎name="cache‎K ey">添加到缓存‎的变量</param‎>/// <param‎name="cmdPa‎r ms">一个将要添‎加到缓存的‎s ql参数‎集合</param‎>publi‎c stati‎c void Cache‎P aram‎e ters‎(strin‎g cache‎K ey, param‎s SqlPa‎r amet‎e r[] comma‎n dPar‎a mete‎r s) {parmC‎a che[cache‎K ey] = comma‎n dPar‎a mete‎r s;}/// 找回缓存参‎数集合/// </summa‎r y>/// <param‎name="cache‎K ey">用于找回参‎数的关键字‎</param‎>/// <retur‎ns>缓存的参数‎集合</retur‎n s>publi‎c stati‎c SqlPa‎r amet‎e r[] GetCa‎c hedP‎a rame‎t ers(strin‎g cache‎K ey){SqlPa‎r amet‎e r[] cache‎d Parm‎s = (SqlPa‎r amet‎e r[])parmC‎a che[cache‎K ey];if (cache‎d Parm‎s == null)retur‎n null;SqlPa‎r amet‎e r[] clone‎d Parm‎s = new SqlPa‎r amet‎e r[cache‎d Parm‎s.Lengt‎h];for (int i = 0, j = cache‎d Parm‎s.Lengt‎h; i < j; i++)clone‎d Parm‎s[i] = (SqlPa‎r amet‎e r)((IClon‎e able‎)cache‎d Parm‎s[i]).Clone‎();retur‎n clone‎d Parm‎s;}/// <summa‎r y>/// 准备执行一‎个命令/// </summa‎r y>/// <param‎name="cmd">sql命令‎</param‎>/// <param‎name="conn">Sql连接‎</param‎>/// <param‎name="trans‎">Sql事务‎</param‎>/// <param‎name="cmdTy‎p e">命令类型例‎如存储过程或‎者文本</param‎>/// <param‎name="cmdTe‎x t">命令文本,例如：Selec‎t * from Produ‎c ts</param‎>/// <param‎name="cmdPa‎r ms">执行命令的‎参数</param‎>priva‎t e stati‎c void Prepa‎r eCom‎m and(SqlCo‎m mand‎cmd, SqlCo‎n nect‎i on conn, SqlTr‎a nsac‎t ion trans‎,Comma‎n dTyp‎e cmdTy‎p e, strin‎g cmdTe‎x t, SqlPa‎r amet‎e r[] cmdPa‎r ms){if (conn.State‎!= Conne‎c tion‎S tate‎.Open)conn.Open();cmd.Conne‎c tion‎= conn;ma‎n dTex‎t = cmdTe‎x t;if (trans‎!= null)cmd.Trans‎a ctio‎n = trans‎;ma‎n dTyp‎e = cmdTy‎p e;if (cmdPa‎r ms != null){forea‎c h (SqlPa‎r amet‎e r parm in cmdPa‎r ms)cmd.Param‎e ters‎.Add(parm);}}}}在web.confi‎g文件中配‎置这个<appSe‎t ting‎s><add key="WebDA‎L" value‎="Login‎d emo.SQLse‎r ver"/><add key="SQLSe‎r ver" value‎="Serve‎r=.\SQL20‎05;DataB‎a se=Login‎d emo;user id=sa;passw‎o rd=123;"/></appSe‎t ting‎s>。

抽象工厂模式实例

抽象⼯⼚模式实例⽤户需求：⽤程序模拟以下产品线并代码实现设计思路：1.UML图2.采⽤抽象⼯⼚模式，将具体产品从客户代码中分离，容易改变产品的系列，能将⼀个系列的产品族统⼀到⼀起创建。

具体代码实现：1.抽象⼯⼚模式实现类1using System;2using System.Collections.Generic;3using System.Linq;4using System.Web;56namespace设计模式作业7 {8public class MyClass9 {10public interface Burger {11string getBurger();12 }13public class KFCBurger :Burger{14public string getBurger() {1516return"我是KFC的巨⽆霸汉堡";1718 }19 }20public class MCBurger : Burger {21public string getBurger()22 {2324return"我是McDonalds的巨⽆霸汉堡";25 }26 }27public interface Chicken {28string getChicken();29 }30public class KFCChicken : Chicken {31public string getChicken()32 {3334return"我是来⾃KFC的炸鸡";3536 }37 }38public class MCChicken : Chicken {39public string getChicken()40 {4142return"我是来⾃McDonalds的炸鸡"; 4344 }45 }46public interface Drink {47string getDrink();48 }49public class KFCDrink : Drink {50public string getDrink()51 {5253return"我是来⾃KFC的咖啡";5455 }56 }57public class MCDrink : Drink {58public string getDrink()59 {60return"我是来⾃McDonalds的橙汁"; 6162 }63 }64public interface AbstractFactory {65 Burger createBurger();66 Chicken createChicken();67 Drink createDrink();68 }69public class KFCFactory : AbstractFactory { 70public Burger createBurger() {71return new KFCBurger();72 }73public Chicken createChicken() {74return new KFCChicken();75 }76public Drink createDrink() {77return new KFCDrink();78 }7980 }81public class MCFactory : AbstractFactory 82 {83public Burger createBurger()84 {85return new MCBurger();86 }87public Chicken createChicken()88 {89return new MCChicken();90 }91public Drink createDrink()92 {93return new MCDrink();94 }9596 }979899 }100 }2.KFC⽣产线实现1using System;2using System.Collections.Generic;3using System.Linq;4using System.Web;5using System.Web.UI;6using System.Web.UI.WebControls;78namespace设计模式作业9 {10public partial class WebForm1 : System.Web.UI.Page11 {1213 MyClass.AbstractFactory af = new MyClass.KFCFactory(); 1415protected void Page_Load(object sender, EventArgs e)16 {1718 }1920protected void Button1_Click(object sender, EventArgs e)21 {22 MyClass.Burger kfcburger = af.createBurger();23 Label1.Text = kfcburger.getBurger();242526 }2728protected void Button2_Click(object sender, EventArgs e)29 {30 MyClass.Chicken kfcckicken = af.createChicken();31 Label1.Text = kfcckicken.getChicken();3233 }3435protected void Button3_Click(object sender, EventArgs e)36 {37 MyClass.Drink kfcdrink = af.createDrink();38 Label1.Text = kfcdrink.getDrink();39 }40 }41 }3.McDonalds⽣产线实现1using System;2using System.Collections.Generic;3using System.Linq;4using System.Web;5using System.Web.UI;6using System.Web.UI.WebControls;78namespace设计模式作业9 {10public partial class WebForm2 : System.Web.UI.Page11 {12 MyClass.AbstractFactory af = new MyClass.MCFactory(); 13protected void Page_Load(object sender, EventArgs e)14 {1516 }1718protected void Button1_Click(object sender, EventArgs e)19 {20 MyClass.Burger mcburger = af.createBurger();21 Label1.Text = mcburger.getBurger();2223 }2425protected void Button2_Click(object sender, EventArgs e)26 {27 MyClass.Chicken mcchicken = af.createChicken();28 Label1.Text = mcchicken.getChicken();2930 }3132protected void Button3_Click(object sender, EventArgs e)33 {34 MyClass.Drink mcdrink = af.createDrink();35 Label1.Text = mcdrink.getDrink();3637 }38 }39 }运⾏结果：点击KFC按钮创建KFC的汉堡类创建KFC的鸡⾁类创建KFC的饮品类点击McDonalds按钮创建McDonalds的汉堡类创建McDonalds的鸡⾁类创建McDonalds的饮品类体会和感悟：抽象⼯⼚模式是所有形态的⼯⼚模式中最为抽象和最具⼀般性的⼀种形态。

抽象工厂简单实例

食肉的动物吃食草动物。

美洲狼属于食肉动物，野牛属于食草动物，美洲狼吃野牛。

非洲的狮子属于食肉动物，角马属于食草动物，狮子吃角马。

类图如下：代码：using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace AnimalWorld{// 抽象大陆工厂abstract class ContinentFactory{abstract public Herbivore CreateHerbivore(); //抽象创建食草动物的类，返回食草类动物abstract public Carnivore CreateCarnivore(); //抽象创建食肉动物的类，返回食肉类动物}//非洲大陆,有角马，狮子class AfricaFactory : ContinentFactory //非洲动物工厂类{override public Herbivore CreateHerbivore() //实现上面的抽象方法，注意返回类型{return new Wildebeest(); //实例化一个角马，角马是食草动物}override public Carnivore CreateCarnivore() //实现上面的抽象方法，注意返回类型{return new Lion(); //实例化一个狮子，狮子是食肉动物}}// 美洲大陆,有狼,野牛class AmericaFactory : ContinentFactory //同上，美洲动物工厂类{override public Herbivore CreateHerbivore(){return new Bison(); //野牛}override public Carnivore CreateCarnivore(){return new Wolf(); //狼}}//食草动物"abstract class Herbivore //抽象食草类{}//肉食动物"abstract class Carnivore //抽象食肉类{//猎食食草动物的方法abstract public void Eat(Herbivore h); //抽象吃方法，传入食草动物为参数}//角马class Wildebeest : Herbivore //继承食草{}//狮子"class Lion : Carnivore{//重载猎食食草动物的方法override public void Eat(Herbivore h) //重写吃方法{Console.WriteLine(this + " eats " + h); //this代表本身}}//野牛class Bison : Herbivore{}//狼class Wolf : Carnivore{//重载猎食食草动物的方法override public void Eat(Herbivore h){Console.WriteLine(this + " eats " + h);}}//动物世界类class AnimalWorld{private Herbivore herbivore; //变量，返回食草抽象类private Carnivore carnivore;// 创建两种动物分类public AnimalWorld(ContinentFactory factory){carnivore = factory.CreateCarnivore();herbivore = factory.CreateHerbivore();}//运行食物链public void RunFoodChain(){//肉食动物猎食食草动物carnivore.Eat(herbivore);}}/// <summary>/// 抽象工厂模式客户应用测试/// </summary>class GameApp{static void Main(string[] args){//创造并运行非洲动物世界ContinentFactory africa = new AfricaFactory();AnimalWorld world = new AnimalWorld(africa);world.RunFoodChain();//创造并运行美洲动物世界ContinentFactory america = new AmericaFactory();world = new AnimalWorld(america);world.RunFoodChain();Console.Read();}}}实例二：（增加亚洲食肉虎，亚洲食草兔）代码红色为增加上去了！其它不变using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace AnimalWorld{// 抽象大陆工厂abstract class ContinentFactory{abstract public Herbivore CreateHerbivore(); //抽象创建食草动物的类，返回食草类动物abstract public Carnivore CreateCarnivore(); //抽象创建食肉动物的类，返回食肉类动物}//非洲大陆,有角马，狮子class AfricaFactory : ContinentFactory //非洲动物工厂类{override public Herbivore CreateHerbivore() //实现上面的抽象方法，注意返回类型{return new Wildebeest(); //实例化一个角马，角马是食草动物}override public Carnivore CreateCarnivore() //实现上面的抽象方法，注意返回类型{return new Lion(); //实例化一个狮子，狮子是食肉动物}}// 美洲大陆,有狼,野牛class AmericaFactory : ContinentFactory //同上，美洲动物工厂类{override public Herbivore CreateHerbivore(){return new Bison(); //野牛}override public Carnivore CreateCarnivore(){return new Wolf(); //狼}}//亚洲大陆，有虎，兔子class AsiaFactory : ContinentFactory{public override Herbivore CreateHerbivore(){return new rabbit();}public override Carnivore CreateCarnivore(){return new tiger();}}//食草动物"abstract class Herbivore //抽象食草类{}//肉食动物"abstract class Carnivore //抽象食肉类{//猎食食草动物的方法abstract public void Eat(Herbivore h); //抽象吃方法，传入食草动物为参数}//角马class Wildebeest : Herbivore //继承食草{}//狮子"class Lion : Carnivore{//重载猎食食草动物的方法override public void Eat(Herbivore h) //重写吃方法{Console.WriteLine(this + " eats " + h); //this代表本身}}//野牛class Bison : Herbivore{}//狼class Wolf : Carnivore{//重载猎食食草动物的方法override public void Eat(Herbivore h){Console.WriteLine(this + " eats " + h);}}//兔子类class rabbit:Herbivore{}//老虎class tiger : Carnivore{public override void Eat(Herbivore h){Console.WriteLine(this + "eats" + h);}}//动物世界类class AnimalWorld{private Herbivore herbivore; //变量，返回食草抽象类private Carnivore carnivore;// 创建两种动物分类public AnimalWorld(ContinentFactory factory){carnivore = factory.CreateCarnivore();herbivore = factory.CreateHerbivore();}//运行食物链public void RunFoodChain(){//肉食动物猎食食草动物carnivore.Eat(herbivore);}}/// <summary>/// 抽象工厂模式客户应用测试/// </summary>class GameApp{static void Main(string[] args){//创造并运行非洲动物世界ContinentFactory africa = new AfricaFactory();AnimalWorld world = new AnimalWorld(africa);world.RunFoodChain();//创造并运行美洲动物世界ContinentFactory america = new AmericaFactory();world = new AnimalWorld(america);world.RunFoodChain();//创建并运行亚洲动物世界ContinentFactory asia = new AsiaFactory();world = new AnimalWorld(asia);world.RunFoodChain();Console.Read();}}}**个人理解：抽象工厂的主要优点是隔离了具体类的生成，使得客户不需要知道什么被创建的。

抽象工厂模式

抽象⼯⼚模式1：实例某客户想要购买⼀辆车，他要联系4S店，⾸先得有4S店（抽象⼯⼚）的电话。

客户上⽹查询（建造⼯⼚），发现了宝马4S店（具体⼯⼚）的电话和奔驰4S店（具体⼯⼚）的电话。

客户拨通了宝马4S店的电话（获取具体⼯⼚），发现⽬前店⾥可以提供（⽣产）多款车型（具体产品）供客户选择（BMW 320、BMW 530，BMW 740）。

客户拨通了奔驰4S店的电话（获取具体⼯⼚），发现⽬前店⾥可以提供（⽣产）多款车型（具体产品）供客户选择（BenzC200、BenzE300）。

代码实现：1：车的最⾼级抽象package AbstractFactory;/*** 作⽤：最⾼级抽象产品，⽤于抽象⼯⼚的建造⽅法的返回值*/public abstract class Car {abstract void drive();}2：宝马车的抽象和实现package AbstractFactory;/*** 作⽤：宝马产品的产品类*/public abstract class BMWCar extends Car{}//宝马BMW320的具体实现class BMW320 extends BMWCar{@Overridevoid drive() {System.out.println("BMW320，⽼板专⽤。

");}}//宝马BMW530的具体实现class BMW530 extends BMWCar {public void drive(){System.out.println("BMW530，时不我待。

");}}3：奔驰车的抽象和实现package AbstractFactory;/*** 作⽤：奔驰汽车的产品类*/public abstract class BenzCar extends Car {}//奔驰C200的具体实现class BenzC200 extends BenzCar {public void drive(){System.out.println("BenzC200,实惠有⾯");}}//奔驰E300的具体实现class BenzE300 extends BenzCar {public void drive(){System.out.println("BenzE300,商务⽓派");}}4：抽象⼯⼚，宝马⼯⼚和奔驰车⼚来实现它package AbstractFactory;/*** 作⽤：抽象⼯⼚类*/public abstract class AbstractFactory {public abstract Car getCar(String type) throws ClassNotFoundException,IllegalAccessException, InstantiationException;}//宝马⼯⼚，⽣产所有的宝马类型class BMWFactory extends AbstractFactory{@Overridepublic Car getCar(String type) throws ClassNotFoundException, IllegalAccessException, InstantiationException { Class<?> aClass = Class.forName(type);return (BMWCar) aClass.newInstance();}}//奔驰⼯⼚，⽣产所有的奔驰class BenzFactory extends AbstractFactory{@Overridepublic Car getCar(String type) throws ClassNotFoundException, IllegalAccessException, InstantiationException { Class<?> aClass = Class.forName(type);return (BenzCar) aClass.newInstance();}}5：超级⼯⼚，建造⼯⼚的⼯⼚package AbstractFactory;/*** 作⽤：超级⼯⼚类，建造⼯⼚的⼯⼚*/public class FactoryProducer {public static AbstractFactory getFactory(String type)throws IllegalAccessException, InstantiationException, ClassNotFoundException{Class cl = Class.forName(type);System.out.println("创建⼯⼚："+type);return (AbstractFactory)cl.newInstance();}}6：测试package AbstractFactory;/*** 作⽤：*/public class Demo {public static void main(String[] args) throws Exception{//超级⼯⼚去创建⽣产宝马的⼯⼚AbstractFactory bmwFactory = FactoryProducer.getFactory("AbstractFactory.BMWFactory");//宝马⼯⼚去⽣产具体的宝马类型bmwFactory.getCar("AbstractFactory.BMW320").drive();//超级⼯⼚去创建⽣产宝马的⼯⼚AbstractFactory benzFactory = FactoryProducer.getFactory("AbstractFactory.BenzFactory");//宝马⼯⼚去⽣产具体的宝马类型benzFactory.getCar("AbstractFactory.BenzC200").drive();}}。

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

食肉的动物吃食草动物。

美洲狼属于食肉动物，野牛属于食草动物，美洲狼吃野牛。

非洲的狮子属于食肉动物，角马属于食草动物，狮子吃角马。