设计模式-快餐简解-【抽象工厂模式】

合集下载

设计模式及其应用场景

设计模式及其应用场景

设计模式及其应用场景
设计模式是指在编写一个应用程序时,应该考虑的常见问题的可重复使用的解决方案。

它们是软件设计过程中最重要的工具,并且能够提高程序的可扩展性,可重用性和可维护性。

设计模式的应用场景包括:
1. 工厂模式:工厂模式可用于创建一组相关或依赖对象,通常是使用一个工厂类来管理操作,以避免将创建代码集成到应用程序中。

2. 抽象工厂模式:抽象工厂模式是工厂模式的进一步抽象,它用于创建一组抽象产品对象,而不需要明确指定具体的产品类。

3. 单例模式:单例模式是一种将一个类的实例限制为一个的设计模式,它可以保证一个类只有一个实例,并且该实例易于访问,以满足特定需求。

4. 命令模式:命令模式是一种将动作封装到对象中的设计模式,它将请求、动作(action)和接收者(receiver)分离,从而使得发送者和接收者之间形成解耦。

5. 观察者模式:观察者模式是一种行为设计模式,它允许一个对象(观察者)注册另一个对象(主题)的更改,以便在主题更改时收到通知。

简说设计模式——抽象工厂模式

简说设计模式——抽象工厂模式

简说设计模式——抽象⼯⼚模式⼀、什么是抽象⼯⼚模式抽象⼯⼚模式其实就是多个,⽐如前⾯⼯⼚⽅法模式中,我们创建多个不同类型的数据库,有MySQL、SQLServer等等,就是⽤⼯⼚⽅法模式来实现的,但此时我们只能实现⼀个表(具体内容见下⽅⼯⼚模式的实现),我们数据库中当然不可能只有⼀个表呀,所以抽象⼯⼚模式就来了。

抽象⼯⼚模式(Abstract Factory),提供⼀个创建⼀系列相关或相互依赖对象的接⼝,⽽⽆需指定它们具体的类。

UML结构图如下:其中,AbstractFactory是抽象⼯⼚接⼝,⾥⾯包含所有的产品创建的抽象⽅法;ConcreteFactory则是具体的⼯⼚,创建具有特定实现的产品对象;AbstractProduct是抽象产品,有可能由两种不同的实现;ConcreteProduct则是对于抽象产品的具体分类的实现。

抽象⼯⼚模式是⼯⼚⽅法模式的升级版本,在有多个业务品种、业务分类时,通过抽象⼯⼚模式产⽣需要的对象是⼀种⾮常好的解决⽅式。

下⾯是抽象⼯⼚模式的通⽤源代码类图:1. AbstractFactory类下述代码是⼀个抽象⼯⼚类,它的职责是定义每个⼯⼚要实现的功能,有n个产品族,在抽象⼯⼚类中就应该有n个创建⽅法。

这⾥按上述类图,给出A、B两个产品族,即构造两个⽅法。

1public abstract class AbstractFactory {23//创建A产品家族4public abstract AbstractProductA createProductA();5//创建B产品家族6public abstract AbstractProductB createProductB();78 }2. AbstractProduct类抽象产品类,两个抽象产品类可以有关系,例如共同继承或实现⼀个抽象类或接⼝。

这⾥给出A产品的抽象类,产品类B类似,不再赘述。

1public abstract class AbstractProductA {23//每个产品共有的⽅法4public void shareMethod() {}5//每个产品相同⽅法,不同实现6public abstract void doSomething();78 }3. ConcreteFactory类具体⼯⼚实现类,如何创建⼀个产品是由具体的实现类来完成的。

抽象工厂设计模式

抽象工厂设计模式

抽象工厂(Abstract Factory)设计模式目的:提供一个创建一系列相关或相互依赖对象的接口,无需指定它们具体的类。

别名:Kit“抽象”来自“抽象产品角色”,而“抽象工厂”就是“抽象产品角色的工厂”。

在简单工厂中,我们的工厂类一次只可以处理一类产品。

那么如果我们想处理多类产品,简单工厂是满足不了的,必须要用抽象工厂设计模式。

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。

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

当每个抽象产品都有多于一个的具体子类的时候,工厂角色怎么知道实例化哪一个子类呢?比如每个抽象产品角色都有两个具体产品。

抽象工厂模式提供两个具体工厂角色,分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化。

每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

每一个模式都是针对一定问题的解决方案,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式针对的是多个产品等级结构。

成分:从上图可以看出,抽象工厂模式涉及到以下几类角色:1. 抽象工厂(AbstractFactory)角色:声明一个创建抽象产品对象的操作接口。

担任这个角色的是工厂方法模式的核心,它是与应用系统的商业逻辑无关的。

通常使用Java 接口或者抽象Java 类实现,而所有的具体工厂类必须实现这个Java 接口或继承这个抽象Java 类。

2. 实体工厂类(Conrete Factory)角色:这个角色直接在客户端的调用下实现创建具体产品对象的操作。

这个角色含有选择合适的产品对象的逻辑,而这个逻辑是与应用系统的商业逻辑紧密相关的。

通常使用具体Java 类实现这个角色。

3. 抽象产品(Abstract Product)角色:为一类产品对象声明一个接口。

担任这个角色的类是工厂方法模式所创建的对象的父类,或它们共同拥有的接口。

抽象工厂模式介绍

抽象工厂模式介绍

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

第6章抽象工厂模式

第6章抽象工厂模式

第6章抽象工厂模式抽象工厂模式是一种创建型设计模式,旨在提供一个创建一系列相关或相互依赖对象的接口,而无需指定具体的类。

通过使用抽象工厂模式,可以使客户端与具体实例的创建分离,降低了客户端与具体实例之间的耦合度。

本文将详细介绍抽象工厂模式的定义、结构、应用场景以及优缺点。

一、定义抽象工厂模式,也称为Kit模式,是一种对象创建型模式。

它提供一个接口,用于创建一系列具有共同接口的相关或相互依赖的对象,而无需指定其具体实现类。

二、结构抽象工厂模式包含以下几个角色:1. 抽象工厂(Abstract Factory):定义了创建产品对象的接口,它包含了一组创建产品的方法。

2. 具体工厂(Concrete Factory):实现了抽象工厂中的方法,完成具体产品的创建。

3. 抽象产品(Abstract Product):定义了产品的接口,是具体产品类的父类。

4. 具体产品(Concrete Product):实现了抽象产品接口的具体产品类。

三、应用场景抽象工厂模式通常在以下几种情况下使用:1.系统需要一系列相关或相互依赖的对象,并且不希望客户端与具体实例之间有耦合。

2.客户端不应知道所使用的具体工厂和具体产品类的名称。

3.系统需要提供一种产品的多种实现,用户可以选择使用哪个实现。

四、优缺点抽象工厂模式具有以下优点:1.将具体产品的创建与使用解耦,客户端只需要知道使用抽象工厂即可。

2.通过切换具体工厂,可以改变系统的配置,实现不同产品簇的切换。

3.新增具体工厂和具体产品类只需实现对应的接口,符合开闭原则。

抽象工厂模式的缺点是:1.当产品簇需要新增产品时,需要修改所有的具体工厂类,不符合开闭原则。

2.当具体产品较多时,会导致具体工厂类的数量增加,难以管理。

五、代码示例我们以汽车和轮胎为例,介绍抽象工厂模式的代码实现。

首先,定义抽象工厂和抽象产品的接口:```java//抽象工厂public interface AbstractFactoryCar createCar(;Tire createTire(;//抽象产品public interface Carvoid drive(;//抽象产品public interface Tirevoid rotate(;```然后,实现具体工厂和具体产品的类:```java//具体工厂public class DomesticFactory implements AbstractFactory public Car createCareturn new DomesticCar(;}public Tire createTirreturn new DomesticTire(;}//具体工厂public class ForeignFactory implements AbstractFactory public Car createCareturn new ForeignCar(;}public Tire createTirreturn new ForeignTire(;}//具体产品public class DomesticCar implements Carpublic void drivSystem.out.println("国产汽车开始启动");}//具体产品public class ForeignCar implements Carpublic void drivSystem.out.println("进口汽车开始启动");}//具体产品public class DomesticTire implements Tire public void rotatSystem.out.println("国产轮胎开始旋转");}//具体产品public class ForeignTire implements Tirepublic void rotatSystem.out.println("进口轮胎开始旋转");}```最后,客户端通过具体工厂创建具体产品:```javapublic class Clientpublic static void main(String[] args) AbstractFactory factory = new DomesticFactory(; Car car = factory.createCar(;car.drive(;Tire tire = factory.createTire(;tire.rotate(;factory = new ForeignFactory(;car = factory.createCar(;car.drive(;tire = factory.createTire(;tire.rotate(;}```运行客户端代码输出:```国产汽车开始启动国产轮胎开始旋转进口汽车开始启动进口轮胎开始旋转```通过抽象工厂模式,客户端代码无需关注具体的产品类,只需要通过工厂创建产品即可。

工厂模式简介和应用场景

工厂模式简介和应用场景

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

⼯⼚模式按照《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();}}}简单⾯馆就提供三种⾯条(产品),你说你要啥,他就给你啥。

23种设计模式的经典运用

23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。

本文将介绍23种经典的设计模式,并给出它们在实际开发中的应用示例。

通过学习这些设计模式,您将增加对软件设计的理解,并能够更好地解决问题。

创建型设计模式1.工厂方法模式(F a c t o r y M e t h o d)工厂方法模式通过定义一个创建对象的接口,但由子类决定实例化具体类。

这种方法可以延迟实例化过程,具有更高的灵活性和可扩展性。

应用场景:-在一个系统中,希望客户端与具体类的实例化解耦。

-希望通过增加具体类的扩展来增加系统的灵活性。

2.抽象工厂模式(A b s t r a c t F a c t o r y)抽象工厂模式提供一个接口,用于创建相关或依赖对象组。

这种模式将对象的实例化推迟到子类中,从而实现了解耦。

应用场景:-当一个系统独立于其产品的创建、组合和表示时。

-当需要一个系列的相互依赖的对象而无需指定其具体类时。

3.单例模式(S i n gl e t o n)单例模式确保一个类只有一个实例,并提供一个全局访问点。

这种模式常用于控制对资源的访问,例如数据库连接或日志文件。

应用场景:-当需要一个类的唯一实例,并且该实例需要被多个客户端共享时。

-当需要限制系统中特定类的实例数量时。

4.原型模式(P r o to t y p e)原型模式通过复制现有对象来创建新对象。

这种模式对于创建需要消耗大量资源的对象非常有用,可以通过克隆现有对象来提高性能。

应用场景:-当一个系统的某些对象的创建比较昂贵时。

-当需要避免构造函数调用,而直接通过复制现有对象来创建新对象时。

5.建造者模式(B ui l d e r)建造者模式将一个复杂对象的构建过程与其表现分离,使得相同的构建过程可以创建不同的表现。

应用场景:-当想要构建一些复杂对象时,如生成器。

-当需要创建对象的过程具有多个步骤,并且每个步骤都可以按需选择或省略时。

结构型设计模式6.适配器模式(A da p t e r)适配器模式将一个类的接口转换为客户端所期望的另一个接口。

23种设计模式的形象比喻

1、ABSTRACT FACTORY—追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都MM爱吃的东西,虽然口味有所不同,但不管你带MM去麦当劳或肯德基,只管向员说“来四个鸡翅”就行了。

麦当劳和肯德基就生产鸡翅的Factory工厂模式:客户类和工厂类分。

任何时候需要某种产品,只需向工厂请求即可。

无须就可以接纳新产品。

缺当产品时,工厂类也要相应的。

如:如何创建及如何向客户端。

2、BUILDER—MM听的就“爱你”这句话了,见到不同地方的MM,要能够用她们的方言跟她说这句话哦,有一个多种语言翻译机,上面每种语言都有一个按键,见到MM只要按对应的键,它就能够用相应的语言说出“爱你”这句话了,国外的MM也可以轻松搞定,这就的“爱你”builder。

(这一定比美军在伊拉克用的翻译机好)建造模式:将对象的内部表象和对象的生成过程分割来,从而使一个建造过程生成具有不同的内部表象的产品对象。

建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。

建造模式可以强制实行一种分步骤进行的建造过程。

3、FACTORY METHOD—请MM去麦当劳吃汉堡,不同的MM有不同的口味,要每个都记住一件烦人的事情,一般采用Factory Method模式,带着MM到员那儿,说“要一个汉堡”,具体要什么样的汉堡呢,让MM直接跟员说就行了。

工厂方法模式:核心工厂类不再负责所有产品的创建,而将具体创建的工作交给子类去,成为一个抽象工厂角色,仅负责给出具体工厂类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。

4、PROTOTYPE—跟MM用原始模型模式:通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。

原始模型模式允许动态的增加或减少产品类,产品类不需要非得有任何事先确定的等级结构,原始模型模式适用于任何的等级结构。

缺每一个类都必须配备一个克隆方法。

5、SINGLETON—俺有6个漂亮的老婆,她们的老公都,就们家里的老公Sigleton,她们只要说道“老公”,都指的同一个人,那就(刚才了个梦啦,哪有这么好的事)单例模式:单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统这个实例单例模式。

24种设计模式的定义和使用场合

一.创建型模式(Creational):简单工厂模式(simpleFactory)发音:['simpl] ['fækt(ə)rɪ]定义:提供一个创建对象实例的功能,而无须关心其具体实现.被创建实例的类型可以是接口,抽象类,也可以是具体的类.1.抽象工厂(AbstractFactory)发音: ['æbstrækt]定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类.使用场合:1.如果希望一个系统独立于它的产品的创建,组合和表示的时候,换句话书,希望一个系统只是知道产品的接口,而不关心实现的时候.2.如果一个系统要由多个产品系列中的一个来配置的时候.换句话说,就是可以,就是可以动态地切换产品簇的时候.3.如果强调一系列相关产品的接口,以便联合使用他们的时候2.建造者模式(Builder)发音: ['bɪldə]定义:将复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.使用场合:1.如果创建对象的算法,应该独立于该对象的组成部分以及它们的装配方式时2.如果同一个构建过程有着不同的表示时3.工厂方法模式(Factory Method)定义:为创建对象定义一个接口,让子类决定实例化哪个类.工厂方法让一个类的实例化延迟到了子类.使用场景:1.客户类不关心使用哪个具体类,只关心该接口所提供的功能.2.创建过程比较复杂,例如需要初始化其他关联的资源类,读取配置文件等.3.接口有很多具体实现或者抽象类有很多具体子类时,4.不希望给客户程序暴露过多的此类的内部结构,隐藏这些细节可以降低耦合度.5.优化性能,比如缓存大对象或者初始化比较耗时的对象.4.原型模式(Prototype Method)发音: ['prəʊtətaɪp]定义:使用原形实例指定将要创建的对象类型,通过复制这个实例创建新的对象.应用场合:1.如果一个系统想要独立于它想要使用的对象时,可以使用原型模式,让系统只面向接口编程,在系统需要新的对象的时候,可以通过克隆原型来得到.2.如果需要实例化的类是在运行时刻动态指定时,可以使用原型模式,通过克隆原型来得到需要的实例.5.单例模式(Singleton) 发音: ['sɪŋg(ə)lt(ə)n]定义:保证一个类仅有一个实例,并提供一个访问它的全局访问点.使用场合:当需要控制一个类的实例只能有一个,而且客户只能从一个全局访问点访问它时,可以使用单例模式,这些功能恰好是单例模式要解决的问题.二.结构型模式(struct)发音: [strʌkt]6.适配器模式(Adapter)发音:[ə'dæptə]定义:将一个类的接口转换成客户希望的另外一个接口.适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作.使用场合;1.如果先要使用一个已经存在的类,但是它的接口不符合你的需求,这种情况可以使用适配器模式,来把已有的实现转换成你需要的接口.2.如果你想创建一个可以复用的类,这个类可能和一些不兼容的类一起工作,这中情况可以使用适配器模式,到时候需要什么就适配什么.3.如果你想使用一些已经窜在的子类,是不坑对每一个子类都进行适配,这中情况可以使用适配器模式,直接适配这些子类的父类就可以了.7.桥接模式(Bridge)发音: [brɪdʒ]定义:将抽象部分与它的实现部分分离,使他们可以独立变化.使用场合:1.如果你不希望在抽象部分和实现部分采用固定的绑定关系,可以采用桥接模式.2.如果出现抽象部分和实现部分都能够扩展的情况,可以采用桥接模式,让抽象部分和实现部分独立地变化.3.如果希望实现部分的修改不会对客户产生影响,可以采用桥接模式.4.如果采用继承的实现方案,会导致产生很多子类,对于这种情况,可以考虑采用桥接模式.8.组合模式(Composite)发音: ['kɒmpəzɪt]定义:将对象组合成属性结构以表示"部分-整体"的层次结构,组合模式使用的用户对单个对象和组合对象的使用具有一致性.使用场合:1.如果你想表示对象的部分-整体层次结构,可以使用..把整体和部分的操作统一起来,使得层次结构实现更简单,从外部来使用,这个层次结构也容易.2.如果希望同意地使用组合结构中的所有对象,可以选用...,这正是组合模式提供的主要功能.9.装饰器模式(Decorator Method)发音: ['dekəreɪtə]定义:动态的给一个对象增加一些额外的职责,就增加功能来说,装饰模式生成子类更为灵活.使用场合:1.如果需要爱不影响其他对象的情况下,以动态,透明的方式给对象添加职责,可以使用装饰模式.2.如果不适合使用子类来进行扩展的时候,可以考虑使用装饰模式.10.外观模式(Facade)发音: [fə'sɑ:d]定义:为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层的接口,这个接口使得这一子系统更加同容易使用.使用场景:1.如果希望为一个复杂的子系统提供一个简单接口的时候,可以考虑使用外观模式.使用外观对象来实现大部分客户需要的功能,从而简化客户的使用.2.如果想要让客户程序和抽象类的实现部分松散耦合,可以考虑使用外观模式,使用外观对象来将这个子系统与他的客户分离开来,从而提高子系统的独立性和可移植性.3.如果构建多层节后的系统,可以考虑使用外观模式使用外观模式对象作为每层的入口,这样可以简化层间调用,也可以松散出层次之间的依赖关系.11.享元模式(Flyweight)发音: ['flaɪweɪt]定义:运用共享技术有效地支持大量细粒度的对象.使用场合:1.如果一个应用程序使用了大量的细粒度对象,可以使用享元模式来减少对象的数量.2.如果犹豫使用大量的对象,造成很大的存储开销,可以使用享元模式来减少对象数量,并节约内存.3.如果对象的大多数状态都可以转变成外部状态,比如通过计算得到,或者从外部传入等,可以使用享元模式来实现内部状态和外部状态的分离.4.如果不考虑对象的外部状态,可以用相对较少的共享对象取代很多组合对象,可以使用享元模式来共享对象.然后组合对象来使用这些共享对象.12.代理模式(Proxy)发音: ['prɒksɪ]定义:为其他对象提供一种代理以控制对这个对象的访问.使用场合:1.需要为一个对象在不同的地址空间提供局部代表的时候,可以使用远程代理.2.需要按照需要创建开销很大的对象的时候,可以使用虚代理.3.需要控制对原始对象的访问的时候,可以使用保护代理.4.需要在访问你对象执行一些附加操作的时候,可以使用智能指引代理.三.行为型模式(behavioral)发音[bi'heivjərəl]13.职责链模式(Chain Of Responsibility)发音: [tʃeɪn] [rɪ,spɒnsɪ'bɪlɪtɪ]定义:使多个对象都有机会处理请求,,从而避免请求的发送者和接收者之间耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止.使用场合:1.如果有多个对象可以处理同一个请求,但是具体由哪个对象来处理该请求,是运行时刻动态确定的.2.如果你想在不明确指定接收者的情况下,向多个对象中的其中一个提交请求的话,可以使用职责链模式.3.如果想要动态指定处理一个请求的对象结合,可以使用职责链模式.14.命令模式(Command)发音: [kə'mɑːnd]定义:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或者记录请求日志,以及支持可撤销的操作.15.解释器模式(Interpreter)发音: [ɪn'tɜːprɪtə]定义:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子.使用场合:16.迭代器模式(Iterator)定义:提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示.使用场合:1.如果你希望提供访问一个聚合对象的内容,但是又不想暴露他的内部表示的时候,可以使用迭代器模式来提供迭代器接口,从而让客户端只是通过迭代器的接口来访问聚合对象,而无须关心聚合对象的内部实现.2.如果你希望有多种遍历方式可以访问聚合对象,可以使用...3.如果你希望为遍历不同的聚合对象提供一个统一的接口,可以使用....17.中介模式(Mediator) 发音:['mi:dieitə]定义:用一个中介对象类封装一系列对象的交互.中介者使得各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互.使用场合:1.如果一组对象之间的通信方式比较复杂,导致相互依赖,结构混乱,可以采用中介模式,把这些对象相互的交互管理起来,各个对象都只需要和中介者交互,从而是的各个对象松散耦合,结构也更清晰易懂.2.如果一个对象引用很多的对象,并直接跟这些对象交互,导致难以复用该对象,可以采用中介者模式,把这个对象跟其他对象的交互封装到中介者对象里面,这个对象只需要和中介者对象交互就可了.18.备忘录模式(Memento)发音: [mɪ'mentəʊ]在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态.使用场合:1.如果必须要保存一个对象在某一个时刻的全部或者部分状态,方便以后需要的时候,可以把该对象恢复到先前的状态,可以使用备忘录模式.2.如果需要保存一个对象的内部状态,但是如果用接口来让其他对象直接得到这些需要保存的状态,将会暴露对象的实现希捷并破坏对象的封装性,这是可以使用备忘录.19.观察者模式(Observer)发音: [əb'zɜːvə]定义:定义对象间的一种一对多的依赖关系.当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新.使用场合;1.当一个抽象模型有两个方面,其中一个方面的操作依赖于另一个方面的状态变化,那么就可以选用观察者模式,将这两者封装成观察者和目标对象,当目标对象变化的时候,依赖于它的观察者对象也会发生相应的变化.这样就把抽象模型的这两个方面分离了使得,它们可以独立地改变和复用.2.如果在更改一个对象的时候,需要同时连带改变其他对象,而且不知道究竟应该有多少对象需要被连带改变,这种情况可以选用观察者模式,被改的那一个对象很明显就相当于是目标对象,而需要连带修改的对歌其他对象,就作为多个观察着对象了.3.当一个对象必须通知其他的对象,但是你又希望这个对象和其他被它通知的对象是松散耦合的,也就是说这个对象其实不详知道具体被通知的对象.这种情况可以选用观察者模式,这个对象就相当于是目标对象,而被它通知的对象就是观察者对象了.20.状态模式(State)发音: [steɪt]允许一个对象在其内部状态改变是改变它的行为.对象看起来似乎修改了他的类.使用场合:1.如果一个对象的行为取决于它的状态,而且它必须在运行时刻根据状态来改变它的行为,可以使用...来包状态和行为分离开.虽然分离了,但是状态和行为是有对应关系的,可以在运行期间,通过改变状态,就能够调用到该状态对应的状态处理对象上去从而改变对象的行为.2.如果一个操作中含有庞大的多分枝语句,而且这些分支依赖于该对象的状态,可以使用....把各个分支的处理分散包装到单独的对象处理类中,这样,这些分支对应的对象就可以不依赖于其他对象而独立变化了.21.策略模式(Strategy)发音: ['strætɪdʒɪ]定义:定义一系列的算法,把它们一个个封装起来,并且使他们可以相互替换.本模式使得算法可独立于使用它的客户而变化.使用场合;1.出现有许多相关的类,仅仅是行为有差别的情况下,可以使用策略模式来使用多个行为中的一个来配置一个类的方法,实现算法动态切换2.出现同一算法,有很多不同实现的情况下,可以使用策略模式来把这些"不同的实现"实现成为一个算法的类层次.3.需要封装算法中,有与算法相关数据的情况下,可以使用策略模式来避免暴露这些跟算法相关的数据结构.4.出现抽象一个定义了很多行为的类,并且是通过多个if-else语句来选择这些行为的情况下,可以使用策略模式来替换这些条件语句.22.模版方法模式(Template Method)发音:['templeɪt; -plɪt]定义:定义在一个操作中的算法框架,把一些步骤推迟到子类去实现.模版方法模式让子类不需要改变算法的结构而重新定义特定的算法步骤功能:1.能够解决代码的冗余问题2.把某些算法步骤延迟到子类3.易于扩展4.父类提供了算法框架,控制了算法的执行流程,而子类不能改变算法的流程,子类的方法的调用由父类的模版方法决定.5.父类可以把那些重要的,不允许改变的方法屏蔽掉,不让子类去复写他们.1.需要固定定义算法骨架,实现一个算法的不变的部分,并把可变的行为留给子类来实现的情况.2.各个子类中具有公共行为,应该抽取出来,集中在一个公共类中去实现,从而避免复杂的代码重复3.需要控制子类扩展的情况.模版方法模式会在特定的点来调用子类的方法,这样只允许在这些点进行扩展.知识:回调:表示一段可执行逻辑的引用(或者指针),我们把该引用(或者指针)传递到另外一段逻辑(或者方法)里供这段逻辑适时调用(网站:)23.访问者模式(Visitor)发音:['vɪzɪtə]定义:表示一个作用于某对象结构中的各个元素的操作.它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作.使用场合:1.如果想对一个对象结构实施一些依赖于对象结构中具体类的操作,可以使用访问者模式.2.如果想对一个对象结构中的各个元素进行很多不同的而且不相关的操作,为了避免这些操作使类变得杂乱,可以使用访问者模式.3.如果对象结构很少变动,但是需要经常给对象结构中的元素定义新的操作,可以使用访问者模式.3.如果对象结构很少变动,但是需要经常给对象结构中的元素定义新的操作,可以使用访问者模式.。

php设计模式之抽象工厂模式

php设计模式之抽象⼯⼚模式抽象⼯⼚模式(Abstact Factory)是⼀种常见的软件设计模式。

该模式为⼀个产品族提供了统⼀的创建接⼝。

当需要这个产品族的某⼀系列的时候,可以为此系列的产品族创建⼀个具体的⼯⼚类。

⼀、意图抽象⼯⼚模式提供⼀个创建⼀系统相关或相互依赖对象的接⼝,⽽⽆需指定它们具体的类【GOF95】⼆、抽象⼯⼚模式结构图三、结合⼀个简单的例⼦了解⽤种蔬菜的例⼦来说明事实,最初的时候,由于规模⼩,只种植⼀种蔬菜,根菜类蔬菜,这个时候由于种植⽅式⽐较简单,采⽤简单⼯⼚模式即可,主要⽬的是让⼯⼈轻松,下达⼯⼚种植即可,但是随着种植⼚的发展以及市场的需求,要增加⼀种蔬菜类型种植了,茎菜,由于茎菜与根菜种植⽅式不⼀致,就需要两个专门的种植⼯⼚来进⾏管理,那么久采⽤⼯⼚模式来管理,⼀个⼯⼚负责⼀种作物的种植,这个时候产品可以理解为仍然在⼀个层次。

但是随着科技的发展,我们逐步要种植转基因与⾮转基因⾷品了,在以前的蔬菜种类上⼜增加了⼀个层次,这个时候⽆法将其作为⼀个层次来解决,所以必须采⽤抽象⼯⼚的⽅式来解决。

我⽤UML图表⽰三种结构:上⾯的UML图很明显的就看出来了,抽象⼯⼚可以创建多个产品类对象,如在种菜⼯⼚中,有种根菜,种茎菜。

⼯⼚模式与抽象⼯⼚模式以及简单⼯⼚模式只有在具体应⽤的时候,分析具体的产品层级,然后选择相应的设计模式。

⽽在每⼀个层次,种菜⼯⼈所关⼼的对象也不⼀样,在简单⼯⼚模式下,⼯⼈要想到种植萝⼘还是⽩菜,在⼯⼚模式下,⼯⼈想到是种植根菜还是茎菜,⽽在抽象⼯⼚模式下,则关⼼种植基因菜还是⾮基因菜四、抽象⼯⼚模式中主要⾓⾊抽象⼯⼚(Abstract Factory)⾓⾊:它声明⼀个创建抽象产品对象的接⼝。

通常以接⼝或抽象类实现,所有的具体⼯⼚类必须实现这个接⼝或继承这个类。

具体⼯⼚(Concrete Factory)⾓⾊:实现创建产品对象的操作。

客户端直接调⽤这个⾓⾊创建产品的实例。

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

设计模式-快餐简解-【抽象工厂模式】佚名2008-11-13【抽象工厂模式应用场景举例】写到抽象工厂模式了,我深知“抽象工厂模式”博文会带来一点点高潮,因为程序员对工厂模式中的“抽象工厂”都是比较感冒的,而且关注也很多,我就尽量用我所能理解的那么点程度来给大家介绍这个模式,如果有更好的比喻还请网友指正,先感谢了!设计模式-快餐简解-【工厂方法模式】介绍了工厂方法的使用,从那个程序中可以看到,奥迪audi车是从audi_car_factory_imple工厂中创建出来的,而大众3W车是从 threeW_car_factory_imple工厂中创建出来的,那么如果这2家汽车生产大厂由总部在北京市,现在发展到上海,深圳等城市创建生气汽车的分厂,该怎么办?是不是得将原来的奥迪汽车工厂类:public class audi_car_factory_imple implements Icar_factory {public Icar_interface create_car() {car_audi_imple car_audi_imple_ref = new car_audi_imple();car_audi_imple_ref.setName("奥迪A6");car_audi_imple_ref.setSpeed(300);return car_audi_imple_ref;}}改成类似如下的模样:public class audi_car_factory_imple implements Icar_factory {public Icar_interface create_car(String area_car) {if (area_car.equals("北京")){创建一个北京的奥迪汽车}if (area_car.equals("上海")){创建一个上海的奥迪汽车}if (area_car.equals("深圳")){创建一个深圳的奥迪汽车}return car_audi_imple_ref;}}那么发现一个问题,不同地域的汽车却在一个工厂中出现,这是不合乎常理的,因为北京奥迪在北京分厂创建,上海奥迪在上海分厂创建,这样才对。

所以如果遇到分“大系”来创建对象的时候,抽象工厂方法是肯定要使用的时候了。

这里的大系指的就是从地域上来分。

这个例子就应该以“用抽象工厂来定义具体工厂的抽象,而由具体工厂来创建对象”比如在玩“极品飞车”这款游戏,每个地图处都有造车的工厂,每个造车的工厂都因为有造车的档次不同而划分为高级车厂,低级车厂,那么这样的场景正是应用抽象工厂的好时机,再来理解一下这句话“用抽象工厂来定义具体工厂的抽象,而由具体工厂来创建对象”,用抽象造车工厂来定义具体造车工厂的抽象,而由具体的造车工厂来创建汽车,这就是抽象工厂与工厂方法的不同,工厂方法中对象的创建是由工厂方法来确定的,创建的对象都是不分类并且实现一个接口的,而抽象工厂就是在工厂方法的基础上对创建车的对象的行为进行分类,比如北京车厂,上海车厂等。

【抽象工厂模式解释】类型:创建模式提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。

【抽象工厂模式UML图】【抽象工厂模式-JAVA代码实现】新建抽象工厂接口:package car_factory_interface;import car_interface.Icar_interface;public interface Icar_factory {public Icar_interface create_threeW_car();public Icar_interface create_audi_car();}新建抽象工厂接口的高级车adv工厂实现类:package car_factory_imple;import car_factory_interface.Icar_factory;import car_imple.car_3w_imple_adv;import car_imple.car_audi_imple_adv;import car_interface.Icar_interface;public class car_factory_adv implements Icar_factory {public Icar_interface create_audi_car() {car_audi_imple_adv car_audi_imple_adv = new car_audi_imple_adv();car_audi_imple_adv.setName("奥迪A6");car_audi_imple_adv.setSpeed(300);return car_audi_imple_adv;}public Icar_interface create_threeW_car() {car_3w_imple_adv car_3w_imple_adv_ref = new car_3w_imple_adv();car_3w_imple_adv_ref.setName("大众A6");car_3w_imple_adv_ref.setSpeed(300);return car_3w_imple_adv_ref;}}新建抽象工厂接口的普通车low工厂实现类:package car_factory_imple;import car_factory_interface.Icar_factory;import car_imple.car_3w_imple_low;import car_imple.car_audi_imple_low;import car_interface.Icar_interface;public class car_factory_low implements Icar_factory {public Icar_interface create_audi_car() {car_audi_imple_low car_audi_imple_low_ref = new car_audi_imple_low(); car_audi_imple_low_ref.setName("奥迪A6");car_audi_imple_low_ref.setSpeed(300);return car_audi_imple_low_ref;}public Icar_interface create_threeW_car() {car_3w_imple_low car_3w_imple_low_ref = new car_3w_imple_low(); car_3w_imple_low_ref.setName("大众A6");car_3w_imple_low_ref.setSpeed(300);return car_3w_imple_low_ref;}}上面已经有抽象工厂和具体工厂的实现类了。

新建汽车接口:package car_interface;public interface Icar_interface {public void start();public void stop();}新建汽车父类:package car_imple;import car_interface.Icar_interface;public class base_car_imple implements Icar_interface {private int speed;private String name;public int getSpeed() {return speed;}public void setSpeed(int speed) {this.speed = speed;}public String getName() {return name;}public void setName(String name) { = name;}public void start() {// TODO Auto-generated method stub}public void stop() {// TODO Auto-generated method stub}}新建大众高级车:package car_imple;import car_interface.Icar_interface;public class car_3w_imple_adv extends base_car_imple {public void start() {System.out.println("富华版:" + this.getName() + " 车以专利技术起动了最高速度为:"+ this.getSpeed());}public void stop() {System.out.println("富华版:" + this.getName() + " 车以专利技术停车了");}}新建大众普通车:package car_imple;import car_interface.Icar_interface;public class car_3w_imple_low extends base_car_imple {public void start() {System.out.println("普通版:" + this.getName() + " 车以专利技术起动了最高速度为:"+ this.getSpeed());}public void stop() {System.out.println("普通版:" + this.getName() + " 车以专利技术停车了");}}新建大众普通车:package car_imple;import car_interface.Icar_interface;public class car_audi_imple_adv extends base_car_imple {public void start() {System.out.println("富华版:" + this.getName() + " 车以专利技术起动了最高速度为:"+ this.getSpeed());}public void stop() {System.out.println("富华版:" + this.getName() + " 车以专利技术停车了");}}新建奥迪普通车:package car_imple;import car_interface.Icar_interface;public class car_audi_imple_low extends base_car_imple {public void start() {System.out.println("普通版:" + this.getName() + " 车以专利技术起动了最高速度为:"+ this.getSpeed());}public void stop() {System.out.println("普通版:" + this.getName() + " 车以专利技术停车了");}}新建客户端运行类:package run_main;import car_factory_imple.car_factory_adv;import car_factory_interface.Icar_factory;import car_interface.Icar_interface;public class run_main {public static void main(String[] args) {Icar_factory Icar_factory_ref = new car_factory_adv();Icar_interface Icar_interface_ref = Icar_factory_ref.create_threeW_car();Icar_interface_ref.start();Icar_interface_ref.stop();}}程序运行结果如下:富华版:大众A6 车以专利技术起动了最高速度为:300富华版:大众A6 车以专利技术停车了抓一篇阎宏的小文字:一开始只在后花园中种蔬菜类的时候可以用简单工厂模式,由工厂负责生成具体的蔬菜类,但是如果后花园要引进水果类的时候简单模式就行不通了,因此需要使用工厂方法模式,将产品类族分开。

相关文档
最新文档