beniao.blog.51cto./389148/102304
.cnblogs./jingyun/archive/2010/04/16/1713341.html
实现步骤过程
1、创建Model，实现业务实体。
2、创建IDAL，实现接口。
3、创建SQLServerDAL，实现接口里的方法。
4、增加web.config里的配置信息，为SQLServerDAL的程序集。
5、创建DALFactory，返回程序集的指定类的实例。
6、创建BLL，调用DALFactory，得到程序集指定类的实例，完成数据操作方法。
7、创建WEB，调用BLL里的数据操作方法。
注意：
1、web.config里的程序集名称必须与SQLServerDAL里的输出程序集名称一致。
2、DALFactory里只需要一个DataAccess类，可以完成创建所有的程序集实例。
3、项目创建后，注意修改各项目的默认命名空间和程序集名称。
4、注意修改解决方案里的项目依赖。
5、注意在解决方案里增加各项目引用。
三、各层间的访问过程
1、传入值，将值进行类型转换(为整型)。
2、创建BLL层的content.cs对象c，通过对象c访问BLL层的方法GetContentInfo(ID)调用BLL层。
3、BLL层方法GetContentInfo(ID)中取得数据访问层SQLServerDAL的实例,实例化IDAL层的接口对象dal，这个对象是由工厂层DALFactory创建的，然后返回IDAL层传入值所查找的容的方法dal.GetContentInfo(id)。
4、数据工厂通过web.config配置文件中给定的webdal字串访问SQLServerDAL层，返回一个完整的调用SQLServerDAL层的路径给BLL层
5、到此要调用SQLServerDAL层，SQLServerDAL层完成赋值Model层的对象值为空，给定一个参数，调用SQLServerDAL层的SqlHelper的ExecuteReader方法,读出每个字段的数据赋值给以定义为空的Model层的对象。
6、SqlHelper执行sql命令，返回一个指定连接的数据库记录集，在这里需要引用参数类型，提供为打开连接命令执行做好准备PrepareCommand。
7、返回Model层把查询得到的一行记录值赋值给SQLServerDAL层的引入的Model层的对象ci，然后把这个对象返回给BLL。
8、回到Web层的BLL层的方法调用,把得到的对象值赋值给Lable标签，在前台显示给界面
.NET设计模式(1): 简单工厂模式
简单工厂模式（Simple Factory Pattern）
介绍：简单工厂模式不能说是一个设计模式，说它是一种编程习惯可能更恰当些。因为它至少不是Gof23种设计模式之一。但它在实际的编程中经常被用到，而且思想也非常简单，可以说是工厂方法模式的一个引导，所以我想有必要把它作为第一个讲一下。
维护过程中由于某些原因需要修改一下这个类，则唯一的做法就是打开源代码，进行修改，修改所有与这个对象有关的操作。这对我们是非常不利的。
问题出来了：对象不能应对“具体实例化类型”的变化
解决思路：套用一下建忠老师的话，封装变化点，哪里变化，封装哪里。在这个例子中，要实例化的类变了，就将实例化这个操作封装起来，我们可以把"new"这个操作移交一个具体的类，由它去负责根据我们的条件创建具体类的实例，也就是下面要说的“简单工厂模式”。
定义：
专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口。简单工厂模式又称为静态工厂方法（Static Factory Method）模式，属于类的创建型模式，通常根据一个条件（参数）来返回不同的类的实例。
意图：
提供一个类，由它负责根据一定的条件创建某一具体类的实例
参与者：
?工厂角色（Creator）
是简单工厂模式的核心，它负责实现创建所有具体产品类的实例。工厂类可以被外
界直接调用，创建所需的产品对象。
?抽象产品角色（Product）
是所有具体产品角色的父类，它负责描述所有实例所共有的公共接口。
?具体产品角色（Concrete Product）
继承自抽象产品角色，一般为多个，是简单工厂模式的创建目标。工厂类返回的都
是该角色的某一具体产品。
UML图：
现实生活中例子：
每次参加不同的聚会或者与不同的人见面，可能穿的衣服是不一样的，比如，你今天上午要与你的一个新客户见面，你可能会对你的老婆说：老婆，给拿件商务装（参数），我要去见我的一个客户，你老婆（工厂类）接到你的请求（商务装参数）后，从衣柜中取出一件商务装（具体产品），交给你。整个过程就完成了。
分析：
你可能根据不同的条件，要的衣服是不一样的，但要的衣服都是已经在你的衣柜中存在的。并且，每件上衣它们都属于同一种抽象，即它们可以从一个抽象类或接口中继承，这此衣服各自都有一定特征，这些都是条件。然后你要的时候，就可以向你老婆说一种特征，她就会根据这个特征为你服务了。这就是典型的简单工厂模式的应用。
抽象产品类代码
1///
2///抽象产品类:上衣
3///
4public interface ICoat
5{
6void GetYourCoat();
7}
非常简单，是吧？这里我只是举一个仅仅能说明问题的例子，在具体的项目中，可能是很复杂的哦。。
具体产品类代码
1namespace SimpleFactory
2{
3///
4///具体产品类：商务上衣
5///
6public class BusinessCoat:ICoat
7{
8public void GetYourCoat()
9{
10Console.WriteLine("商务上衣"); 11}
12}
13
14///
15///具体产品类：时尚上衣
16///
17public class FashionCoat:ICoat
18{
19///
20///实现ICoat中定义的方法
21///
22///
23public void GetYourCoat()
24{
25Console.WriteLine("时尚上衣");
26}
27}
28}
简单工厂模式中最核心的部分：工厂类
1namespace SimpleFactory
2{
3///
4///简单工厂模式中的核心部分:工厂类
5///
6public class Factory
7{
8public ICoat CreateCoat(string styleName) 9{
10switch(styleName.Trim().ToLower()) 11{
12case"business":
13return new BusinessCoat(); 14case"fashion":
15return new FashionCoat();
16default:
17throw new Exception("还没有你要的那种衣服"); 18}
19}
20}
21}
再看一下客户在调用的时候的代码
1///
2///客户类
3///
4class Client
5{
6static void Main(string[]args)
7{
8ICoat food;
9try
10{
11Factory factory=new Factory();
12
13Console.Write("我要的是时尚上衣\t");
14food=factory.CreateCoat("fashion");
15food.GetYourCoat();
16
17}
18catch(Exception ex)
19{
20Console.WriteLine(ex.Message);
21}
22}
23}
到这里，代码就完成了。
在客户端的代码中有我们就可以根据具体的参数，返回我们希望返回的对象，将"new"操作推迟到工厂类中实现。
这里，参数我直接写上了，我们其实可以将这个参数写到一个xml文件中，如app.config 文件中，动态的读出来，需要穿另外一种衣服了，只需要打开app.config文件，修改里面的值就行了，不需要项目重新编译。这样这个小程序就能够适应一定的变化了（在上传上去的代码中我会修改一下）。其实它也是设计模式正要解决的问题，在不修改代码的情况下，使项目能够适应一定的客户需求变化。注意，是一定的，并非全部。
优点：
?简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对象的尴尬局面中摆脱出来。
?外界与具体类隔离开来，偶合性低。
?明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：
?工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高聚的责任分配原则?虽然简单工厂模式能够适应一定的变化，但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的，如果需要添加新的类，则就需要改变工厂类了。（这个问题在下一个工厂方法模式将得到很好的解决）
应用情景
?工厂类负责创建的对象比较少
?客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心
参考资料
?《深入浅出设计模式(C#/Java版)》清华大学
?MSDN Webcast C#面向对象设计模式纵横谈建忠老师
工厂方法模式： 一个抽象产品类，可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类只能创建一个具体产品类的实例。 抽象工厂模式： 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。 区别： 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。 看了网络上很多关于设计模式的方法,有的模式看起来相似,但本质还是区别很大的.像简单工厂,工厂方法和抽象工厂就有很明显的区别. 有一个比较好理解的例子,在这跟大家介绍下: 1.如果一个后花园只种蔬菜类,那么就用简单工厂就可以了. 2.如果后花园蔬菜品种繁多.得用工厂方法才可以,把共有的东西抽象出来. 3.如果要扩大后花园的规模,比如一个在北方,一个在南方,这样工厂方法就无法实现了,就应当用抽象工厂,把各种各样的植物,又组成一个后花园. 所以我个人认为,简单工厂是一个工厂只生产一类的产品,面对的是具体的类,工厂方法是可以生产不同的产品,把公共的方法抽象出来,然后进行创建各种各样的产品.抽象工厂把几种产品划出共同的东西,把相互依赖的对象抽象出来,只要实现这些接口就可以得到不同的产品. 具体例子: 1.简单工厂: using System; public interface ICar { void run(); } public class BMWCar : ICar { public void run() { Console.WriteLine("BMWCar run"); } }
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据LSP原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。 当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。 每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。 下面是一个java抽象工厂的实现实例. 我们以交通工具(Vihicle),食品(Foot),武器(Weapon)为抽象产品类为例: 交通工具(Vihicle) public abstract class Vihicle { public abstract void run(); } 食品(Foot) public abstract class Foot { public abstract void printName(); } 武器(Weapon) public abstract class Weapon { public abstract void shoot(); } 这三种抽象产品类都有两种子类的实现: 交通工具(Vihicle)有实现类Car,Broom public class Car extends Vihicle{ public void run(){ System.out.println("冒着烟奔跑中的Car..."); } } public class Broom extends Vihicle{ public void run(){ System.out.println("一路沙尘暴飞奔而来.."); } } 食品(Foot)有实现类Mushroom,Apple
大连海事大学软件设计与体系结构 课程实验报告 （2016-2017学年第二学期） 实验四设计模式应用 班级：软件工程一班 学号：2220141524 姓名：孙正涛 指导教师：谢兄 成绩： 2016年1月2日
目录 1实验目的 (3) 2实验内容 (3) 3实验要求 (4) 4实验步骤 (4) 5总结与体会 (4) 5.1实验中出现的问题及其解决方案 (4) 5.2总结 (5) 5.3体会............................................................................................. 错误！未定义书签。
1实验目的 1.1利用Observer、单件等设计模式开发实现一个小的系统。 1.2通过常用的设计模式的实例实验，熟悉设计模式特点及应用条件，掌握基于设计模式的 软件系统的设计与开发应用。 2实验内容 2.1完成一个了一个可以绘图并进行移动的绘图程序 该程序分成分成8部分来写分别是：ShapeMgr.java MyCircle.java MyLine.java MyLocation.java MyRectangle.java MyShape.java IShape.java Painting.java 2.2ShapeMgr.java 这部分代码是负责几种管理图形的代码，将代码存在一个ArrayList 集合中，方便在移动的时候进行几种的管理 2.3MyCircle.java 这部分是关于绘制圆形的，里面有filloval()方法——这是用于绘图的方法，还有一个inside()方法，这是关于移动的函数，用于判断是否可以进行移动 2.4MyLine.java 与上一个类是一样的，用于绘制直线 2.5MyRectangle.java 与上一个类是一样的，用于绘制矩形 2.6MyLocation.java 这是一个负责进行初始地址管理的类，因为每次移动都需要变更地址，而图形的相对属性是不变的。就像是矩形开始点到终止点的距离，是不变的。确定了初始的地点，依据现有图形的一些属性，就可以重新绘制出移动后的另一个图形。每次只要是关于初始地点的X、Y都必须通过这个类来获取和改变，所以里面有get、set函数等。 这个类是图形移动的关键，所以设计的时候花费的时间比较多。 2.7MyShape.java 这个类继承了接口IShape接口，实现了它里面的方法，并且其他的类继承了这个类里面的方法，并进行一些改变。 这个类的作用主要是最坐标进行处理的，因为在移动的时候，只要是针对初始的X，Y 的值进行改变，然后在根据之前的一些属性进行重新绘制图形。 2.8IShape.java 这是一个父父接口，用于管理最常用的几个方法 MyLocation getMylocation(); void setMyLocation(MyLocation location); 这个方法是与MyShape类中的一个方法，用于获取之前的X，Y的地址，然后通过计算式进行改变地址的值，获取新的地址，然后在重新绘制出新的图形。 Int area();
抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。 每个模式都是针对一定问题的解决方案。抽象工厂模式面对的问题是多产品等级结构的系统设计。 在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。 产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如AMD的CPU和ADM芯片的主板，组成一个家族。Intel的CPU和Intel芯片的主板，又组成一个家族。而这两个家族都来自于两个产品等级：CPU，主板。一个等级结构是由相同的结构的产品组成，示意图如下： 理解这个产品结构是理解抽象工厂模式的关键所在，所以我不惜花费时间来画此图。如果领悟不到此图的含义，就无法区分工厂方法模式和抽象工厂模式的区别。 从上图可以看出，抽象工厂模式的每个工厂创造出来的都是一族产品，而不是一个或者一组。组是可以随意组合的！其实两个就这点点差别，呵呵，估计现在你已经差不多明白了抽象工厂模式的含义。不废话了，看个例子，真相将大白于天下！ 1.3.1 抽象工厂模式在农场中的实现 1.3.1.1 背景 聪明的农场主总是让自己的庄园越来越有价值，“农场”在经历了简单工厂模式和工厂模式后，不断的扩大生产。如今，再次面临新的大发展，一项重要的工作就是引进塑料大棚技术，在大棚里种植热带（Trop ical）和亚热带（Northern）的水果和蔬菜，用以满足市场需求，获取更大的利益。 1.3.1.2 产品角色图 经过分析，对产品角色进行分析得出下图
1.3.1.3 系统设计 经过分析，所谓的各个园丁其实就是工厂角色，而蔬菜和水果则是产品角色。将抽象工厂模式用于农场中，系统设计图如下： 1.3.1.4 实现源码
实验一、教务系统 1. 实验目的： ①学习工厂模式； ②掌握简单工厂模式的用法，以及其优缺点； ③掌握抽象工厂模式的用法，以及其优缺点。 2. 实验内容： 1.假设我们开发一个教务管理系统，现在教务处已经购买了Oracle数据库的2年使用权，且数据库 中有大量数据，不能短时间内进行数据库迁移。教务处提出一个要求，希望我们的系统现在可以支持Oracle，但在他们需要的时候，增加支持MySql、SQLServer的功能，请用简单工厂模式实现这一需求。（提示：具体代码可以数据读取写入工作抽象为一行命令行输出，但是核心的类关系必须给出。） 2.请用抽象工厂模式实现出以上需求。 3. 简单工厂 优点： 1、工厂方法包含从一个类的结构中选择初始类的业务逻辑。 2、客户类不直接创建产品类的对象。客户类只作为对象的消费者。 3、简单工厂方法模式实现了责任分离。 4、客户类不负有创建类的对象的责任，因此如果有新产品子类加入，不必修改已有的客户类代码。 缺点： 1、简单工厂方法模式不符合开闭原则。 2、简单工厂类只能是一个单独的类，而不能成为一个层次的类 4. 抽象工厂 优点： 1、具体产品从客户代码中被分离出来 2、容易改变产品的系列 3、将一个系列的产品族统一到一起创建 缺点： 在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口
5. 类图 6、实验总结 对于简单工厂和抽象工厂的学习有了初步的认识，在此学习中基本了解了什么情况下使用简单工厂和抽象工厂。 简单工厂： 1、工厂类负责创建的对象比较少； 2、客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心； 3、由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。 抽象工厂： 1、一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。 2、这个系统有多于一个的产品族，而系统只消费其中某一产品族。 3、同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。 4、系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。
工厂模式有以下几种形态: 简单工厂(Simple Factory)模式 工厂方法(Factory Method)模式,又称多形性工厂(Polymorphic Factory)模式 抽象工厂(Abstract Factory)模式,又称工具箱(Kit或Toolkit)模式 在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。 工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给子类去作。
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。 反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。 抽象工厂模式是所有形态的工厂模式中最为抽象和最具广泛性的一种形态，抽象工厂模式是工厂方法模式的进一步扩广化和抽象化。如下图：
在抽象工厂模式中，抽象产品(AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。 总结：简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。 工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
实验一单例模式的应用 1 实验目的 1) 掌握单例模式（Singleton）的特点 2) 分析具体问题，使用单例模式进行设计。 2 实验内容和要求 很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用C#控制台应用程序实现该单例模式。绘制该模式的UML 图。 3 实验代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AppConfig { publicclass Singleton { privatestatic Singleton instance; private Singleton() {
} publicstatic Singleton GetInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } class Program { staticvoid Main(string[] args) { Singleton singletonOne = Singleton.GetInstance(); Singleton singletonTwo = Singleton.GetInstance(); if (singletonOne.Equals(singletonTwo)) { Console.WriteLine("singletonOne 和 singletonTwo 代表的是同一个实例"); } else { Console.WriteLine("singletonOne 和 singletonTwo 代表的是不同实例"); } Console.ReadKey(); } } } 4 实验结果
(4) 抽象工厂模式 电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。 interface CPU {
void discribe(); } interface RAM { void discribe(); } class PcCPU implements CPU { public void discribe() { System.out.println("PcCPU"); } } class MacCPU implements CPU { public void discribe() { System.out.println("MacCPU"); } } class PcRAM implements RAM { public void discribe() { System.out.println("PcRAM"); } } class MacRAM implements RAM { public void discribe() { System.out.println("MacRAM"); } } interface ComputerPartsFactory { CPU produceCPU(); RAM produceRAM();
} class PcFactory implements ComputerPartsFactory { public PcCPU produceCPU() { System.out.println("PcCPU produced!"); return new PcCPU(); } public PcRAM produceRAM() { System.out.println("PcRAM produced!"); return new PcRAM(); } } class MacFactory implements ComputerPartsFactory { public MacCPU produceCPU() { System.out.println("MacCPU produced!"); return new MacCPU(); } public MacRAM produceRAM() { System.out.println("MacRAM produced!"); return new MacRAM(); } } class ComputerPartsClient { public static void main(String a[]) { ComputerPartsFactory factory; CPU cpu; RAM ram; factory=(ComputerPartsFactory)XMLUtil.getBean();//Pc OR Mac cpu=factory.produceCPU(); cpu.discribe(); ram=factory.produceRAM(); ram.discribe(); } }
?概述 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。怎么应对这种变化？怎么绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程式和这种“多系列具体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。 意图 提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。 模型图 逻辑模型： 物理模型： 生活中的例子 抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口，而不必指定他们具体的类。这种模式能汽车制造厂所
使用的金属冲压设备中找到。这种冲压设备能制造汽车车身部件。同样的机械用于冲压不同的车型的右边车门、左边车门、右前挡泥板、左前挡泥板和引擎罩等等。通过使用转轮来改动冲压盘，这个机械产生的具体类能在三分钟内改动。 抽象工厂之新解 虚拟案例 中国企业需要一项简单的财务计算：每月月底，财务人员要计算员工的工资。 员工的工资= (基本工资+ 奖金- 个人所得税)。这是个放之四海皆准的运算法则。 为了简化系统，我们假设员工基本工资总是4000美金。 中国企业奖金和个人所得税的计算规则是: 奖金= 基本工资(4000) * 10% 个人所得税= (基本工资+ 奖金) * 40% 我们目前要为此构建一个软件系统（代号叫Softo），满足中国企业的需求。 案例分析 奖金(Bonus)、个人所得税(Tax)的计算是Softo系统的业务规则(Service)。 工资的计算(Calculator)则调用业务规则(Service)来计算员工的实际工资。 工资的计算作为业务规则的前端(或客户端Client)将提供给最终使用该系统的用户(财务人员)使用。
中南大学软件学院 软件体系结构 设计模式实验报告 学生姓名：宋昂 所在学院：软件学院 学生学号： 3901080115 学生班级：软件0801 指导老师：刘伟 完成日期： 2010-12-7
一、实验目的 熟练使用PowerDesigner和任意一种面向对象编程语言实现几种常见的设计模式，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式和适配器模式，理解每一种设计模式的模式动机，掌握模式结构，学习如何使用代码实现这些模式，并学会分析这些模式的使用效果。 二、实验内容 使用PowerDesigner和任意一种面向对象编程语言实现简单工厂模式、工厂方法模式、抽象工厂模式、单例模式和适配器模式，包括根据实例绘制模式结构图、编写模式实例实现代码，运行并测试模式实例代码。 (1) 简单工厂模式 使用简单工厂模式设计一个可以创建不同几何形状(Shape)的绘图工具类，如可创建圆形(Circle)、方形(Rectangle)和三角形(Triangle) 对象，每个几何图形都要有绘制draw()和擦除erase()两个方法，要求在绘制不支持的几何图形时，提示一个UnsupportedShapeException，绘制类图并编程实现。 (2) 简单工厂模式 使用简单工厂模式模拟女娲(Nvwa)造人(Person)，如果传入参数“M”，则返回一个Man 对象，如果传入参数“W”，则返回一个Woman对象，使用任意一种面向对象编程语言实现该场景。现需要增加一个新的Robot类，如果传入参数“R”，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 (3) 工厂方法模式 某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式，现使用工厂方法模式设计该系统。用代码实现日志记录器实例，如果在系统中增加一个中的日志记录方式——控制台日志记录(ConsoleLog)，绘制类图并修改代码，注意增加新日志记录方式过程中原有代码的变化。
下面就来看一个Demo ，从这个Demo 中看出抽象工厂的优点 先来展现一下具体的类图 上面的类图呢，说明的是有两个具体工厂，一个是Linux 控件的制造，还有一个是Windows 控件的制造， 然后，有两个产品族，一个是WindowsTextBox 和LinuxTextBox 组成的TextBox 产品族，还有一个就是WindowsButton 和LinuxButton 组成的Button 产品族。 下面就来写类了 先来看工厂类吧 namespace AbstractFactory { public abstract class AbstractFactory { //在抽象工厂中，应该包含所有产品创建的抽象方法
public abstract Button CreateButton(); public abstract TextBox CreateTextBox(); } } namespace AbstractFactory { public class WindowsFactory:AbstractFactory { public override Button CreateButton() { return new WindowsButton(); } public override TextBox CreateTextBox() { return new WindowsTextBox(); } } } namespace AbstractFactory { public class LinuxFactory:AbstractFactory { public override Button CreateButton() { return new LinuxButton(); } public override TextBox CreateTextBox() { return new LinuxTextBox(); }
工厂模式的三种类型： 1抽象工厂模式是所有形态的工厂模式中最为抽 象和最其一般性的。抽象工厂模式可以向客户端 提供一个接口，使得客户端在不必指定产品的具 体类型的情况下，能够创建多个产品族的产品对 象。 1.抽象工厂（Creator）角色 抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。 2.具体工厂（Concrete Creator）角色 具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。 3.抽象（Product）角色 抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。 4.具体产品（Concrete Product）角色 抽象模式所创建的具体实例对象 总结：抽象工厂中方法对应产品结构，具体工厂对应产品族。 2工厂方法模式同样属于类的创建型模式又被称 为多态工厂模式。工厂方法模式的意义是定义一个创建 产品对象的工厂接口，将实际创建工作推迟到子类当中。 核心工厂类不再负责产品的创建，这样核心类成为一个 抽象工厂角色，仅负责具体工厂子类必须实现的接口， 这样进一步抽象化的好处是使得工厂方法模式可以使系 统在不修改具体工厂角色的情况下引进新的产品。
1.抽象工厂（Creator）角色 工厂方法模式的核心，任何工厂类都必须实现这个接口。 2.具体工厂（Concrete Creator）角色 具体工厂类是抽象工厂的一个实现，负责实例化产品对象。 3.抽象（Product）角色 工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。 4.具体产品（Concrete Product）角色 工厂方法模式所创建的具体实例对象 工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方 法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具 体类上。 工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工 厂类都有共同的接口，或者有共同的抽象父类。 当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对 象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也 不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂 模式在添加新产品对象后不得不修改工厂方法，扩展性不好。 工厂方法模式退化后可以演变成简单工厂模式。 3简单工厂模式属于类的创建型模式,又叫做静态 工厂方法模式。通过专门定义一个类来负责创建 其他类的实例，被创建的实例通常都具有共同的 父类。 1.工厂（Creator）角色 简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。 2.抽象（Product）角色 简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。 3.具体产品（Concrete Product）角色
《软件体系结构》大作业（1） 学院：软件学院 课程名称：软件体系结构 专业班级： 学生姓名：学号： 学生姓名：学号： 指导教师： 完成时间：年月日 评分表 1、叙述各小组成员完成本题目的分工协作情况。 小组中的每个成员都先理解题目要求及涉及的设计模式，并一起完成代码编写。另外，组长负责文档制作。 2、评分表 序号姓名评分是否组长 1 2 作业正文需要包括以下内容： 1、作业题目内容的详细描述。 2、完成本题目所采用的软件设计模式名称及画出相应的类图，或者是所采用的 软件体系结构名称及画出相应的体系结构图。
3、画出完成本题目所设计程序的设计类图；如还有其他图，也一并画出。 4、完成本题目所设计的程序代码。 5、程序运行的典型界面截图
1、作业题目内容的详细描述。 【作业2.1-1】例2.3为使用工厂方法模式设计的汽车保险管理应用程序实例。现在需要 扩展例2.3的设计图，添加一个名为LuxuryCarInsurance的类，并且需要编写此类和其他需要添加的类的代码，详细要求参见光盘的相应作业部分。 【作业2.1-1】在例2.4中，设计并且实现了豪华（Super）和中等（Medium）别墅（House）与公寓（Condo）的查询。要求在该设计的基础上，增加一个新的类SemiDetacher（半独立式楼宇），并且编写代码，实现相应的查询功能，详细要求参见光盘的相应作业部分。 2、完成本题目所采用的软件设计模式名称及画出相应的类图，或者是所采用的软件体系结构名称及画出相应的体系结构图。 【作业2.1-1】采用的是工厂方法模式 【作业2.1-2】采用的是抽象方法模式
抽象工厂模式 概述 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具·体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。 意图 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类 模型图 逻辑模型： 物理模型： 生活中的例子 抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口，而不需要指定它们具体的类。这种模式可以汽车制造厂所使用的金属冲压设备中找到。这种冲压设备可以制造汽车车身部件。同样的机械用于冲压不同的车型的右边车门、左边车门、右前挡泥板、左前挡泥板和引擎罩等等。通过使用转轮来改变冲压盘，这个机械产生的具体类可以在三分钟内改变。 抽象工厂之新解 虚拟案例 中国企业需要一项简单的财务计算：每月月底，财务人员要计算员工的工资。 员工的工资 = (基本工资 + 奖金 - 个人所得税)。这是一个放之四海皆准的运算法则。
为了简化系统，我们假设员工基本工资总是4000美金。 中国企业奖金和个人所得税的计算规则是: 奖金 = 基本工资(4000) * 10% 个人所得税 = (基本工资 + 奖金) * 40% 我们现在要为此构建一个软件系统（代号叫Softo），满足中国企业的需求。 案例分析 奖金(Bonus)、个人所得税(Tax)的计算是Softo系统的业务规则(Service)。 工资的计算(Calculator)则调用业务规则(Service)来计算员工的实际工资。 工资的计算作为业务规则的前端(或者客户端Client)将提供给最终使用该系统的用户(财务人员)使用。 针对中国企业为系统建模 根据上面的分析，为Softo系统建模如下： 代码： 针对美国企业为系统建模 为了拓展国际市场，我们要把该系统移植给美国公司使用。 美国企业的工资计算同样是: 员工的工资 = 基本工资 + 奖金 - 个人所得税。 但是他们的奖金和个人所得税的计算规则不同于中国企业: 美国企业奖金和个人所得税的计算规则是:
题目：抽象工厂模式 学生姓名张婧 学号20XX21077 院系信息科学与技术学院专业计算机应用技术 年级20XX 级
抽象工厂模式 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？这就要用到抽象工厂模式。抽象工厂模式是简单工厂模式和工厂方法模式的升级版，它有更大的灵活性,同时也更加复杂一些。 为了理解抽象工厂,我们考虑这样一个实际例子:如果你想吃饭了，怎么办自己做吗？自己做就相当于程序中直接使用new。当然是自己下个指令，别人来做更爽。那就把做饭的任务交给厨师吧，那么他就是一个做饭的工厂了，你告诉他要吃红烧肉，等会他就从厨房给你端出来一盘香喷喷的红烧肉了，再来个清蒸鱼吧。下图 1 就是这个问题的模型。 图1 显然到了这里，你是Client，厨师就是工厂，他拥有做红烧肉的方法，做清蒸鱼的方法，这些方法返回值就是食物抽象。红烧肉、清蒸鱼就是食物的继承类，简单工厂模式也成型了。
简单工厂模式结构 图2 优点：允许客户端相对独立的创建产品的过程，并且在系统引入新产品的时候无需修改客户端。 缺点：对修改不封闭，新增加产品您要修改工厂。违法了开闭法则（OCP）。 工厂方法模式生活例子: 厨师手艺再好，总有不会做的菜，你想吃回锅肉，怎么办，让厨师学呗，于是就给他新增了做回锅肉的方法，以后你再想吃一个新菜，就要给厨师新加一个方法，显然此做法的缺点也就暴露出来了，用程序设计的描述就是对修改永远不能封闭。 面对上面对修改不能封闭的问题，有没有好的解决方案吗？把厨师抽象变成一个基类，你请几个具体的厨师，分别有做清蒸鱼的，做红烧肉的厨师，如果你想吃一个新菜，就再新找个厨师，从你的厨师基类继承一下，让他来做这个新菜。现在来看这个模式发生了变化，结构中多了一个厨师的抽象，抽象并不具体的加工产品了，至于做什么，是由这个抽象工厂的继承子类来实现，现在的模式也就变成工厂方法模式了，这个上面的结构图1就变成了下面的图3的结构了。
实验8 抽象工厂和建造者模式 一、实验目的 1、掌握抽象工厂模式的概念、模式结构、适用场景、优点和缺点。 3、掌握建造者模式的概念、模式结构、适用场景、优点和缺点。 二、实验环境 Windows操作系统，Rational Rose，eclipse、Myeclipse ，VS Studio，记事本等等。 三、实验内容 1、抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。 抽象工厂的模式图如下所示。模式中包含4个角色，抽象工厂、具体工厂、抽象产品和具体产品。
题目描述：我们在上一节讲了女娲造人的故事。人是造出来了，世界也热闹了，可是低头一看，都是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，记给人类定义性别了，那怎么办？ 由于女娲之前的准备工作花费了非常大的精力，比如准备黄土，准备八卦炉等，从头开始建立所有的事物也是不可能的，那就想在现有的条件下重新造人，尽可能旧物利用嘛。怎么才能让人类有爱有恨呢？是神仙当然办法的了，定义互斥的性别，然后在每个个体中埋下一颗种子：异性相吸，成熟后就一定会去找个异性（这就是我们说的爱情原动力）。从设计角度来看，一个具体的对象通过两个坐标就可以确定：肤色和性别。 产品类分析完毕了，生产的工厂类该（八卦炉）怎么改造呢？只有一个生产设备，要么生产出全都是男性，要么都是女性，那不行呀，这么大的翻天覆地的改造就是为了产生不同性别的人类。有办法了！把目前已经有的生产设备——八卦炉拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两个，并且略加修改，就成了女性八卦炉（只生产女性人种）和男性八卦炉（只生产男性人种），于是乎女娲就开始准备生产了。根据描述，请使用抽象工厂模式，画出UML类图，实现题目描述的功能。 UML类图:
简单工厂模式，工厂方法模式和抽象工厂模式的异同 简单工厂模式，工厂方法模式和抽象工厂模式都是属于创建型设计模式，这三种创建型模式都不需要知道具体类。我们掌握一种思想，就是在创建一个对象时，需要把容易发生变化的地方给封装起来，来控制变化（哪里变化，封装哪里），以适应客户的变动，项目的扩展。用这三种设计模式都可以实现，那究竟这三种设计模式有什么异同呢？下面根据这三者之间的特点，优点，缺点，适用范围进行比较。 一．特点 简单工厂模式：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有 共同的父类。它又称为静态工厂方法模式。它的实质是由一个工厂 类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类 继承自一个父类或接口）的实例。简单工厂模式的创建目标，所有 创建的对象都是充当这个角色的某个具体类的实例。在这个模式中， 工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据 外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使 用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象 是如何创建以及如何组织的。有利于整个软件体系结构的优化。 工厂方法模式：工厂方法是粒度很小的设计模式，因为模式的表现只是一个抽象的方法。 提前定义用于创建对象的接口，让子类决定实例化具体的某一个类，即 在工厂和产品中间增加接口，工厂不再负责产品的创建，由接口针对不 同条件返回具体的类实例，由具体类实例去实现。工厂方法模式是简单 工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开 －闭原则’，实现了可扩展。其次实现更复杂的层次结构，可以应用于 产品结果复杂的场合。工厂方法模式是对简单工厂模式进行了抽象。有 一个抽象的Factory类（可以是抽象类和接口），这个类将不在负责具 体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。 在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对 应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就 负责生产对应的产品。
我的空间主页|空间装扮博客|写新文章相册|上传照片好友|找新朋友档案|留言板我的应用loading.. 我的i贴吧i动态传送门我的动态jljHappyDay 1 | 我的消息(0/0) | 我的空间| 我的应用| 我的i贴吧| 百度空间| 百度首页| 退出踏浪帅的空间https://www.doczj.com/doc/9913658412.html, C# 资料收藏主页博客相册|个人档案|好友查看文章 NET设计模式(4): 抽象工厂模式（实例代码）2009-11-29 00:18实例： 大家知道，动物世界中各大陆的动物是不一样的，各种动物可以分成两样，一种食草，一种食肉。食肉的动物吃食草动物。美洲狼属于食肉动物，野牛属于食草动物，美洲狼吃野牛。非洲的狮子属于食肉动物，角马属于食草动物，狮子吃角马。类图如下： 代码： 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(); //实例化一个狮子，狮子是食肉动物 }
太原师范学院 实验报告 Experimentation Report of Taiyuan teachers College 系部计算机系年级课程设计模式实训教程 姓名学号日期2018.03.03 项目 Factory Method设计模式 一、实验目的 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。 框架使用抽象类定义和维护对象之间的关系。这些对象的创建通常也由框架负责。考虑这样一个应用框架，它可以向用户显示多个文档。在这个框架中，两个主要的抽象是类Application和Document。这两个类都是抽象的，客户必须通过它们的子类来做与具体应用相关的实现。 二、实验原理 试验要求包含典型的 Factory Method结构。 程序能够明确表达设计思想。 三、实验仪器及材料 操作系统： Windows，linux； 开发工具： VC； Java，C# 四、实验方法 设计一个Factory Method案例并实现，并撰写设计报告。
五、实验记录及数据处理 interface Log{ public void writeLog(); } //文件日志记录器：具体产品 class FileLog implements Log{ @Override public void writeLog() { System.out.println("文件日志记录。"); } } //数据库日志记录器：具体产品 class DatebaseLog implements Log{ @Override public void writeLog() { System.out.println("数据库日志记录。"); } } //日志记录器工厂接口：抽象工厂 interface LogFactory{ public Log createLog(); } //文件日志记录器工厂类：具体工厂 class FileLogFactory implements LogFactory{ @Override public Log createLog() { return new FileLog(); } } //数据库日志记录器工厂类：具体工厂 class DatabaseLogFactory implements LogFactory{ @Override public Log createLog() {
软件设计模式实验报告 篇一：软件设计模式实验报告 计算机科学与技术学院实验报告 课程名称：专业：班级：学号：姓名： 实验一单例模式的应用 1 实验目的 1) 掌握单例模式（Singleton）的特点 2) 分析具体问题，使用单例模式进行设计。 2 实验内容和要求 很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new 一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行
中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用C#控制台应用程序实现该单例模式。绘制该模式的UML图。 UML图： 源代码： class Program { static void Main { AppConfig appConfigOne = ; AppConfig appConfigTwo = ; if ) { ; } else {
; } ; } } } 运行结果： 实验小结： 通过这次实验，我了解了单例模式的具体概念和使用方法，并且感受到了他的优点带来的方便，但是同时也知道了该设计模式的缺点：由于单例模式中没有抽象层，因此单例类的扩展有很大困难。 实验二工厂模式的应用 1 实验目的 1) 掌握工厂模式（ Factory ）的特点 2) 分析具体问题，使用工厂模式进行设计。 2 实验内容和要求 有一个OEM制造商代理做HP笔记
本电脑，后来该制造商得到了更多的品牌笔记本电脑的订单Acer，Lenovo，Dell，该OEM商发现，如果一次同时做很多个牌子的本本，有些不利于管理。利用工厂模式改善设计，用C#控制台应用程序实现该OEM制造商的工厂模式。绘制该模式的UML图。UML 图： 源代码：class Laptop { public virtual void GetLaptop { } } class HpLaptop:Laptop { public override void GetLaptop { ; } } class AcerLaptop : Laptop {