L08B-抽象工厂模式 ppt课件
抽象工厂模式
抽象⼯⼚模式9.1 ⼥娲的失误我们在上⼀章节讲了⼥娲造⼈的故事。
⼈是造出来了,世界也热闹了,可是低头⼀看,都是清⼀⾊的类型,缺少关爱、仇恨、喜怒哀乐等情绪,⼈类的⽣命太平淡了,⼥娲⼀想,猛然⼀拍脑袋,哇K!忘记给⼈类定义性别了,那怎么办?抹掉重来,于是⼈类经过⼀次⼤洗礼,所有的⼈种都消灭掉了,世界⼜是空⽆⼀物,寂静⽽⼜寂寞。
由于⼥娲之前的准备⼯作花费了⾮常⼤的精⼒,⽐如准备黄⼟,准备⼋卦炉等,从头开始建⽴所有的事物也是不可能的,那就想在现有的条件下重新造⼈,尽可能旧物利⽤嘛。
先说⼈种(Product产品类)应该怎么改造呢?怎么才能让⼈类有爱有恨呢?是神仙当然办法的了,定义互斥的性别,然后在每个个体中埋下⼀颗种⼦:异性相吸,成熟后就⼀定会去找个异性(这就是我们说的爱情原动⼒)。
从设计⾓度来看,⼀个具体的对象通过两个坐标就可以确定:肤⾊和性别,如图9-1所⽰。
图9-1 肤⾊性别坐标图产品类分析完毕了,⽣产的⼯⼚类该(⼋卦炉)怎么改造呢?只有⼀个⽣产设备,要么⽣产出全都是男性,要么都是⼥性,那不⾏呀,这么⼤的翻天覆地的改造就是为了产⽣不同性别的⼈类。
有办法了!把⽬前已经有的⽣产设备——⼋卦炉拆开,于是⼥娲就使⽤了“⼋卦拷贝术”,把原先的⼋卦炉⼀个变两个,并且略加修改,就成了⼥性⼋卦炉(只⽣产⼥性⼈种)和男性⼋卦炉(只⽣产男性⼈种),于是乎⼥娲就开始准备⽣产了,其类图如图9-2所⽰。
图9-2 ⼥娲重新⽣产⼈类这个类图虽然⼤,但是⽐较简单,Java的典型类图,⼀个接⼝,多个抽象类,然后是N个实现类,每个⼈种都是⼀个抽象类,性别是在各个实现类中实现的。
特别需要说明的是HumanFactory接⼝,在这个接⼝中定义了三个⽅法,分别⽤来⽣产三个不同肤⾊的⼈种,也就是我们在图9-1中的Y坐标,它的两个实现类分别是性别,也就是图9-1中的X坐标,通过X坐标(性别)和Y坐标(肤⾊)唯⼀确定了⼀个⽣产出来的对象:什么性别的⼈种。
抽象工厂模式
抽象工厂模式是一种面向对象的软件设计模式,它主要用于解决软件系统中对象的创建问题。
该模式提供了一种创建一系列相关或相互依赖对象的接口,而不需要指定其具体类。
一、定义是一种接口工厂模式,它提供了一个用于创建一系列相关或相互依赖对象的接口,而不需要指定其具体类。
通常涉及到两个或多个抽象类,每个抽象类可以派生出多个具体类。
在中,客户端通过调用工厂对象的方法来创建各种不同类的对象,而这些对象都是由同一个工厂对象创建的。
二、结构1. 抽象工厂类:定义了一个创建一系列产品(如汽车,颜色等)的方法接口。
2. 具体工厂类:实现了抽象工厂类中的方法,用于创建一系列相关或相互依赖的对象。
3. 抽象产品类:定义了一系列产品的公共接口。
4. 具体产品类:实现了抽象产品类中定义的接口,是一系列具体产品的实例。
三、优点1. 将客户端与类的实现分离,客户端只需要知道抽象工厂和抽象产品类,而不需要知道具体的实现类。
2. 应对复杂的产品结构,只需要增加一个新的具体工厂类即可。
3. 方便替换产品系列,只需要更改具体工厂类即可。
四、缺点1. 系统扩展困难,增加新产品时,需要增加新的抽象产品类和具体产品类。
2. 通常在产品族中增加新的产品比较困难,如果需要增加一个新的产品族,则需要修改抽象工厂和所有具体工厂类。
五、使用场景1. 需要一个产品系列,并且需要确保这些产品系列是相关的。
2. 当需要实现一个产品族而不需要知道具体实现时。
3. 当需要一个对象而不知道如何创建它的具体类型(即抽象工厂)时。
六、代码示例以下是一个简单的的示例代码:```pythonclass AbstractFactory:def create_car(self):passdef create_color(self):passclass BenzFactory(AbstractFactory): def create_car(self):return BenzCar()def create_color(self):return RedColor()class BmwFactory(AbstractFactory): def create_car(self):return BmwCar()def create_color(self):return BlueColor()class AbstractCar:def drive(self):passclass BenzCar(AbstractCar):def drive(self):print("Driving Benz car")class BmwCar(AbstractCar): def drive(self):print("Driving BMW car")class AbstractColor:def color(self):passclass RedColor(AbstractColor): def color(self):print("Car color is red")class BlueColor(AbstractColor): def color(self):print("Car color is blue")def test(factory):car = factory.create_car()color = factory.create_color() car.drive()color.color()if __name__ == '__main__':test(BenzFactory())test(BmwFactory())```该示例代码中,我们定义了一个抽象工厂类`AbstractFactory`、两个具体工厂类`BenzFactory`、`BmwFactory`、一个抽象产品类`AbstractCar`、两个具体产品类`BenzCar`、`BmwCar`、一个抽象产品类`AbstractColor`、两个具体产品类`RedColor`、`BlueColor`。
深入浅出讲解设计模式中的工厂模式幻灯片PPT
计算机工程技术学院
设计模式之--简单工厂模式
追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM 爱吃的东西,虽然口味有所不同,但不管你带MM去麦当劳或 肯德基,只管向服务员说“来四个鸡翅”就行。麦当劳和肯德 基就是生产鸡翅的Factory。
计算机工程技术学院
设计模式之--简单工厂模式
话说乾隆皇帝酷爱古董文物,大贪官和申当然不会放过这个溜 须拍马的好机会,但是苦于他自己不懂文物,也没有时间亲自 去收集鉴别,所以干脆私下里成立了一个衙门叫做文物管理局, 负责给他收集天下的古董文物。他什么时候想要只需一句话, “来一件XXX”,一件文物就到他手里了。 看出点名堂了吧,我们的和中堂要是在现代可是设计模式高手 哦。这就是简单工厂模式了。 文物管理局就是工厂,青铜器、字画、瓷器都是具体产品,客 户端当然是和申了,他不需要亲自创建这些产品,需要的时候 给工厂招呼一声就是了,虽然他不懂也没有时间去研究这些产 品(当官就是好啊,呵呵)。下面看看代码吧:
计算机工程技术学院
设计模式之--简单工厂模式
client FuitGardener +factory:Fruit
Interface Fruit
+grow:void +harvest:void +plant:void
Grape
+grow:void +harvest:void +plant:void
Seedless:boolen
+Factory: IAntique
瓷器司
水墨司
青铜司
+Factory: IAntique
+Factory: IAntique
+Factory: IAntique
抽象工厂模式介绍
抽象工厂模式介绍抽象工厂模式是一种软件设计模式,它提供了一种创建一系列相互关联或依赖的对象的方法,而无需指定具体实现类。
该模式的核心思想是将对象的创建和使用分离,从而在系统设计中提供更高的灵活性和可扩展性。
抽象工厂模式基于工厂方法模式,它将工厂抽象化,允许客户端使用抽象工厂来创建一系列相关或依赖的对象,而不必关心具体的实现类。
通过使用抽象工厂模式,我们可以使系统更易于扩展和修改,满足不同的需求和变化。
抽象工厂模式的结构包括抽象工厂、具体工厂、抽象产品和具体产品。
抽象工厂定义了创建一系列相关或依赖对象的方法,具体工厂实现了这些方法。
抽象产品定义了一系列相关产品的接口,具体产品实现了这些接口。
通过抽象工厂和具体产品的组合,我们可以创建一系列具有关联性的对象。
抽象工厂模式的使用可以带来多种好处。
首先,它可以提供系统的灵活性。
由于抽象工厂将对象的创建和使用分离,我们可以很容易地替换具体的工厂实现,从而满足不同的需求和变化。
其次,它可以提供系统的可扩展性。
通过增加新的具体工厂和产品实现,我们可以方便地扩展系统的功能。
再次,它可以提供系统的可维护性。
由于抽象工厂模式将创建对象的代码集中于一个工厂类中,我们可以更容易地维护和修改代码。
最后,它可以提供系统的解耦性。
客户端只需要与抽象工厂和抽象产品进行交互,不需要了解具体产品的实现细节,从而降低了系统的耦合度。
抽象工厂模式的应用场景较为广泛。
一种常见的应用场景是在需要创建一系列相互依赖的对象的时候。
比如,在一个图形界面应用程序中,需要创建一系列按钮和文本框,它们都依赖于同一个主题。
通过使用抽象工厂模式,我们可以创建具有相同主题的按钮和文本框,保持它们的外观风格一致。
另一个应用场景是在需要创建一系列相关产品族的时候。
比如,在一个汽车制造系统中,需要生产不同品牌和型号的汽车,每个品牌和型号都由相应的零部件组成。
通过使用抽象工厂模式,我们可以为每个品牌和型号创建对应的汽车工厂和零部件工厂,从而保证汽车的组装作业能够顺利进行。
第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(;}```运行客户端代码输出:```国产汽车开始启动国产轮胎开始旋转进口汽车开始启动进口轮胎开始旋转```通过抽象工厂模式,客户端代码无需关注具体的产品类,只需要通过工厂创建产品即可。
L09B抽象工厂模式
源代码
下面给出这个系统所有的源代码。 首先给出工厂角色的源代码,可以看出,抽象工厂角色规定出两个工厂方法,分别 提供两个不同等级结构的产品对象。 代码清单1:抽象产品角色的源代 package com.javapatterns.abstractfactory; public interface Creator { /** * 产品等级结构A 的工厂方法 */ public ProductA factoryA(); /** * 产品等级结构B 的工厂方法 */ public ProductB factoryB(); }
可以看出,一个工厂等级结构可以创建出分属于不同产品等级结构的一 个产品族中的所有对象;显然,这时候抽象工厂模式比工厂方法模式更 有效率。如果使用相图来描述的话,就如下面的类图所示。 可以看出,对应于每一个产品族都有一个具体工厂。而每一个具体工厂 负责创建属于同一个产品族、但是分属于不同等级结构的产品。
产品对象的创建问题:
通过使用抽象工厂模式,可以处理具有相同(或者相似)等级结构的多 个产品族中的产品对象创建问题。比如下面就是两个具有相同等级结构 的产品等级结构A 和产品等级结构B 的结构图。
如果使用相图描述的话,会看到在相图上出现两个等级结构A 和B,以 及两个产品族1 和2。如下图所示。 在下面的相图中,每一个坐标点都代表一个具体产品角色。
下面是产品等级结构B 的抽象产品角色,这个抽象产品角色也是由一个Java 接 口实现的。 代码清单7:抽象产品角色ProductB 的源代码 package com.javapatterns.abstractfactory; public interface ProductB { } 下面是属于产品等级结构B 的具体产品类ProductB1 的源代码。这个具体产品实 现了产品等级结构B 的抽象产品接口。 代码清单8:具体产品类ProductB1 的源代码 package com.javapatterns.abstractfactory; public class ProductB1 implements ProductB { /** * 构造子 */ public ProductB1() { } }
抽象工厂模式(PPT31页)-文档资料
Button
Text
一个产品族 产品等级结构
抽象工厂模式
模式分析
抽象工厂模式
模式分析
✓ 抽象工厂类的典型代码如下:
public abstract class AbstractFactory {
public abstract AbstractProductA createProductA(); public abstract AbstractProductB createProductB(); }
抽象工厂模式
模式实例与解析
✓ 实例一:电器工厂
抽象工厂模式
模式实例与解析
✓ 实例一:电器工厂
• 参考代码 (Chapter 06 Abstract Factory\sample01)
演示……
抽象工厂模式
模式实例与解析
✓ 实例二:数据库操作工厂
• 某系统为了改进数据库操作的性能,自定义数据库连接对象 Connection和语句对象Statement,可针对不同类型的数据库提 供不同的连接对象和语句对象,如提供Oracle或SQL Server专用 连接类和语句类,而且用户可以通过配置文件等方式根据实际 需要动态更换系统数据库。使用抽象工厂模式设计该系统。
模式分析
Button
Text
UnixButton LinuxButton WindowsButton
UnixText LinuxText WindowsText
抽象工厂模式
模式分析
产品族
Windows WindowsButton WindowsText
Unix Linux
UnixButton LinuxButton
而使客户端不依赖于具体实现。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
• 下图则给出了多个相平行的产品等级结构的例子。
产品族
• 为了方便引进抽象工厂模式,特地引进一个新的概念:产品族(Product Family)。所谓产品族,是指位于不同产品等级结构中,功能相关联的产 品组成的家族。比如在下图中,箭头所指就是三个功能相关联的产品,它 们位于三个不同的等级结构中的相同位置上,组成一个产品族。
•
一般而言,有多少个产品等级结构,在工厂角色中就有对应个数的个工厂方 法。每一个产品等级结构中有多少具体产品,就有多少个产品族,也就会在 工厂等级结构中发现多少个具体工厂。 • 下面给出具体工厂角色ConcreteCreator2 的源代码。这个具体工厂类实现 了抽象工厂角色所要求的两个工厂方法,分别提供两个产品等级结构中的另 一个产品对象。 代码清单3:具体工厂类ConcreteCreator2 的源代码 public class ConcreteCreator2 implements Creator { /** * 产品等级结构A 的工厂方法*/ public ProductA factoryA() { return new ProductA2();} /** * 产品等级结构B 的工厂方法*/ public ProductB factoryB() { return new ProductB2();} }
源代码
• 下面给出这个系统所有的源代码。 首先给出工厂角色的源代码,可以看出,抽象工厂角色规定出两个工厂方法, 分别提供两个不同等级结构的产品对象。 代码清单1:抽象产品角色的源代 public interface Creator { /** * 产品等级结构A 的工厂方法 */ public ProductA factoryA(); /** * 产品等级结构B 的工厂方法 */ public ProductB factoryB(); }
• 系统对产品对象的创建需求由一个工厂的等级结构满足;其 中有两个具体工厂角色,即UnixFactory 和WinFactory。其 中UnixFactory 对象负责创建Unix 产品族中的产品,而 WinFactory 对象负责创建Windows 产品族中的产品。这就 是抽象工厂模式的应用,抽象工厂模式的解决方案如下图所 示。
• •
下面是产品等级结构B 的抽象产品角色,这个抽象产品角色也是由一个Java 接 口实现的。 代码清单7:抽象产品角色ProductB 的源代码
public interface ProductB { }
• 下面是属于产品等级结构B 的具体产品类ProductB1 的源代码。这个具体产品实 现了产品等级结构B 的抽象产品接口。 代码清单8:具体产品类ProductB1 的源代码
public class ProductB2 implements ProductB { /** * 构造函数 */ public ProductB2() { } }
在什么情形下应当使用抽象工厂模式
• 文献[GOF95]指出,在以下情况下应当考虑使用抽 象工厂模式: (1)一个系统不应当依赖于产品类实例如何被创建、 组合和表达的细节。这对于所有形态的工厂模式都 是重要的; (2)这个系统的产品有多于一个的产品族,而系统 只消费其中某一族的产品; (3)同属于同一个产品族的产品是在一起使用的, 这一约束必须要在系统的设计中体现出来;
代码清单4:下面是产品等级结构A 的源代码 public interface ProductA { }
• 下面是属于产品等级结构A 的具体产品类ProductA1 的源代码。这个具 体产品实现了产品等级结构A 的抽象产品接口。 • 代码清单5:具体产品类ProductA1 的源代码 public class ProductA1 implements ProductA { public ProductA1() { } } • 下面是同样属于产品等级结构A 的具体产品类ProductA2 的源代码。这 个具体产品也实现了产品等级结构A 的抽象产品接口。 • 代码清单6:具体产品类ProductA2 的源代码 public class ProductA2 implements ProductA { public ProductA2() {} }
例:
• abstract class Button { public abstract void paint(); } • class WinButton extends Button { public void paint() { System.out.println("I'm a WinButton"); } } • class OSXButton extends Button { public void paint() { System.out.println("I'm an OSXButton"); }}
• 如果使用坐标图描述的话,会看到在图上出现两个等级结构 A 和B,以及两个产品族1 和2。如下图所示。 • 在下面的图中,每一个坐标点都代表一个具体产品角色。
• 如果使用工厂方法模式处理的话,就必须要有两个独立的工 厂族。由于这两个产品族的等级结构相同,因此,使用同一 个工厂族也可以处理这两个产品族的创建问题。后者就是抽 象工厂模式,这样根据产品角色的结构图,就不难给出工厂 角色的结构设计图,如下图所示。
抽象工厂模式的应用
• 抽象工厂模式的起源或者说最早的应用,是用于创建分属于 不同操作系统的视窗构件。比如,命令按键(Button)与文 字框(Text)都是视窗构件,在UNIX 操作系统的视窗环境 和Windows 操作系统的视窗环境中,这两个构件有不同的 本地实现,它们的细节也有所不同。 • 在每一个操作系统中,都有一个视窗构件组成的构件家族。 在这里就是Button 和Text组成的产品族。而每一个视窗构件 都构成自己的等级结构,由一个抽象角色给出抽象的功能描 述,而由具体子类给出不同操作系统下的具体实现,如下图 所示。
•
下面给出具体工厂角色ConcreteCreator1 的源代码。这个具体工厂类实现了抽 象工厂角色所要求的两个工厂方法,分别提供两个产品等级结构中的某一个产品 对象。 代码清单2:具体工厂类ConcreteCreator1 的源代码
public class ConcreteCreator1 implements Creator { /** * 产品等级结构A 的工厂方法 */ public ProductA factoryA() { return new ProductA1();} /** * 产品等级结构B 的工厂方法 */ public ProductB factoryB() { return new ProductB1();} }
引进抽象工厂模式
• 上面所给出的三个不同的等级结构具有平行的结构。因此, 如果采用工厂方法模式,就势必要使用三个独立的工厂等级 结构来对付这三个产品等级结构。由于这三个产品等级结构 的相似性,会导致三个平行的工厂等级结构。随着产品等级 结构的数目增加,工厂方法模式所给出的工厂等级结构的数 目也会随之增加。 • 那么,是否可以使用同一个工厂等级结构来对付这些相同或 者极为相似的产品等级结构呢?当然是可以的,而这就是抽 象工厂模式的好处。同一个工厂等级结构负责三个不同产品 等级结构中的产品对象的创建,如下图所示,图中的虚线代 表创建关系。
系统的设计
• 采用抽象工厂模式设计出的系统类图如下所示。
• 从上图可以看出,抽象工厂模式涉及到以下的角色。 • 抽象工厂(AbstractFactory)角色:担任这个角色的是工厂方 法模式的核心,它是与应用系统的商业逻辑无关的。通常使用 Java 接口或者抽象Java 类实现,而所有的具体工厂类必须实现 这个Java 接口或继承这个抽象Java 类。 • 具体工厂类(Conrete Factory)角色:这个角色直接在客户端的 调用下创建产品的实例。这个角色含有选择合适的产品对象的逻 辑,而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用 具体Java 类实现这个角色。 • 抽象产品(Abstract Product)角色:担任这个角色的类是工厂 方法模式所创建的对象的父类,或它们共同拥有的接口。通常使 用Java 接口或者抽象Java 类实现这一角色。 • 具体产品(Concrete Product)角色:抽象工厂模式所创建的任 何产品对象都是某一个具体产品类的实例。这是客户端最终需要 的东西,其内部一定充满了应用系统的商业逻辑。通常使用具体 Java 类实现这个角色。
•
public class ProductB1 implements ProductB { /** * 构造函数 */ public ProductB1() { } }
• 下面是属于产品等级结构B 的具体产品类ProductB2 的源代码。这个具 体产品实现了产品等级结构B 的抽象产品接口。 • 代码清单9:具体产品类ProductB2 的源代码
• 可以发现在上面的产品类图中,有两个产品的等级结构,分 别是Button 等级结构和Text等级结构。同时有两个产品族, 也就是UNIX 产品族和Windows 产品族。UNIX 产品族由 UnixButton 和UnixText 产品构成;而Windows 产品族由 WinButton 和WinText 产品构成。 • 图描述如下所示。
• abstract class GUIFactory {
public static GUIFactory getFactory() { int sys = readFromConfigFile(“OS_TYPE”); //从配置文 件中读取操作系统类型 if (sys == 0) { return new WinFactory();} else { return new OSXFactory();} } public abstract Button createButton();
• 可以看出,一个工厂等级结构可以创建出分属于不同产品等 级结构的一个产品族中的所有对象;显然,这时候抽象工厂 模式比工厂方法模式更有效率。 • 可以看出,对应于每一个产品族都有一个具体工厂。而每一 个具体工厂负责创建属于同一个产品族、但是分属于不同等 级结构的产品。