工厂模式代码及类图

合集下载

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

03 C#设计模式-简单工厂模式

03 C#设计模式-简单工厂模式

简单工厂模式的结构与实现
class Factory 简单工厂模式实现 { //静态工厂方法 典型的工厂类代码: public static Product GetProduct(string arg) { Product product = null; if (arg.Equals("A")) { product = new ConcreteProductA(); //初始化设置product } else if (arg.Equals("B")) { product = new ConcreteProductB(); //初始化设置product } return product; } }

简单工厂模式概述
简单工厂模式定义
在简单工厂模式中用于创建实例的方法通常是静态 (static)方法,因此又被称为静态工厂方法(Static Factory Method)模式 要点:如果需要什么,只需要传入一个正确的参数, 就可以获取所需要的对象,而无须知道其创建细节
<<use>>
udao.FindUserById();
引入工厂类UserDAOFactory
UserDAOFactory + CreateUserDAO (int arg) : UserDAO ...
Login - udao : UserDAO + Login (int arg) + Execute () : void ...

创建对象与使用对象
C#语言创建对象的几种方式
使用new关键字直接创建对象 通过反射机制创建对象 通过克隆方法创建对象 通过工厂类创建对象
www.CBiblioteka

工厂模式的三种类型

工厂模式的三种类型

工厂模式的三种类型1抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。

抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,能够创建多个产品族的产品对象。

1.抽象工厂(Creator)角色抽象工厂模式的核心,包含对多个产品结构的声明,任何工厂类都必须实现这个接口。

2.具体工厂(ConcreteCreator)角色具体工厂类是抽象工厂的一个实现,负责实例化某个产品族中的产品对象。

3.抽象(Product)角色抽象模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

4.具体产品(ConcreteProduct)角色抽象模式所创建的具体实例对象总结:抽象工厂中方法对应产品结构,具体工厂对应产品族。

2工厂方法模式同样属于类的创建型模式又被称为多态工厂模式工厂方法模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。

核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

1.抽象工厂(Creator)角色工厂方法模式的核心,任何工厂类都必须实现这个接口。

2.具体工厂(ConcreteCreator)角色具体工厂类是抽象工厂的一个实现,负责实例化产品对象。

3.抽象(Product)角色工厂方法模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

4.具体产品(ConcreteProduct)角色工厂方法模式所创建的具体实例对象工厂方法模式与简单工厂模式在结构上的不同不是很明显。

工厂方法类的核心是一个抽象工厂类,而简单工厂模式把核心放在一个具体类上。

工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口,或者有共同的抽象父类。

当系统扩展需要添加新的产品对象时,仅仅需要添加一个具体对象以及一个具体工厂对象,原有工厂对象不需要进行任何修改,也不需要修改客户端,很好的符合了“开放-封闭”原则。

设计模式习题

设计模式习题

设计模式习题一、模式(Pattern)定义策略模式(Strategy)定义:策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。

策略模式让算法独立于使用它的客户而独立变化。

类图:Context(适用性):1) 需要使用ConcreteStrategy提供的算法。

2) 内部维护一个Strategy的实例。

3) 负责动态设置运行时Strategy具体的实现算法。

4) 负责跟Strategy之间的交互和数据传递。

Strategy(抽象策略类):定义了一个公共接口,各种不同的算法以不同的方式实现这个接口,Context使用这个接口调用不同的算法,一般使用接口或抽象类实现。

ConcreteStrategy(具体策略类):实现了Strategy定义的接口,提供具体的算法实现。

适用性:对于Strategy模式来说,主要有这些适用性:1、多个类只区别在表现行为不同,可以使用Strategy模式,在运行时动态选择具体要执行的行为。

(例如FlyBehavior和QuackBehavior)2、需要在不同情况下使用不同的策略(算法),或者策略还可能在未来用其它方式来实现。

(例如FlyBehavior和QuackBehavior的具体实现可任意变化或扩充)3、对客户(Duck)隐藏具体策略(算法)的实现细节,彼此完全独立。

策略模式顺序图:1.观察者模式(Observer Pattern)定义:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

类图:P52 主要解决问题:l 当一个抽象模型有两个方面的,其中一个方面依赖与另一个方面。

l 当一个对象的改变需要同时改变其他对象,而不知道具体有多对象有待改变l 当一个对象必须通知其他对象,而它又不能假定其他对象是谁。

生活中的例子:观察者定义了对象间一对多的关系,当一个对象的状态变化时,所有依赖它的对象都得到通知并且自动地更新。

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

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

实验二:工厂模式实验内容简单工厂方法模式:利用简单工厂方法模式创建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 抽象工厂模式实现效果图实验体会做完这次试验,下面是我的一些体会:首先,工厂模式是为了解耦:把对象的创建和使用的过程分开。

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

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

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

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

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

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

深入浅出设计模式(中文版)

深入浅出设计模式(中文版)

这便是简单工厂模式了。怎么样,使用起来很简单吧?那么它带来了什么好处呢? 首先,使用了简单工厂模式后,我们的程序不在“有病”,更加符合现实中的情况;而且 客户端免除了直接创建产品对象的责任,而仅仅负责“消费”产品(正如暴发户所为) 。 下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当暴发户 增加了一辆车的时候, 只要符合抽象产品制定的合同, 那么只要通知工厂类知道就可以被客 户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为 每增加一辆车, 都要在工厂类中增加相应的业务逻辑或者判断逻辑, 这显然是违背开闭原则 的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类(在我们的例子中 是为司机师傅) ,我们称它为全能类或者上帝类。 我们举的例子是最简单的情况, 而在实际应用中, 很可能产品是一个多层次的树状结构。 由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了, 也累坏了我们这些程序员:( 于是工厂方法模式作为救世主出现了。 四、工厂方法模式 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性, 使得它可以被子类继承。 这 样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分 担。 你应该大致猜出了工厂方法模式的结构,来看下它的组成: 1) 抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须 实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。 2) 具体工厂角色: 它含有和具体业务逻辑有关的代码。 由应用程序调用以创建对应的具体 产品的对象。
那么简单工厂模式怎么来使用呢?我们就以简单工厂模式来改造暴发户坐车的方式 ——现在暴发户只需要坐在车里对司机说句:“开车”就可以了。 //抽象产品角色 public interface Car{ public void drive(); } //具体产品角色 public class Benz implements Car{ public void drive() { System.out.println("Driving Benz "); } } public class Bmw implements Car{ public void drive() { System.out.println("Driving Bmw "); } } 。 。 。 (奥迪我就不写了:P) //工厂类角色 public class Driver{ //工厂方法.注意 返回类型为抽象产品角色 public static Car driverCar(String s)throws Exception //判断逻辑,返回具体的产品角色给 Client if(s.equalsIgnoreCase("Benz")) return new Benz(); else if(s.equalsIgnoreCase("Bmw")) return new Bmw(); ...... else throw new Exception(); 。 。 。 //欢迎暴发户出场...... {

工厂模式简介和应用场景

工厂模式简介和应用场景

⼯⼚模式简介和应⽤场景⼀、简介⼯⼚模式主要是为创建对象提供了接⼝。

⼯⼚模式按照《Java与模式》中的提法分为三类:1. 简单⼯⼚模式(Simple Factory)2. ⼯⼚⽅法模式(Factory Method)3. 抽象⼯⼚模式(Abstract Factory)⼆、简单⼯⼚模式我喜欢吃⾯条,抽象⼀个⾯条基类,(接⼝也可以),这是产品的抽象类。

public abstract class INoodles {/*** 描述每种⾯条啥样的*/public abstract void desc();}先来⼀份兰州拉⾯(具体的产品类):public class LzNoodles extends INoodles {@Overridepublic void desc() {System.out.println("兰州拉⾯上海的好贵家⾥才5 6块钱⼀碗");}}程序员加班必备也要吃泡⾯(具体的产品类):public class PaoNoodles extends INoodles {@Overridepublic void desc() {System.out.println("泡⾯好吃可不要贪杯");}}还有我最爱吃的家乡的⼲扣⾯(具体的产品类):public class GankouNoodles extends INoodles {@Overridepublic void desc() {System.out.println("还是家⾥的⼲扣⾯好吃 6块⼀碗");}}准备⼯作做完了,我们来到⼀家“简单⾯馆”(简单⼯⼚类),菜单如下:public class SimpleNoodlesFactory {public static final int TYPE_LZ = 1;//兰州拉⾯public static final int TYPE_PM = 2;//泡⾯public static final int TYPE_GK = 3;//⼲扣⾯public static INoodles createNoodles(int type) {switch (type) {case TYPE_LZ:return new LzNoodles();case TYPE_PM:return new PaoNoodles();case TYPE_GK:default:return new GankouNoodles();}}}简单⾯馆就提供三种⾯条(产品),你说你要啥,他就给你啥。

软件体系结构—设计模式3.1—简单工厂模式

软件体系结构—设计模式3.1—简单工厂模式

要提出BadShapeException 异常。
(2)请给出上一题的源代码。 (3)请简单举例说明描图员系统怎样使用。
消费角色无需知道它得到的是哪一个产品;换言之,产品消费角色无需修改 就可以接纳新的产品。
对于工厂角色来说,增加新的产品是一个痛苦的过程。工厂角色必须知道每
一种产品,如何创建它们,以及何时向客户端提供它们。换言之,接纳新的 产品意味着修改这个工厂角色的源代码。
综合本节的讨论,简单工厂角色只在有限的程度上支持“开–闭”原则。
3、多个工厂方法 每个工厂类可以有多于一个的工厂方法,分别负责创建不同的产品对象。 4、抽象产品角色的省略 如果系统仅有一个具体产品角色的话,那么就可以省略掉抽象产品角色。省 略掉抽象产品类后的简略类图如下图所示。
仍然以前面给出的示意性系统为例,这时候系统的类图就变成如下所示。
下面是工厂类的源代码。显然,这个类提供一个工厂方法,返还一个具体产 品类的实例。
简单工厂模式所创建的对象往往属于一个产品等级结构,这个等级结构可以
是MVC模式中的视图(View);而工厂角色本身可以是控制器
(Controller)。一个MVC 模式可以有一个控制器和多个视图,如下图所示。
换言之,控制器端可以创建合适的视图端,就如同工厂角色创建合适的对象
角色一样;而模型端则可以充当这个创建过程的客户端。 如果系统需要有多个控制器参与这个过程的话,简单工厂模式就不适用了,
简单的情况下,可以简化为一个标识接口。所谓标识接口,就是没有声明任 何方法的空接口。
具体产品类的示意性源代码如下。
2.3简单工厂模式的实现
1、多层次的产品结构 在真实的系统中,产品可以形成复杂的等级结构,比如下图所示的树状结构 上就有多个抽象产品类和具体产品类。

数据访问层设计

数据访问层设计

在系列一中,我从整体上分析了PetShop的架构设计,并提及了分层的概念。

从本部分开始,我将依次对各层进行代码级的分析,以求获得更加细致而深入的理解。

在PetShop 4.0中,由于引入了 2.0的一些新特色,所以数据层的内容也更加的广泛和复杂,包括:数据库访问、Messaging、MemberShip、Profile 四部分。

在系列二中,我将介绍有关数据库访问的设计。

在PetShop中,系统需要处理的数据库对象分为两类:一是数据实体,对应数据库中相应的数据表。

它们没有行为,仅用于表现对象的数据。

这些实体类都被放到Model程序集中,例如数据表Order对应的实体类OrderInfo,其类图如下:这些对象并不具有持久化的功能,简单地说,它们是作为数据的载体,便于业务逻辑针对相应数据表进行读/写操作。

虽然这些类的属性分别映射了数据表的列,而每一个对象实例也恰恰对应于数据表的每一行,但这些实体类却并不具备对应的数据库访问能力。

由于数据访问层和业务逻辑层都将对这些数据实体进行操作,因此程序集Model 会被这两层的模块所引用。

第二类数据库对象则是数据的业务逻辑对象。

这里所指的业务逻辑,并非业务逻辑层意义上的领域(domain)业务逻辑(从这个意义上,我更倾向于将业务逻辑层称为“领域逻辑层”),一般意义上说,这些业务逻辑即为基本的数据库操作,包括Select,Insert,Update和Delete。

由于这些业务逻辑对象,仅具有行为而与数据无关,因此它们均被抽象为一个单独的接口模块IDAL,例如数据表Order对应的接口IOrder:将数据实体与相关的数据库操作分离出来,符合面向对象的精神。

首先,它体现了“职责分离”的原则。

将数据实体与其行为分开,使得两者之间依赖减弱,当数据行为发生改变时,并不影响Model模块中的数据实体对象,避免了因一个类职责过多、过大,从而导致该类的引用者发生“灾难性”的影响。

其次,它体现了“抽象”的精神,或者说是“面向接口编程”的最佳体现。

实验3 抽象工厂模式

实验3 抽象工厂模式
}
interfaceView {
voidcreate();
}
classAndroidimplementsContral {
publicvoidcreate() {
System.out.println("contral");
}
}
classAndroid2implementsView
{
publicvoidcreate() {
publicvoidcreate() {
System.out.println("mac'RAM");
}
}
interfaceComputerFactory {
CPU produceCPU();
RAM produceRAM();
}
classPcFactoryimplementsComputerFactory {
RAM ram;
Factory = new ComputerFactory();
cpu =factory.produceCPU();
cpu.create();
ram =factory.produceRAM();
ram.create();
}
}
2.类图及代码:
interfaceContral {
voidcreate();
Factory factory =newSymbinFactory();
Contral c;
View v;
c = factory.produce1();
c.create();
v = factory.produce2();
v.create();
}
}
五.实验总结

设计模式之工厂模式(3种)详解及代码示例

设计模式之工厂模式(3种)详解及代码示例

设计模式之⼯⼚模式(3种)详解及代码⽰例 ⼯⼚模式划分来说总共有三类:简单⼯⼚模式、⼯⼚⽅法模式和抽象⼯⼚模式。

其中简单⼯⼚模式不输⼊23种设计模式之⼀,但他们⼜都属于创建型模式。

我们依次讲解这三种⼯⼚模式。

⼀、简单⼯⼚ 1、什么是简单⼯⼚模式? ⾸先来说简单⼯⼚,简单⼯⼚模式,⼜叫做静态⼯⼚模式(Static Factory Method),由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例,简单⼯⼚模式的实质是由⼀个⼯⼚类根据传⼊的参数,动态决定应该创建哪⼀个产品类。

属于创建型模式,但不属于GOF23设计模式。

2、简单⼯⼚适⽤场景 ⼯⼚类负责创建的对象⽐较少;客户端(应⽤层)只需要知道传⼊⼯⼚类的参数,对于如何创建对象(逻辑)不关⼼。

3、简单⼯⼚优缺点优点:只需要传⼊⼀个正确的参数,就可以获取你所需要的对象,⽽⽆需知道其细节创建。

缺点:⼯⼚类的职责相对过重,增加新的产品,需要修改⼯⼚类的判断逻辑,违背了开闭原则。

4、简单⼯⼚实现 ⾸先来看类图: 代码实现:public class ShapeFactory {public Shape getShape(String shapeType){if(shapeType.equalsIgnoreCase("circle")){return new Circle();}else if(shapeType.equalsIgnoreCase("rectangle")){return new Rectangle();}else if(shapeType.equalsIgnoreCase("squere")){return new Squere();}return null;}public Shape getShape(Class clazz) throws Exception{return (Shape) clazz.newInstance();}}⼆、⼯⼚⽅法模式 1、什么是⼯⼚⽅法 ⼯⼚⽅法模式(Factory Method),⼜称多态性⼯⼚模式,属于设计模式三⼤分类中的创建型模式,作为抽象⼯⼚模式的孪⽣兄弟,⼯⼚⽅法模式定义了⼀个创建对象的接⼝,但由⼦类决定要实例化的类是哪⼀个,也就是说⼯⼚模式让实例化推迟到⼦类。

郑州大学设计模式小作业

郑州大学设计模式小作业

一、抽象工厂模式1.1 题目:计算机包含内存(RAM)、CPU等硬件设备,根据下面的“产品等级结构-产品族”示意图,使用抽象工厂模式实现计算机设备创建过程并绘制相应的类图。

1.2类图:1.3程序代码://定义接口CPUpublic interface CPU {void create();}//定义接口RAMpublic interface RAM {void create();}//定义类PcCPUpublic class PcCPU implements CPU{ public void create() {System.out.println(" win cpu");}}//定义类PcRAMpublic class PcRAM implements RAM { public void create() {System.out.println("win RAM");}}//定义类MacCPUpublic class MacCPU implements CPU{ public void create() {System.out.println("mac CPU");}}//定义类MacRAMpublic class MacRAM implements RAM{ public void create() {System.out.println("mac RAM");}}//定义接口ComputerFactoryinterface ComputerFactory {CPU produceCPU();RAM produceRAM();}//定义类ComputerPartsClientpublic class ComputerPartsClient {public static void main(String args[]) {ComputerFactory factory;CPU cpu;RAM ram;factory = new PcFactory();cpu = factory.produceCPU();cpu.create();ram = factory.produceRAM();ram.create();ComputerFactory factory1;factory1 = new MacFactory();cpu = factory1.produceCPU();cpu.create();ram = factory1.produceRAM();ram.create();}}//定义类PcFactorypublic class PcFactory implements ComputerFactory { public PcCPU produceCPU() {System.out.println("请使用PC产品族的CPU");return new PcCPU();}public PcRAM produceRAM() {System.out.println("请使用PC产品族的RAM");return new PcRAM();}}//定义类MacFactorypublic class MacFactory implements ComputerFactory{ public MacCPU produceCPU() {System.out.println("请使用Mac产品族的CPU");return new MacCPU();}public MacRAM produceRAM() {System.out.println("请使用Mac产品族的RAM");return new MacRAM();}}1.4运行结果:二、桥接模式2.1题目:如果系统中某对象有三个维度,如某日志记录器既可以支持不同的操作系统(Windows、Linux、Unix),还可以支持多种编程语言(C#、C++、Java),并且可以使用不同的输出方式(File、Console、XML)。

软件开发的23种设计模式

软件开发的23种设计模式

软件开发的23种设计模式 ⼆⼗三种设计模式1.单例模式(Singleton Pattern)定义:Ensure a class has only one instance, and provide a global point of access to it.(确保某⼀个类只有⼀个实例,⽽且⾃⾏实例化并向整个系统提供这个实例。

)通⽤代码:(是线程安全的)public class Singleton {private static final Singleton singleton = new Singleton();//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){return singleton;}//类中其他⽅法,尽量是staticpublic static void doSomething(){}}使⽤场景:●要求⽣成唯⼀序列号的环境;●在整个项⽬中需要⼀个共享访问点或共享数据,例如⼀个Web页⾯上的计数器,可以不⽤把每次刷新都记录到数据库中,使⽤单例模式保持计数器的值,并确保是线程安全的;●创建⼀个对象需要消耗的资源过多,如要访问IO和数据库等资源;●需要定义⼤量的静态常量和静态⽅法(如⼯具类)的环境,可以采⽤单例模式(当然,也可以直接声明为static的⽅式)。

线程不安全实例:public class Singleton {private static Singleton singleton = null;//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){if(singleton == null){singleton = new Singleton();}return singleton;}}解决办法:在getSingleton⽅法前加synchronized关键字,也可以在getSingleton⽅法内增加synchronized来实现。

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

简单工厂、工厂方法、抽象工厂模式实验报告
类图修改为如图 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();
实验步骤: (算法描述、源程序、操作步骤和方法)
简单工厂工厂方法抽象工厂模式实验报告模式工厂方法简单工厂工厂方法抽象工厂工厂方法工厂模式简单工厂

软件工程的23种设计模式的UML类图

软件工程的23种设计模式的UML类图

软件工程的23种设计模式的UML类图0 引言谈到设计模式,绝对应该一起来说说重构。

重构给我们带来了什么?除了作为对遗留代码的改进的方法,另一大意义在于,能够让我们在写程序的时候能够不需事先考虑太多的代码组织问题,当然这其中也包含了应用模式的问题。

尽管大多数开发者都已经养成了写代码前先从设计开始的习惯,但是,这种程度的设计,涉及到到大局、到总体架构、到要紧的模块划分我觉得就够了。

换句话说,这时就能写代码了。

这就得益于重构的思想了。

假如没有重构的思想,有希望获得非常高质量的代码,我们就不得不在开始写代码前考虑更多事实上并非非常稳固的代码组织及设计模式的应用问题,那开发效率当然就大打折扣了。

在重构与设计模式的合理应用之下,我们能够相对较早的开始写代码,并在功能尽早实现的同时,不断地通过重构与模式来改善我们的代码质量。

因此,下面的章节中,在谈模式的同时,我也会谈谈关于常用的这些模式的重构成本的懂得。

重构成本越高意味着,在遇到类似的问题情形的时候,我们更应该提早考虑应用对应的设计模式,而重构成本比较低则说明,类似的情形下,完全能够先怎么方便,怎么快怎么写,哪怕代码不是很优雅也没关系,回头再重构也很容易。

1 创建型1.1FactoryMethod思想:Factory Method的要紧思想是使一个类的实例化延迟到其子类。

场景:典型的应用场景如:在某个系统开发的较早阶段,有某些类的实例化过程,实例化方式可能还不是很确定,或者者实际实例化的对象(可能是需要对象的某个子类中的一个)不确定,或者者比较容易变化。

如今,假如直接将实例化过程写在某个函数中,那么通常就是if-else或者select-case代码。

假如,候选项的数目较少、类型基本确定,那么这样的if-else还是能够同意的,一旦情形变得复杂、不确定性增加,更甚至包含这个构造过程的函数所在的类包含几个甚至更多类似的函数时,这样的if-else代码就会变得比较不那么容易保护了。

软件设计模式中的工厂模式

软件设计模式中的工厂模式

软件设计模式中的工厂模式在软件设计和开发中,模式是一种重要的技术手段,它可以用来解决不同的问题,提高代码的可重用性和可维护性。

工厂模式是一种常用的设计模式,它可以将对象的创建和使用分离开来,使得程序可以更加灵活地处理对象的生成和管理。

本文将介绍工厂模式的相关知识,包括其基本概念、实现方法和应用场景等。

一、基本概念工厂模式是一种创建型模式,其核心思想是将对象的创建过程封装起来,让客户端通过调用工厂类来获取所需的对象。

工厂模式分为三种类型:简单工厂模式、工厂方法模式和抽象工厂模式。

其中,简单工厂模式只有一个工厂类,它根据客户端传递的参数来生成不同的对象;工厂方法模式中,每个对象都有一个对应的工厂类,由客户端决定使用哪个工厂类来创建对象;抽象工厂模式中,一个工厂类可以生成多个产品族的对象,即一组相关的对象。

二、实现方法实现工厂模式需要注意以下几点:1.定义一个工厂接口,用于描述工厂的功能。

2.定义一个工厂类,该类实现工厂接口,并提供一个可以生成对象的方法。

3.定义一个产品接口,用于规范不同类型的产品。

4.定义多个具体产品类,它们都实现产品接口。

5.客户端使用工厂类来生成所需的对象,而不是直接创建对象。

三、应用场景工厂模式适用于以下场景:1.需要大量创建相似对象的情况。

2.需要在不同的环境下生成不同的对象时。

3.需要封装对象的创建过程,提高代码的可维护性和可重用性。

4.需要对客户端隐藏具体的实现细节,从而降低客户端和产品的耦合度。

四、总结工厂模式是一种常用的设计模式,它可以将对象的创建和使用分离开来,使得程序可以更加灵活地处理对象的生成和管理。

工厂模式分为三种类型:简单工厂模式、工厂方法模式和抽象工厂模式。

实现工厂模式需要定义工厂接口、工厂类、产品接口和具体产品类等。

工厂模式适用于需要大量创建相似对象、需要封装对象创建过程或需要隐藏具体实现细节的情况下。

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

抽象工厂类图:代码:public interface Sauce {}public class MarinaraSauce implements Sauce{public MarinaraSauce(){System.out.println("Add MarinaraSauce...");}} public class PlumTomatoSauce implements Sauce{public PlumTomatoSauce(){System.out.println("Add PlumTomatoSauce...");}}public interface Dough {}public class ThickCrustDough implements Dough{public ThickCrustDough(){System.out.println("Add ThickCrustDough...");}}public class ThinCrustDough implements Dough{public ThinCrustDough(){System.out.println("Add ThinCrustDough...");}}public interface Veggies {}public class Onion implements Veggies{ public Onion(){System.out.println("Add Onion...");}}public class Mushroom implements Veggies{public Mushroom(){System.out.println("Add Mushroom...");}}public class Garlic implements Veggies{public Garlic(){System.out.println("Add Garlic...");}}public class Eggplant implements Veggies{public Eggplant(){System.out.println("Add Eggplant...");}}public class BlackOlives implements Veggies{public BlackOlives(){System.out.println("Add BlackOlives...");}}public abstract class Pizza {String name;Dough dough;Sauce sauce;Veggies veggies[];abstract void prepare();void bake(){System.out.println("Bake for 25 minutes at 350");}void cut(){System.out.println("Cutting the pizza into diagonal slices");}void box(){System.out.println("Place pizza in official PizzaStore box");}void setName(String name){=name;}String getname(){return name;}}public interface PizzaIngredientFactory {public Dough createDough();public Sauce createSauce();public Veggies[] createVeggies();}public class NYPizzaIngredientFactory implements PizzaIngredientFactory{ public Dough createDough(){return new ThinCrustDough();}public Sauce createSauce(){return new MarinaraSauce();}public Veggies[] createVeggies(){Veggies veggies[]={new Garlic(),new Onion(),new Mushroom()};return veggies;}}public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory{ public Dough createDough(){return new ThickCrustDough();}public Sauce createSauce(){return new PlumTomatoSauce();}public Veggies[] createVeggies(){Veggies veggies[]={new BlackOlives(),new Eggplant()};return veggies;}}public class VeggiesPizza extends Pizza{PizzaIngredientFactory ingredientFactory;public VeggiesPizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory=ingredientFactory;}void prepare(){System.out.println("Preparing "+name);dough=ingredientFactory.createDough();sauce=ingredientFactory.createSauce();veggies=ingredientFactory.createVeggies();}}public class CheesePizza extends Pizza{PizzaIngredientFactory ingredientFactory;public CheesePizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory=ingredientFactory;}void prepare(){System.out.println("Preparing "+name);dough=ingredientFactory.createDough();sauce=ingredientFactory.createSauce();}}public abstract class PizzaStore {public Pizza orderPizza(String type){Pizza pizza;pizza=createPizza(type);pizza.prepare();pizza.bake();pizza.cut();pizza.box();return pizza;}protected abstract Pizza createPizza(String type);}public class NYPizzaStore extends PizzaStore{ protected Pizza createPizza(String item){Pizza pizza=null;PizzaIngredientFactory ingredientFactory=new NYPizzaIngredientFactory();if(item.equals("cheese")){pizza=new CheesePizza(ingredientFactory);pizza.setName("New York Style Cheese Pizza");}else if(item.equals("veggie")){pizza=new VeggiesPizza(ingredientFactory);pizza.setName("New York Style veggie Pizza");}return pizza;}}public class ChicagoPizzaStore extends PizzaStore{ protected Pizza createPizza(String item){Pizza pizza=null;PizzaIngredientFactory ingredientFactory=new ChicagoPizzaIngredientFactory();if(item.equals("cheese")){pizza=new CheesePizza(ingredientFactory);pizza.setName("Chicago Style Cheese Pizza");}else if(item.equals("veggie")){pizza=new VeggiesPizza(ingredientFactory);pizza.setName("Chigago Style veggie Pizza");}return pizza;}}测试结果Preparing New York Style Cheese PizzaAdd ThinCrustDough...Add MarinaraSauce...Bake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxEthan ordered a New York Style Cheese Pizza Preparing Chigago Style veggie PizzaAdd ThickCrustDough...Add PlumTomatoSauce...Add BlackOlives...Add Eggplant...Bake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxJoel ordered a Chigago Style veggie Pizza Preparing New York Style veggie PizzaAdd ThinCrustDough...Add MarinaraSauce...Add Garlic...Add Onion...Add Mushroom...Bake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxMul ordered a New York Style veggie Pizza Preparing Chicago Style Cheese PizzaAdd ThickCrustDough...Add PlumTomatoSauce...Bake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxTom ordered a Chicago Style Cheese Pizza工厂方法:类图代码import java.util.ArrayList;public abstract class Pizza {String name;String dough;String sauce;ArrayList toppings=new ArrayList();void prepare(){System.out.println("Preparing "+name);System.out.println("Tossing dough...");System.out.println("Adding sauce...");System.out.println("Adding toppings: ");for(int i=0;i<toppings.size();i++){System.out.println(""+toppings.get(i));}}void bake(){System.out.println("Bake for 25 minutes at 350");}void cut(){System.out.println("Cutting the pizza into diagonal slices");}void box(){System.out.println("Place pizza in official PizzaStore box");}void setName(String name){=name;}String getname(){return name;}}public class ChicagoStyleCheesePizza extends Pizza{public ChicagoStyleCheesePizza(){name="Chicago Style Deep Dish Cheese Pizza";dough="Extra Thick Crust Dough";sauce="Plum Tomato Sauce";toppings.add("Shredded Mozzarella Cheese");}void cut(){System.out.println("Cutting the pizza into square slices");}}public class ChicagoStyleV eggiePizza extends Pizza{public ChicagoStyleV eggiePizza(){name="Chigago Style veggie Pizza";dough="Extra Thick Crust Dough";sauce="Plum Tomato Sauce";toppings.add("BlackOlives");toppings.add("Eggplant");}}public class NYStyleCheesePizza extends Pizza{ public NYStyleCheesePizza(){name="NY Style Sauce and Cheese Pizza";dough="Thin Crust Dough";sauce="Marinara Sauce";toppings.add("Grated Reggiano Cheese");}}public class NYStyleV eggiePizza extends Pizza{ public NYStyleV eggiePizza(){name="New Y ork Style veggie Pizza";dough="Thin Crust Dough";sauce="Marinara Sauce";toppings.add("Garlic");toppings.add("Onion");toppings.add("Mushroom");}}public abstract class PizzaStore {public Pizza orderPizza(String type){Pizza pizza;pizza=createPizza(type);pizza.prepare();pizza.bake();pizza.cut();pizza.box();return pizza;}protected abstract Pizza createPizza(String type);}public class ChicagoPizzaStore extends PizzaStore{ protected Pizza createPizza(String item){Pizza pizza=null;if(item.equals("cheese")){pizza=new ChicagoStyleCheesePizza();}else if(item.equals("veggie")){pizza=newChicagoStyleV eggiePizza();}return pizza;}}public class NYPizzaStore extends PizzaStore{ protected Pizza createPizza(String item){Pizza pizza=null;if(item.equals("cheese")){pizza=new NYStyleCheesePizza();}else if(item.equals("veggie")){pizza=new NYStyleV eggiePizza();}return pizza;}}public class PizzaTestDrive {public static void main(String []args){PizzaStore nyStore=new NYPizzaStore();PizzaStore chicagoStore=new ChicagoPizzaStore();Pizza pizza=nyStore.orderPizza("cheese");System.out.println("Ethan ordered a "+pizza.getname()+"\n");pizza=chicagoStore.orderPizza("veggie");System.out.println("Joel ordered a "+pizza.getname()+"\n");pizza=nyStore.orderPizza("veggie");System.out.println("Mul ordered a "+pizza.getname()+"\n");pizza=chicagoStore.orderPizza("cheese");System.out.println("Tom ordered a "+pizza.getname()+"\n");}}测试结果:Preparing NY Style Sauce and Cheese PizzaTossing dough...Adding sauce...Adding toppings:Grated Reggiano CheeseBake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxEthan ordered a NY Style Sauce and Cheese Pizza Preparing Chigago Style veggie PizzaTossing dough...Adding sauce...Adding toppings:BlackOlivesEggplantBake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxJoel ordered a Chigago Style veggie PizzaPreparing New York Style veggie PizzaTossing dough...Adding sauce...Adding toppings:GarlicOnionMushroomBake for 25 minutes at 350Cutting the pizza into diagonal slicesPlace pizza in official PizzaStore boxMul ordered a New York Style veggie PizzaPreparing Chicago Style Deep Dish Cheese Pizza Tossing dough...Adding sauce...Adding toppings:Shredded Mozzarella CheeseBake for 25 minutes at 350Cutting the pizza into square slicesPlace pizza in official PizzaStore boxTom ordered a Chicago Style Deep Dish Cheese Pizza。

相关文档
最新文档