工厂模式系列文章
工厂模式应用场景
工厂模式应用场景在现代社会中，汽车已经成为人们生活中不可或缺的交通工具。
而汽车制造工厂则是汽车产业中至关重要的一环。
通过工厂模式的应用，汽车制造工厂可以实现高效生产、灵活生产线调整和产品定制等优势，为汽车产业的发展提供了有力支持。
工厂模式在汽车制造工厂中实现了高效生产。
通过流水线作业和自动化设备的运用，汽车制造工厂可以大幅提高生产效率，实现大规模、高速度的汽车生产。
工厂内的各个工序相互配合，实现了协同作业，从而缩短了汽车的生产周期，提高了产能和生产效率。
工厂模式使汽车制造工厂能够灵活调整生产线。
随着市场需求的变化和新技术的应用，汽车制造商需要不断调整生产线，以适应不同车型的生产需求。
工厂模式可以实现生产线的灵活调整，使汽车制造商能够快速响应市场需求变化，提高生产线利用率和产能。
工厂模式也支持汽车制造商实现产品定制。
随着消费者对汽车个性化需求的增加，汽车制造商需要提供更多样化的产品选择。
工厂模式可以实现定制化生产，根据客户需求定制汽车的配置、颜色和功能，满足消费者个性化需求，提高市场竞争力。
除了以上优势，工厂模式还可以帮助汽车制造商降低生产成本、提高产品质量和减少人为误操作。
通过自动化设备和智能化管理系统的应用，汽车制造工厂可以降低人力成本，减少生产过程中的人为错误，提高产品质量和生产效率。
总的来说，工厂模式在汽车制造工厂中的应用为汽车产业的发展带来了许多好处。
通过高效生产、灵活生产线调整和产品定制等优势，汽车制造商可以更好地适应市场需求变化，提高生产效率和产品质量，推动汽车产业的不断发展。
相信随着工厂模式的不断完善和应用，汽车制造工厂将迎来更加美好的未来。
简单工厂模式的使用场景与示例
简单工厂模式的使用场景与示例简单工厂模式是一种常见的设计模式，它是一种创建型模式，可以帮助我们根据客户端的需求动态地生成不同的对象。
本文将介绍简单工厂模式的使用场景与示例，以便读者更好地理解和应用该模式。
一、简单工厂模式的基本原理在介绍简单工厂模式的使用场景之前，我们先来了解一下它的基本原理。
简单工厂模式由三个角色组成：工厂类、抽象产品类和具体产品类。
工厂类根据客户端的需求，决定创建哪一种具体产品类的对象，并返回给客户端使用。
二、简单工厂模式的使用场景1. 创建对象时只需要知道其类别，而不需要知道具体的实现。
简单工厂模式可以隐藏具体产品类的创建细节，客户端只需要调用工厂类的方法即可获取所需的对象。
2. 客户端不关心对象的创建过程。
通过简单工厂模式，我们可以将对象的创建逻辑封装在工厂类中，使得客户端完全不需要关心对象的创建过程，只需要关心获取到所需对象即可。
3. 需要一组相关的对象被统一创建。
在某些场景下，我们可能需要一组相关的对象被统一创建，简单工厂模式可以灵活地满足这种需求。
三、简单工厂模式的示例下面通过一个示例来具体介绍简单工厂模式的应用。
假设我们有一个游戏场景中的角色类，包括玩家角色和敌人角色。
我们需要根据不同的角色类型创建对应的角色对象。
首先，我们定义一个抽象角色类（Role），用于表示玩家角色和敌人角色的共有属性和方法，包括姓名（name）和攻击力（attack）。
```javapublic abstract class Role {protected String name;protected int attack;public Role(String name, int attack) { = name;this.attack = attack;}public abstract void display();public abstract void attack();}```接下来，我们定义具体的玩家角色类（PlayerRole）和敌人角色类（EnemyRole），它们分别继承自抽象角色类（Role）。
工厂方法模式
示例代码
抽象工厂角色负责声明工厂方法（factory 抽象工厂角色负责声明工厂方法（factory method），用来“生产” method），用来“生产”抽象产品，以下是 抽象工厂的示例性Python代码： 抽象工厂的示例性Python代码： class Creator { public factoryMethod()； factoryMethod()； }
具体产品角色充当最终的创建目标， 具体产品角色充当最终的创建目标， 一般来讲它是抽象产品类的子类，实现了 抽象产品类中定义的所有工厂方法，实际 应用时通常会具有比较复杂的业务逻辑。 以下是具体产品类的示例性Python代码： 以下是具体产品类的示例性Python代码： class ConcreteProduct implements pr { public ConcreteProduct() { } }
一般结构
角色
抽象工厂（Creator）角色 是工厂方法模式的核心， 抽象工厂（Creator） 它负责定义创建抽象产品对象的工厂方法。抽象工厂不能 被外界直接调用，但任何在模式中用于创建产品对象的工 厂类都必须实现由它所定义的工厂方法。 具体工厂（ Creator） 是工厂方法 具体工厂（Concrete Creator）角色 模式的对外接口，它负责实现创建具体产品对象的内部逻 辑。具体工厂与应用密切相关，可以被外界直接调用，创 建所需要的产品。 抽象产品（Product） 是工厂方法模式所创建 抽象产品（Product）角色 的所有对象的父类，它负责描述所有具体产品共有的公共 接口。 具体产品（ Product） 是工厂方法 具体产品（Concrete Product）角色 模式的创建目标，所有创建的对象都是充当这一角色的某 个具体类的实例。
工厂设计的模式研究
享元模式（ｌｗｅ ｈ） Ｆｙ ｉ ｔ ｇ ，代理模式（ｒｗ） Ｐｏ ，行为型模式有助 于 定义系统中对 象之 间的通信 ， 以及在一个复杂 的程序中如何
控制流程，包括责任链模式（ ｈｉ ｆＲ ｓｏ ｓ ｉｔ） Ｃ ａ ｏ ｅｐ ｎｉ ｌｙ ；命令 ｎ ｂｉ 模 式 （ｏ Ｃ ｍｍａｄ ，解 释 器 模 式 （ ｔ ｐｅ ｒ， 迭代 器 模 式 ｎ） Ｉ ｅ ｒｔ ） ｎｒ ｅ （ ｅａ ｒ，中介者模式（ ｄａ ｒ，备忘录模式（ ｍｅｔ） Ｉ ｔ） ｔ ｏ ｒ Ｍｅｉｔ ） ｏ Ｍｅ ｎｏ， 观察者模 式（ ｂｅｖ ）状态模式（ｔｔ）策略模 式（ｔ ｔｇ ） Ｏ ｓｒｅ ， ｒ Ｓａ ， ｅ Ｓ ａｅｙ ， ｒ 模板 方法模式（ｅ ｌｔＭｅ ｏ ） Ｔ ｍｐａ ｔ ｄ，访 问者模式（ ｉｔｒ。 ｅ ｈ Ｖｓ ｏ） ｉ 如果能够有效地利用设计模式 ， 采用灵活多变的， 方式 进行编程 ， 就可以极 大地提高程序代码 的可重用性和 可维护
性。
ｌ 设计模 式定 义
模 式（ａ ｅ ） 实就是解 决某一类 问题 的方法论 。你把 ｐｔ ｒ 其 ｔ ｎ 解决某类 问题 的方法总结归纳到理论高度 ，那就是模式 。 Ａｌ ａ ｄｒ给 出的经典定义是 ：每个模式都描述了一个 ｅ ｎｅ ｘ 在我们 的环境中不断 出现 的问题 ， 然后描述了该问题 的解 决 方案 的核心 。 通过这种方式 ， 你可 以无数次地使 用那些 已有 的解决方案 ，无需在重复相同的工作 。 模式有不同的领域，建筑 领域有建筑模式 ，软件 设计领 域也有设计模式 。当一个领域逐渐成 熟的时候 ，自然会 出现 很 多模式 。 随着这个领域相关文献的增 多，出现 了一些有用 的设计模式定义 。 “ 设计模 式是用于解 决经常 出现 的设 计问题 ｆｍａｌ ｌ Ｓ ｌａｋ ｔ Ｃ ｍｐｎｏ］】 ｏ ａｉｎ［’ 。 ’ “ 计模 式包 含 一 套 描述 如 何 完 成 某 些任 务 的规 则 设 ［ｒｅ１９ ］ Ｐｅ，９４’ ’ “ 设计模式更专注于重用经常性设计的主题 ，而框架关
对工厂模式的理解
对工厂模式的理解工厂模式是一种常用的设计模式，它属于创建型模式，用于封装对象的创建过程。
通过工厂模式，我们可以将对象的创建和使用分离，提高代码的可维护性和扩展性。
在软件开发中，我们经常需要创建不同类型的对象。
如果我们直接在代码中使用new关键字来创建对象，那么代码的可维护性会变差。
当我们需要创建新的对象时，就需要修改已有的代码，违反了开闭原则。
而工厂模式的出现，正是为了解决这个问题。
工厂模式的核心思想是将对象的创建过程封装在一个工厂类中，客户端只需要调用工厂类的方法，即可获取所需的对象。
工厂类根据客户端的请求，选择合适的参数和逻辑来创建对象，并将对象返回给客户端。
工厂模式有三种常见的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式是最简单的工厂模式，它由一个工厂类负责创建所有的产品对象。
客户端只需要提供一个参数，工厂类根据这个参数来创建相应的对象。
简单工厂模式的优点在于客户端不需要关心对象的创建过程，只需要关心如何使用对象即可。
但是它的缺点也很明显，工厂类负责创建所有的对象，当对象类型较多时，工厂类会变得臃肿，不易于扩展。
工厂方法模式是简单工厂模式的升级版，它将工厂类抽象成接口或抽象类，每个具体的产品对象由专门的工厂类负责创建。
客户端需要使用哪种产品对象，就使用相应的工厂类来创建。
工厂方法模式的优点在于每个工厂类只负责创建特定类型的对象，更符合单一职责原则，代码结构更加清晰。
但是它的缺点在于客户端需要知道每个工厂类的具体实现，不够简洁。
抽象工厂模式是工厂方法模式的进一步扩展，它将多个工厂方法组合到一起，形成一个工厂族，每个工厂负责创建对应的产品族。
客户端通过选择工厂族，即可创建所需的产品对象。
抽象工厂模式的优点在于客户端不需要关心具体的工厂和产品，只需要知道选择哪个工厂族即可。
但是它的缺点在于当需要增加新的产品族时，需要修改抽象工厂的接口，违反了开闭原则。
工厂模式的应用场景非常广泛，特别是在需要创建多种类型的对象时，可以有效地降低代码的耦合度。
工厂管理-5工厂模式 精品
工厂模式是我们最常用的模式了,著名的Jive论坛,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。
为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。
我们以类Sample为例，如果我们要创建Sample的实例对象:Sample sample=new Sample();可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值查询数据库等。
首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:Sample sample=new Sample(参数);但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。
为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。
在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。
这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。
简单工厂 工厂方法
简单工厂工厂方法
简单工厂模式和工厂方法模式是两种不同的设计模式，它们在实现方式和适用场景上有所区别。
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
简单工厂模式适用于工厂负责的对象比较少，且客户只关心传入工厂的参数，而不关心如何创建对象的情况。
工厂方法模式定义了一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
这种模式的优点是核心类成为抽象工厂角色，不再负责产品的创建，仅负责具体工厂子类必须实现的接口，使得系统在不修改具体工厂角色的情况下引进新的产品。
工厂方法模式适用于具体工厂角色和抽象工厂角色分离的情况，使得系统更加灵活和可扩展。
总的来说，简单工厂和工厂方法都是创建型设计模式，用于处理对象的创建问题。
但简单工厂模式是一种更简单、直接的对象创建方式，而工厂方法模式则更加强调抽象和多态的应用，使系统更加灵活和可扩展。
在实际应用中，可以根据需要选择合适的设计模式。
工厂模式的说明,解析跟用法案例
无论是简单工厂模式、工厂模式还是抽象工厂模式，它们本质上都是将不变的部分提取出来，将可变的部分留作接口，以达到最大程度上的复用。
拿一个生产水杯（cup）的工厂举例：起初，不用工厂模式，我必须在生产水杯之前知道水杯的材料和形状等水杯的所有特征才能生产，这就是我们的new Cup();这个Cup必须是具体的。
厂主发现同一形状的被子，只是材料不同,如一个是玻璃(glass)的，一个是瓷(china)的,但是确要两条生产线，显然有资源浪费的嫌疑。
现在厂主生产杯子时先不让生产线知道我要产的是玻璃的还是瓷的，而是让它在不知道具体材料的情况下先做它能做的，等到它把模具做好，只需要向其中填充玻璃原料或者瓷原料就可以造出同一形状的具体杯子了。
但是很可惜，java并不能new一个抽象的Cup，所以就有了简单工厂模式。
原来是Cup cup=new Cup;现在是SimpleCupFactory.createCup(String cupName),根据cup的名字生产Cup,而createCup返回的是一个实现了Cup接口或抽象类的具体Cup。
简单抽象工厂模式有一个问题，就是当我现在想生产一个同样形状的铁杯时，工厂里并没有定义相应的处理流程，只能更改createCup方法，这就不合理了。
我现在只是想生产铁杯，你只要在最后的时候把玻璃原料换成铁的不就行了吗，干嘛还要更改整条生产线呢？于是就有了工厂模式。
原来生产线在生产模具的时候还要考虑是为玻璃杯生产的模具还是为铁杯生产的模具，现在它不用管了。
CupFactory.createCup()创建Cup.CupFactory是接口或抽象类。
实现它的具体子类会创建符合Cup接口的具体Cup。
那么现在厂主想要生产水壶(kettle)，用工厂模式就不得不再造一条水壶生产线，能不能在水杯生产线同时生产水壶呢？这就是抽象工厂模式。
在原CupFactory中加一个createKettle()方法，用来生产水壶咱们业务中常常面临着很多业务，有的时候会用到工厂模式，比如咱们学校有老师，学生对象构成了学校的对象组成大大致部分，那么我们我们可以这没来public class 学生实现学习接口{public void 上课();public void 考试（）；}public class 老师实现学习接口(){public void 上课public void 考试（）；}那么我如果我们要分新建一个考试，要有老师跟学生参加，而学生要分成男女考试跟学习，但是不能影响到日常的学习情况，而这个活动是学校举办的那么我们只需要比赛类:public 活动类{public static 学习学生考试（）{renturn new 学生}public static 学习老师考试(){return new 老师();}}然后是场地public 学校{private 学习，男生；private 学习女生;private 学习老师public void 活动（）{this.老师=活动.老师考试;this.男生=活动.学生考试，这个时候就可以这个样子，学生学习的时候老师考试男生.学习（）；女生.考试（）；老师.考试（）；}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
设计模式概述在面向对象的编程中，软件编程人员更加注重以前的代码的重用性和可维护性。
设计模式使人们可以更加简单方便地复用成功的设计和体系结构。
将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。
模式是对前人设计经验的总结。
一般而言，一个模式有四个基本要素1.模式名称（p a t t e r nn a m e）一个助记名，2.问题(p r o b l e m)：描述了应该在何时使用模式。
它解释了设计问题和问题存在的前因后果，它可能描述了特定的设计问题，如怎样用对象表示算法等。
也可能描述了导致不灵活设计的类或对象结构。
有时候，问题部分会包括使用模式必须满足的一系列先决条件。
3.解决方案(s o l u t i o n)描述了设计的组成成分，它们之间的相互关系及各自的职责和协作方式。
因为模式就像一个模板，可应用于多种不同场合，所以解决方案并不描述一个特定而具体的设计或实现，而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象组合）来解决这个问题。
4.效果(c o n s e q u e n c e s)描述了模式应用的效果及使用模式应权衡的问题。
尽管我们描述设计决策时，并不总提到模式效果，但它们对于评价设计选择和理解使用模式的代价及好处具有重要意义。
软件效果大多关注对时间和空间的衡量，它们也表述了语言和实现问题。
因为复用是面向对象设计的要素之一，所以模式效果包括它对系统的灵活性、扩充性或可移植性的影响，显式地列出这些效果对理解和评价这些模式很有帮助。
一些基本的设计模式A b s t r a c t F a c t o r y：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
A d a p t e r：将一个类的接口转换成客户希望的另外一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
B r i d g e：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
B u i l d e r：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
C h a i no fR e s p o n s i b i l i t y：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。
C o m m a n d：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。
C o m p o s i t e：将对象组合成树形结构以表示“部分-整体”的层次结构。
它使得客户对单个对象和复合对象的使用具有一致性。
D e c o r a t o r：动态地给一个对象添加一些额外的职责。
就扩展功能而言，它比生成子类方式更为灵活。
F a c a d e：为子系统中的一组接口提供一个一致的界面，F a c a d e模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
F a c t o r yM e t h o d：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
F a c t o r y M e t h o d使一个类的实例化延迟到其子类。
F l y w e i g h t：运用共享技术有效地支持大量细粒度的对象。
I n t e r p r e t e r：给定一个语言,定义它的文法的一种表示，并定义一个解释器,该解释器使用该表示来解释语言中的句子。
I t e r a t o r：提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示。
M e d i a t o r：用一个中介对象来封装一系列的对象交互。
中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
M e m e n t o：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
这样以后就可将该对象恢复到保存的状态。
O b s e r v e r：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。
P r o t o t y p e：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
P r o x y：为其他对象提供一个代理以控制对这个对象的访问。
S i n g l e t o n：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
S t a t e：允许一个对象在其内部状态改变时改变它的行为。
对象看起来似乎修改了它所属的类。
S t r a t e g y：定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。
本模式使得算法的变化可独立于使用它的客户。
T e m p l a t eM e t h o d：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
T e m p l a t e M e t h o d使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
V i s i t o r：表示一个作用于某对象结构中的各元素的操作。
它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
设计模式从本质上说是一种规则，从形式上说，分为创建型、结构型、行为型。
设计模式的应用是为了实现软件设计中的几个原则，其中一个重要原则是：减少模块之间的耦合程度。
为了确保这个目的，在设计一个类时，要针对接口，而非实现。
（P r o g r a m m i n g t o a n I n t e r f a c e, n o t a nI m p l e m e n t a t i o n）设计的时候只关心类的接口，编程的时候可以先实现一个简单的接口，供别的模块调用。
使用一个类的时候只对接口工作，不关心具体的实现，也不关心具体的类型。
这样也符合人类认识世界的规律，一般说来人们总是先了解一个事情的大概情况，比如，我们先了解一台电视机的大概功能，然后才能了解每个功能具体是怎样实现的。
开始的时候不提供实现，正是为了以后能够最大限度的实现。
设计模式不受语言的限制，使用.n e t或者j a v a更容易实现。
简单工厂模式(SimpleFactory Pattern)-又名静态工厂方法模式一、模式概述工厂模式的几种形态:厂模式专门负责将大量有共同接口的类实例化。
工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。
工厂模式有以下几种形态：（1）简单工厂（S i m p l e F a c t o r y）模式，又称静态工厂方法模式（S t a t i c F a c t o r y M e t h o d P a t t e r n）。
（2）工厂方法（F a c t o r y M e t h o d）模式，又称多态性工厂（P o l y m o r p h i c F a c t o r y）模式或虚拟构造子（V i r t u a lC o n s t r u c t o r）模式；（3）抽象工厂（A b s t r a c tF a c t o r y）模式，又称工具箱（K i t或T o o l k i t）模式。
从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（S t a t i c F a c t o r y Me t h o d）模式，但不属于23种G O F设计模式之一。
简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现，学习了此模式可以为后面的很多中模式打下基础。
我们来分析一个现实生活中的案例，买早餐，大家先看看下面这个图：当我们在买早餐的时候，早餐店里都卖得写什么呢？这点你有注意吗？众多食品摆在那里，你只对营业员说你要何种食品，他便会知道给你拿什么样的食品给你，这说明什么呢？如果用面向对象的思想来理解的话，营业员在这里就充当了一个工厂的角色，他负责根据你的请求返回你需要的食品对象。
而这一点正是简单工厂模式的意图。
二、模式意图简单工厂模式根据提供给他的数据（参数），返回几个可能类中的一个类的实例。
简单工厂模式的要点：1：构造一个创建对象的工厂；2：调用者从工厂中取得某些对象；3：由工厂决定如何创建对象；4：客户不知道对象是如何生成的。
简单工厂模式一般涉及到三种角色：工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。
工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的类实现。
抽象产品角色：担任这个角色的类是由工厂方法所创建的对象的父类，或她们共同拥有的接口。
一般由接口或抽象类实现。
具体产品角色：工厂方法所创建的任何对象都是这个角色的实例，由具体类实现。
三、模式UML图下面是简单工厂模式的示意性U ML图：如上图，简单工厂模式U ML我画了两种，详细如下：①只有一个产品对象的简单工厂模式。
②带有一个抽象产品对象的简单工厂模式。
四、模式参与者工厂（F a c t o r y）角色：接受客户端的请求，通过请求负责创建相应的产品对象。
抽象产品（A b s t r a c t P r o d u c t）角色:是工厂模式所创建对象的父类或是共同拥有的接口。
可是抽象类或接口。
具体产品（C o n c r e t e P r o d u c t）对象：工厂模式所创建的对象都是这个角色的实例。
五、模式实现我们通过上面的分析，已经清晰的知道了工厂模式中的各种角色和职责，那工厂模式通过代码是怎么实现的呢？1、首先我们来看看只有一个产品对象的简单工厂模式的实现。
其实这很好理解，就当店里只卖一种食品，这里以馒头为例。
1///<s u mma r y>2///馒头3///</s u mma r y>4p u b l i c c l a s s S t e a me d B r e a d5{6///<s u mma r y>7///构造方法8///</s u mma r y>9p u b l i c S t e a me d B r e a d()10{}1112///<s u mma r y>13///销售价格14///</s u mma r y>15p r i v a t ed o u b l e p r i c e=0.5;16p u b l i cd o u b l e P r i c e17{18g e t{r e t u r n p r i c e;}19s e t{p r i c e=v a l u e;}20}21}O K，产品对象建立好了，下面就是创建工厂(F a c t o r y)对象了。