当前位置：文档之家 › 抽象工厂设计模式的实验报告

抽象工厂设计模式的实验报告

  • 格式：pdf
  • 大小：214.94 KB
  • 文档页数：6

下载文档原格式

  / 6

合集下载

实验五 工厂方法模式、抽象工厂模式和生成器模式

实验五 工厂方法模式、抽象工厂模式和生成器模式

实验五工厂方法模式、抽象工厂模式和生成器模式的应用一、实验目的通过该实验，理解工厂方法模式、抽象工厂模式和生成器模式的意图、结构，在软件开发中使用这些模式并进行功能验证。

二、实验内容1.手机工厂：现实中不同品牌的手机应由不同的工厂制造，使用工厂方法模式模拟实现。

图1 手机工厂的类图2.微型计算机配件的生产：该系统所需要的产品族有两个：PC系列和MAC系列，产品等级结构也有两个：RAM和CPU，使用抽象工厂模式模拟实现。

图2 微型计算机配件生产系统的设计类图3.用程序画一个小人：要求小人要有头、身体、手和脚。

使用生成器模式模拟实现。

图3 利用程序画小人的类图三、实验步骤与要求1．对于以上题目要认真分析和理解题意，程序中要求使用相应的模式。

2．上机录入，使用JDK编译器调试、运行、验证程序。

3．请指导教师审查程序和运行结果并评定成绩；4．撰写并上交实验报告。

四、实验原理：1、工厂方法模式当系统准备为用户提供某个类的子类的实例，又不想让用户代码和该子类形成耦合时，可以使用工厂方法模式来设计系统。

工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法，该方法返回某个类的子类的实例，该抽象类或接口让其子类或实现该接口的类通过重写这个抽象方法返回某个子类的实例。

适合使用工厂方法模式的情景有：●用户需要一个类的子类的实例，但不希望与该类的子类形成耦合●用户需要一个类的子类的实例，但用户不知道该类有哪些子类可用。

工厂方法模式的UML类图：图4 工厂方法模式的类图2、抽象工厂模式当系统准备为用户提供一系列相关的对象，又不想让用户代码和创建这些对象的类形成耦合时，就可以使用抽象工厂模式来设计系统。

抽象工厂模式的关键是在一个抽象类或接口中定义若干个抽象方法，这些抽象方法分别返回某个类的实例，该抽象类或接口让其子类或实现该接口的类重写这些抽象方法为用户提供一系列相关的对象。

适合使用抽象工厂模式的情景有：●系统需要为用户提供多个对象，但不希望用户直接使用new运算符实例化这些对象，即希望用户和创建对象的类解耦。

设计模式实验报告总结(3篇)

设计模式实验报告总结(3篇)

第1篇一、实验背景随着软件工程的不断发展，设计模式作为一种解决软件开发中常见问题的有效方法，越来越受到广泛关注。

本次实验旨在通过学习设计模式，提高编程能力，掌握解决实际问题的方法，并加深对设计模式的理解。

二、实验目的1. 理解设计模式的基本概念和分类；2. 掌握常见设计模式的原理和应用；3. 提高编程能力，学会运用设计模式解决实际问题；4. 培养团队协作精神，提高项目开发效率。

三、实验内容本次实验主要涉及以下设计模式：1. 创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式；2. 结构型模式：适配器模式、装饰者模式、桥接模式、组合模式、外观模式；3. 行为型模式：策略模式、模板方法模式、观察者模式、责任链模式、命令模式。

四、实验过程1. 阅读相关资料，了解设计模式的基本概念和分类；2. 分析每种设计模式的原理和应用场景；3. 编写代码实现常见设计模式，并进行分析比较；4. 将设计模式应用于实际项目中，解决实际问题；5. 总结实验经验，撰写实验报告。

五、实验结果与分析1. 创建型模式（1）单例模式：通过控制对象的实例化，确保一个类只有一个实例，并提供一个访问它的全局访问点。

实验中，我们实现了单例模式，成功避免了资源浪费和同步问题。

（2）工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

实验中，我们使用工厂模式创建不同类型的交通工具，提高了代码的可扩展性和可维护性。

（3）抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

实验中，我们使用抽象工厂模式创建不同类型的计算机，实现了代码的复用和扩展。

（4）建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

实验中，我们使用建造者模式构建不同配置的房屋，提高了代码的可读性和可维护性。

2. 结构型模式（1）适配器模式：将一个类的接口转换成客户期望的另一个接口，使原本接口不兼容的类可以一起工作。

抽象工厂-模式设计

抽象工厂-模式设计

•概述在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。

怎么应对这种变化？怎么绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程式和这种“多系列具体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。

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

模型图逻辑模型：物理模型：生活中的例子抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口，而不必指定他们具体的类。

这种模式能汽车制造厂所使用的金属冲压设备中找到。

这种冲压设备能制造汽车车身部件。

同样的机械用于冲压不同的车型的右边车门、左边车门、右前挡泥板、左前挡泥板和引擎罩等等。

通过使用转轮来改动冲压盘，这个机械产生的具体类能在三分钟内改动。

抽象工厂之新解虚拟案例中国企业需要一项简单的财务计算：每月月底，财务人员要计算员工的工资。

员工的工资= (基本工资+ 奖金- 个人所得税)。

这是个放之四海皆准的运算法则。

为了简化系统，我们假设员工基本工资总是4000美金。

中国企业奖金和个人所得税的计算规则是:奖金= 基本工资(4000) * 10%个人所得税= (基本工资+ 奖金) * 40%我们目前要为此构建一个软件系统（代号叫Softo），满足中国企业的需求。

案例分析奖金(Bonus)、个人所得税(Tax)的计算是Softo系统的业务规则(Service)。

工资的计算(Calculator)则调用业务规则(Service)来计算员工的实际工资。

工资的计算作为业务规则的前端(或客户端Client)将提供给最终使用该系统的用户(财务人员)使用。

针对中国企业为系统建模根据上面的分析，为Softo系统建模如下：则业务规则Service类的代码如下：1using System;23namespace ChineseSalary4{5 /**//// ＜summary>6 /// 公用的常量7 /// ＜/summary>8 public class Constant9 {10 public static double BASE_SALARY = 4000;11 }12}1using System;23namespace ChineseSalary4{5 /**//// ＜summary>6 /// 计算中国个人奖金7 /// ＜/summary>8 public class ChineseBonus9 {10 public double Calculate()11 {12 return Constant.BASE_SALARY * 0.1;13 }14 }15}16客户端的调用代码：1using System;23namespace ChineseSalary4{5 /**//// ＜summary>6 /// 计算中国个人所得税7 /// ＜/summary>8 public class ChineseTax9 {10 public double Calculate()11 {12 return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.4;13 }14 }15}16运行程式，输入的结果如下：Chinese Salary is：2640针对美国企业为系统建模为了拓展国际市场，我们要把该系统移植给美国公司使用。

工厂模式实验范文

工厂模式实验范文

工厂模式实验范文工厂模式是一种创建型设计模式，它通过定义一个用于创建对象的接口，但将具体的创建逻辑延迟到子类中完成，使得工厂类在不知道具体产品的情况下，通过子类来创建对象。

工厂模式可以提供灵活的方式来创建对象，并将对象的创建与具体业务逻辑分离，提高代码的可维护性和扩展性。

工厂模式由三个部分组成：抽象产品、具体产品和工厂类。

其中，抽象产品定义了产品的接口，具体产品是实现了抽象产品接口的具体类，工厂类负责创建具体产品对象。

抽象产品：手机接口```javapublic interface Phonevoid call(;void sendMessage(;```具体产品：小米手机类、华为手机类```javapublic class XiaomiPhone implements Phonepublic void cal}public void sendMessagSystem.out.println("使用小米手机发送短信"); }public class HuaweiPhone implements Phone public void cal}public void sendMessagSystem.out.println("使用华为手机发送短信"); }```工厂类：手机工厂类```javapublic class PhoneFactorypublic Phone createPhone(String brand)if ("xiaomi".equals(brand))return new XiaomiPhone(;} else if ("huawei".equals(brand))return new HuaweiPhone(;} elsethrow new IllegalArgumentException("Unsupported phone brand: " + brand);}}```在客户端中使用工厂模式创建手机对象。

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

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

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

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

由此：⼈种和性别相互组合⽣成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();}在接⼝中我们可以看到 抽象的⼯⼚是可以⽣产出不同肤⾊的⼈种的。

工厂模式实验报告

工厂模式实验报告

工厂模式实验报告工厂模式实验报告引言：工厂模式是一种软件设计模式，它提供了一种创建对象的方法，将对象的实例化过程与客户端代码分离，从而提高了代码的可维护性和可扩展性。

在本次实验中，我们将探索工厂模式在实际开发中的应用，并通过实例化汽车工厂的场景来说明其优点和使用方法。

一、工厂模式的背景和概念工厂模式是一种创建型设计模式，它旨在通过一个工厂类来创建对象，而不是直接在客户端代码中进行实例化。

这种方式将对象的创建过程封装在工厂类中，使得客户端代码与具体对象的创建过程解耦，从而提高了代码的灵活性和可维护性。

二、工厂模式的优点1. 代码解耦：工厂模式将对象的创建过程与客户端代码分离，使得客户端代码只需要关注对象的使用，而不需要关心对象的创建细节。

这样可以降低代码的耦合度，提高代码的可维护性和可扩展性。

2. 简化客户端代码：通过工厂模式，客户端代码只需要与工厂类进行交互，而不需要直接与具体的产品类进行交互。

这样可以简化客户端代码，提高代码的可读性和可理解性。

3. 代码复用：工厂模式可以通过一个工厂类创建多个不同类型的对象，从而实现代码的复用。

当需要创建新的对象时，只需要扩展工厂类，而不需要修改客户端代码。

4. 可扩展性：通过工厂模式，可以方便地添加新的产品类，而不需要修改客户端代码。

这样可以提高系统的可扩展性，满足不断变化的需求。

三、工厂模式的实际应用在实际开发中，工厂模式经常被用于创建复杂对象或者对象的组合。

下面以汽车工厂为例，来说明工厂模式的使用方法。

1. 定义产品接口：首先，我们需要定义一个产品接口，用于描述汽车的基本功能和属性，例如加速、刹车等。

2. 创建具体产品类：然后，我们需要创建具体的产品类，实现产品接口，并实现具体的功能和属性。

例如，创建小轿车类、SUV类等。

3. 创建工厂类：接下来，我们需要创建一个工厂类，用于创建产品对象。

工厂类可以根据客户端的需求，创建不同类型的产品对象。

例如，根据客户端传入的参数，工厂类可以创建小轿车对象或者SUV对象。

设计模式实验报告-工厂模式

实验二：工厂模式实验内容简单工厂方法模式：利用简单工厂方法模式创建pad, phone, watch的对象，并使用这些对象娱乐。

工厂模式：利用工厂模式创建pad, phone, watch的对象，并使用这些对象娱乐。

抽象工厂模式：利用抽象工厂模式创建华为、小米、苹果的pad, phone, watch的对象，并使用这些对象娱乐。

简单工厂方法模式设计图1简单工厂模式类图核心代码ConsumerElectronics.java核心代码Pad.java核心代码Watch.java核心代码Phone.java核心代码ConsumerElectronicsFactory.java核心代码实现效果图 2 简单工厂模式实现效果图工厂模式设计图 3 工厂模式类图核心代码ConsumerElectronicsFactory.java核心代码PadFactory.java核心代码WatchFactory.java核心代码PhoneFactory.java核心代码实现效果图4 工厂模式实现效果图抽象工厂模式设计图5抽象工厂模式类图核心代码AbstractFactory.java核心代码AppleFactory.java核心代码HuaweiFactory.java核心代码MiFactory.java核心代码实现效果图 6 抽象工厂模式实现效果图实验体会做完这次试验，下面是我的一些体会：首先，工厂模式是为了解耦：把对象的创建和使用的过程分开。

其次，工厂模式可以降低代码重复。

如果创建对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。

我们可以这些创建对象的代码放到工厂里统一管理。

既减少了重复代码，也方便以后对该对象的创建过程的修改维护。

由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要逐个修正，只需要在工厂里修改即可，降低维护成本。

另外，因为工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。

实验3 抽象工厂模式

publicPcCPU produceCPU() {
System.out.println("CPU over!");
returnnewPcCPU();
}
publicPcRAM produceRAM() {
System.out.println("RAM over");
returnnewPcRAM();
returnnewSymbin();
}
publicView produce2() {
System.out.println("2over");
returnnewAndroid2();
}
}
classSymbinFactoryimplementsFactory {
publicSymbin produce1() {
System.out.println("view");
}
}
classSymbinimplementsContral {
publicvoidcreate() {
System.out.println("sys contral");
}
}
classSymbin2implementsView {
publicvoidcreate() {
RAM ram;
Factory = new ComputerFactory();
cpu =factory.produceCPU();
cpu.create();
ram =factory.produceRAM();
ram.create();
}
}
2.类图及代码：
interfaceContral {

最经典的设计模式实验报告

设计模式实验报告（一）课程名称: ___设计模式__ _实验名称:__创建型与结构型模式专业: 计算机科学与技术学号:姓名:实验日期：2012.4.09工厂模式一、实验目的:1、学习工厂模式设计2、学习抽象工厂模式设计3、学习建造者模式设计4、学习单例模式二、运行环境:Microsoft Visual Studio 2010三、实验内容1、工厂模式模式定义：在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

实例说明：为了让增加新品牌电视机更加方便，可以通过工厂方法模式对该电视机厂进行进一步重构。

可以将原有的工厂进行分割，为每种品牌的电视机提供一个子工厂，海尔工厂专门负责生产海尔电视机，海信工厂专门负责生产海型电视机，如果需要生产TCL电视机，只需要对应增加一个新的TCL工厂即可，原有的工厂无需做任何修改，使得整个系统具有更好的灵活性和可扩展性。

①源代码:Class1:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Windows.Forms;namespace工厂模式?{public interface TV{void play();}public class HaierTV : TV{public void play(){MessageBox.Show("海￡尔?电?视酣?播￥放?中D");}}public class HisenseTV : TV{public void play(){MessageBox.Show("海￡信?电?视酣?播￥放?中D");}}public interface TVFactory{TV produceTV();}public class HaierTVFactory : TVFactory{public TV produceTV(){MessageBox.Show("海￡尔?电?视酣?工¤厂§生Θ?产ú海￡信?电?视酣?机ú");return new HaierTV();}}public class HisenseTVFactory : TVFactory{public TV produceTV(){MessageBox.Show("海￡信?电?视酣?工¤厂§生Θ?产ú海￡信?电?视酣?机ú");return new HisenseTV();}}class Class1{}}Form1.csusing System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;namespace工¤厂§模￡式?{public partial class Form1 : Form{public Form1(){InitializeComponent();}private void button1_Click(object sender, EventArgs e) {TV tv;TVFactory factory;factory = new HaierTVFactory (); //唯¨一?不?一?样ù的?地?方?tv=factory.produceTV ();tv .play ();}private void button2_Click(object sender, EventArgs e) {TV tv;TVFactory factory;factory = new HisenseTVFactory(); //唯¨一?不?一?样ù的?地?方?tv = factory.produceTV();tv.play();}}}②运行结果:主界面：点击“海尔电视”按钮后：再点击“确定”后：点击“海信电视”按钮后：点击“确定”按钮后：2、抽象工厂模式模式定义：提供一个创建一系列相关或相互依赖对象的接口，且无需指定他们具体的类。

简单工厂、工厂方法、抽象工厂模式实验报告

类图修改为如图 2 所示，然后修改程序。
+
"
=
"
+
图 2 简单计算器使用简单工厂方法
三、将类图修改为如图 3 所示，然后修改程序。
图 1 简单计算器
二、将类图修改为如图 2 所示，然后修改程序。
图 3 简单计算器使用工厂方法模式
实验步骤： （算法描述、源程序、操作步骤和方法）
实验目的与要求：初步了解模式的含义，掌握模式的模型图，弄清模式的适
用条件和优点。达到逐步灵活应用的目的。
签名：某某某 2012 年 3 月 24 日
实验内容：
一、 阅读如下计算器程序， 将实现加减乘除计算功能的四个语句改为调用类实例 来实现。类图如图 1 所示。 import java.util.Scanner; public class Application { public static void main(String[] args) { int numberA,numberB; char oper = '+'; double result=0; Scanner sc = new Scanner(System.in); System.out.println("请输入第一个参与运算的数 numberA=："); numberA = sc.nextInt(); System.out.println("请输入第二个参与运算的数 numberB=："); numberB = sc.nextInt();
实验步骤： （算法描述、源程序、操作步骤和方法）
简单工厂工厂方法抽象工厂模式实验报告模式工厂方法简单工厂工厂方法抽象工厂工厂方法工厂模式简单工厂
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}; // 具体产品 Text1 class Text1 : public DrawText {
public: Text1() {
std::cout<<"Text1\n"; }; };
// 具体产品 Rectangle1 class Rectangle1: public DrawRectangle {
Dot2() {
std::cout<<"Dot2\n"; }
};
// 具体产品 Text2 class Text2 : public DrawText {
public: Text2() {
std::cout<<"Text2\n"; }; }; // 具体产品 Rectangle2 class Rectangle2 : public DrawRectangle { public: Rectangle2() {
} DrawText* CreateText() {
return new Text2(); } DrawRectangle* CreateRectangle() {
return new Rectangle2(); } }; // class Drawing { public: DrawLine* drawline; DrawDot* drawdot; DrawText* drawtext; DrawRectangle* drawRectangle; public: Drawing(AbstractFactory* factory); };
std::cout<<"Rectangle2\n";
} };
class AbstractFactory {
public: virtual DrawLine* CreateLine()=0; virtual DrawDot* CreateDot()=0; virtual DrawText* CreateText()=0; virtual DrawRectangle* CreateRectangle()=0;
一、实验目的 使用抽象工厂模式实现一个图形界面，其中的图形包括：文本（Text），矩形（Rectangle），
点（Dot），线（Line）。 二、实现方法 1 采用 VC++环境 2 采用工厂的设计模式 三、模式的思想 提供一个创建一系列相关或相互依赖对象的接口，而不需指定他们具体的类 四、模式设计的 UML 类图的绘制
Drawing::Drawing(AbstractFactory* factory) {
drawdot = factory->CreateDot(); drawline = factory->CreateLine(); drawtext = factory->CreateText(); drawRectangle = factory->CreateRectangle(); }
};
// 抽象产品 DrawRectangle class DrawRectangle {
}; // 具体产品 Line1 class Line1 : public DrawLine {
public: Line1() {
std::cout<<"Line1\n"; } }; // 具体产品 DБайду номын сангаасt1 class Dot1 : public DrawDot { public: Dot1() { std::cout<<"Dot1\n"; }
五、程序源代码 #include<stdio.h> #include<iostream> // 抽象产品 DrawLine class DrawLine { }; // 抽象产品 DrawDot class DrawDot { };
// 抽象产品 DrawText class DrawText {
}; // ConcreteFactory1 class ConcreteFactory1 : public AbstractFactory {
public: DrawLine* CreateLine() { return new Line1(); } DrawDot* CreateDot() { return new Dot1(); } DrawText* CreateText() { return new Text1(); } DrawRectangle* CreateRectangle() { return new Rectangle1(); }
}; // ConcreteFactory2
class ConcreteFactory2 : public AbstractFactory {
public: DrawLine* CreateLine() { return new Line2(); } DrawDot* CreateDot() { return new Dot2();
public: Rectangle1() {
std::cout<<"Rectangle1\n"; } };
// 具体产品 Line2 class Line2 : public DrawLine { public:
Line2() { std::cout<<"Line2\n"; } };
// 具体产品 Dot2 class Dot2 : public DrawDot { public:
void main() {
AbstractFactory* factory= new ConcreteFactory1(); Drawing* drawing= new Drawing(factory) ;
}
六、运行结果
七、实验总结 1、 通过本次实验，加深了对抽象工厂模式的理解。抽象工厂提供一个创建一系列相关 或相互依赖对象的接口，而不需指定他们具体的类。抽象工厂同样是存在缺点的， 难以支持新种类的产品。 2、 由于以前对 C++不太了解，本次实验加深了对 C++的了解，强化了编程能力。理解 解了构造函数，虚函数，纯虚函数，成员函数实现，类之间的继承等含义。 3、 但对于函数的调用问题常常出错，这在以后的学习中应多加注意和练习。