工厂模式-ByStone2014-11-18

合集下载

跟我学软件系统数据访问层的模块设计中所涉及的J2EE核心设计模式——工厂模式

跟我学软件系统数据访问层的模块设计中所涉及的J2EE核心设计模式——工厂模式
杨教授大学堂,版权所有,盗版必究。 3/6 页
class AbstractDAO
杨教授大学堂 精心创作的优秀程序员 职业提升必读系列资料
{ public Connection getBMPDBMSConnection() txception { InitialContext ic = new InitialContext(); DataSource ds = (DataSource)ic.lookup("SqlServer2000JNDI"); Connection con = ds.getConnection(); return con; } } 针对 Oracle 的 DAO 实现类 根据数据库源的类型,再提供另一种数据源的实现类(与于上面的相同) 。 package bmp20beanDao; import java.sql.*; import javax.sql.DataSource; import javax.naming.*; public class OracleDAO extends AbstractDAO { public Connection getBMPDBMSConnection() throws NamingException,
杨教授大学堂,版权所有,盗版必究。 2/6 页
杨教授大学堂 精心创作的优秀程序员 职业提升必读系列资料
{ return new Monitor(); } } } 在使用者的程序代码中只需要采用如下的代码来获得某以产品 TVSet myOneTV=(TVSet)Factory.creatorProduct(Set_Product);
杨教授大学堂,版权所有,盗版必究。 1/6 页
杨教授大学堂 精心创作的优秀程序员 职业提升必读系列资料

工厂模式,工厂方法模式,单例模式,外观(Facade)模

工厂模式,工厂方法模式,单例模式,外观(Facade)模

工厂模式,工厂方法模式,单例模式,外观(Facade)模式,观察者(Observer)模式,桥接(Bridge)模式都是比较常用的,不同的项目有不同的设计方向,可以参考的设计模式也不尽相同,没有定数,只是上面这几个模式用的比较多一些。

其他的模式我找了一下,都列出来了。

======================Java常用的设计模式创建型模式1、FACTORY—追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM 爱吃的东西,虽然口味有所不同,但不管你带MM去麦当劳或肯德基,只管向服务员说“来四个鸡翅”就行了。

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

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

消费者无须修改就可以接纳新产品。

缺点是当产品修改时,工厂类也要做相应的修改。

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

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

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

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

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

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

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

简单工厂模式和工厂方法模式

简单工厂模式和工厂方法模式

简单⼯⼚模式和⼯⼚⽅法模式
简单⼯⼚模式:定义⼀个⼯⼚类,在⼯⼚类中通过switch或if判断,决定应该创建哪个⼦类对象。

创建⼦类对象是在这⼀个⼯⼚类当中进⾏的。

其弊端在于每次新增都要去修改这个⼯⼚类,违反了开放-封闭原则。

⼯⼚⽅法模式:定义多个⼯⼚类,每⼀个Operation类都对应着⼀个⼯⼚类。

⽐如我们的计算器模型,加减乘除四种运算,对应着四个⼯⼚类。

注意:这四个⼯⼚类并不是继承⾃ Operation类,只是在⼯⼚类的⽅法中return new Operation();创建⼀个Operation类的对象返回。

根据理⽒替换和依赖倒转原则——具体表现为⾯向接⼝编程,⽽不是⾯向实现编程。

针对多个⼯⼚类,可以抽象出⼀个顶级⼯⼚接⼝——OperationFactoryInterface ,所有的⼯⼚类都实现该接⼝。

那么在新增操作的时候,只需要新增⼀个Operation类和⼀个对应的⼯⼚类即可。

对扩展开放,对修改关闭,没有违反开放-封闭原则。

在调⽤者发起调⽤的时候,使⽤顶级接⼝OperationFactoryInterface 接收结果,具体调⽤的⼯⼚类交给调⽤者。

public static void main(String[] args) {
OperationFactoryInterface oprFac = new AddFactory();
Operation opr = oprFac.createOperation();
opr.setNumberA(1);
opr.setNumberB(2);
double result = opr.getResult();
}。

工厂模式(简单工厂、工厂方法、抽象工厂)

工厂模式(简单工厂、工厂方法、抽象工厂)

工厂模式(简单工厂、工厂方法、抽象工厂)简单工厂模式从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactory Method)模式,但不属于23种GOF设计模式之一。

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。

简单工厂模式的一般结构,如图所示:上门2个图片有对简单工厂模式的理解,来源《java与模式》使用场景工厂类负责创建的对象比较少。

客户端只知道传入工厂类的参数,对于如何创建对象并不关心。

l 工厂角色l 抽象产品角色l 具体产品角色其实角色这个词用的比较确切,能够让我们理解到,每个角色的不是单纯地指一个类,可能是一组类所构成了这个角色。

下面对三个角色进行描述:1. 工厂角色工厂角色负责产品的生产工作。

在简单工厂模式中,工厂类是一个具体的实现类,在系统设计中工厂类负责实际对象的创建工作。

工厂类(Factory)的特点是:它知道系统中都存在哪些能够创建对象的具体类(ConcreteProduct),也知道该如何将创建的对象,以某种能够屏蔽具体类实现细节的方式(AbstractProduct)提供给所需要的其他角色来使用该对象提供的数据和服务。

2.抽象产品角色抽象产品角色是具体的产品的抽象。

抽象就是将产品的共性抽取出来,可以直接暴露给客户端(需要使用具体产品的角色),对所有的客户端来说,从工厂中直接获取到的原始产品的外部形态都是相同的,没有任何的差别,包括数据和服务。

这也就是说,具体客户端应该“秘密”掌握着某一个或一些具体产品的详细资料(具体产品类型、数据和服务),然后根据具体客户端(任何一个需要使用某种具体产品的数据和服务的实现类)需要什么样的附加数据和服务,进行类类型转换后,通过借助于对应的具体产品对象来完成其职责。

抽象产品角色,在实际系统中可以定义为接口或者抽象类。

工厂模式学习报告ppt课件

工厂模式学习报告ppt课件

}
else
{
throw new BadFruitException("Bad fruit request");
}
}
}
整理版课件
12
简单工厂模式的结构
工厂类(Creator)角色:担任这个 角色的是工厂方法模式的核心, 含有与应用紧密相关的商业逻 辑.具体由一个JAVA类实现.
•抽象产品(Product)角色:一般 是所有公共产品的公共拥有的 接口.可以是接口也可以是抽象 类.
整理版课件
22
public interface Creator {
public abstract Connection
设计模式的实际应用 getConnection(); ConnectionFactory static newInsttic newInstance()
•具体产品(Concrete Product) 角色:工厂模式所创建的任何对 象都是这个角色.具体由一个 JAVA类实现.
Fruit Gardener
factory(String which)
整理版课件
fruit Applet等
13
简单工厂模式的实现
•多层次的产品结构 •使用JAVA接口或JAVA抽象类 •多个工厂方法(可以有多个工厂方法)
“设计模式”学习报告
移动互联子公司 胡凯 2003-08-07
整理版课件
1
概要:
•模式概论 •简单工厂模式 •工厂模式 •设计模式的实际应用 •总结 •相关资源
整理版课件
2
▪模式概论
什么是模式 为什么要用模式 设计模式的分类
整理版课件
3
什么是模式 ?

工厂模式简介和应用场景

工厂模式简介和应用场景

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

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

设计模式之工厂模式


定义设计模式
对建立类型更进一步的抽象 针对不同问题域的相同解决方式 小到代码,大到架构 经验的传承,并非体系 设计模式类别
1. 创建型 2. 结构型 3. 行为型
设计模式与面向对象
面向对象设计模式解决的是类与相互通信的对象之间的组织关系,包 括它们的角色、职责、协作方式几个方面 面向对象设计模式是“好的面向对象设计”,所谓“好的面向对象设 计”是那些可以满足“应对变化,提高复用”的设计。 面向对象设计模式描述的是软件设计,因此它是独立于编程语言的, 但是面向对象设计模式的最终实现仍然要使用面向对象编程语言来表 达,本课程基于C#语言,但实际上它适用于支持.NET框架的所 有.NET语言,如Visual 、C++/CLI 等。 面向对象设计模式不像算法技巧,可以照搬照用,它是建立在对“面 向对象”纯熟、深入的理解的基础上的经验性认识。掌握面向对象设 计模式的前提是首先掌握“面向对象”!
第三章 设计模式之工厂模式
设计模式概述 设计模式是对开发者经常遇到的设计问题的可再线的解决 方案 设计模式建立了一系列描述如何完成软件开发领域中特定 任务的规则 设计模式更关注于复用可重复出现的结构设计方案,而框 架注重于具体设计实现 设计模式提出了一个发生在特定设计环境中的可重复出现 的设计问题,并提供了解决方案 设计模式就是前人发现的(不是发明)的解决软件开发过 程中特定问题的方法
GoF设计模式
Design Patterns:Elements of Reusable Object-Oriented software(设 计模式:可复用面向对象软件的基础) Erich Gamma、Richard Helm、 Ralph Johnson、John Vlissides(Gang OF Four GoF 四人帮) GoF设计模式主要列举了常用的23种模式(创建型模式、结构型模式 和行为型模式) 由于《GoF设计模式》一书确定了设计模式的地位,人们通常所说的 设计模式隐含地表示“面向对象设计模式”。但这并不意味“设计模 式”就等于“面向对象设计模式”,也不意味着GoF 23种模式就表 示了所有的“面向对象设计模式”。除了“面向对象设计模式”外, 还有其他设计模式。除了GoF 23 种设计模式外,还有更多的面向对 象设计模式。 GoF 23 种设计模式是学习面向对象设计模式的起点,而非终点

简单工厂模式的介绍、优缺点分析和解决方案

简单⼯⼚模式的介绍、优缺点分析和解决⽅案所有的模式都是利⽤java中的封装、继承、多态这三个特性张开的,就像由这三个秘籍组成的各种变幻万千的招式,⽽所有的⽬的都是为了打败坏模式带来的代码垃圾这个敌⼈,所有的招式都是要求“可维护”、“可扩展”、“可复⽤”,当然如果达到这三个标准后,基本上“灵活性好”同时也就拥有了。

所以下⾯介绍最常⽤的⼯⼚模式,分为三类:简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式。

⼀、简单⼯⼚模式1.介绍⼯⼚模式,顾名思义,最少有⼀个⽣产产品的机器存在的⼯⼚Factory,与此同时,也要有⼀个构建好的产品模块Product。

所以,我们要⽤到Factory来创造Product。

在简单⼯⼚模式中,有⼏种⾓⾊存在。

⼀个是所有产品的⽗类P,即所有产品的模板;另外⼀个是继承了⽗类P 的产品⼦类p1,p2...;当然,最重要的是Factory,在Factory中可以将这些的产品实例化,根据需求来将Factory和Product产⽣联系。

2.例⼦我们先来做⼀个例⼦吧,以做⼀个简单的计算器来开始。

a. Product的⽗类: Operationpublic class Operation {private double _numberA = 0 ;private double _numberB = 0;private double result = 0;public double get_numberA() {return _numberA;}public void set_numberA(double _numberA) {this._numberA = _numberA;}public double get_numberB() {return _numberB;}public void set_numberB(double _numberB) {this._numberB = _numberB;}public double getResult() {return result;}public void setResult(double result) {this.result = result;}}b.继承了Product的⼦类:加法产品(OperationAdd),乘法产品(OperationMul),减法产品(OperationSub),除法产品(OperationDiv)public class OperationAdd extends Operation{@Overridepublic double getResult(){double result = 0;result = get_numberA() + get_numberB();return result;}}public class OperationSub extends Operation{@Overridepublic double getResult(){double result = 0 ;result = get_numberA() - get_numberB();return result;}}public class OperationMul extends Operation {@Overridepublic double getResult(){double result = 0;result = get_numberA()*get_numberB();return result;}}public class OperationDiv extends Operation{@Overridepublic double getResult(){double result = 0 ;if(get_numberB() == 0){throw new RuntimeException("除数不能为0.");}else{result = get_numberA()/get_numberB();return result;}}}c.⽣产产品的⼯⼚Factory(OperationFactory)package SimpleFactory;public class OperationFactory {public static Operation createOperation(String operate){Operation oper = null;switch(operate){case "+" :oper = new OperationAdd() ;break;case "-" :oper = new OperationSub() ;break;case "*" :oper = new OperationMul() ;break;case "/" :oper = new OperationDiv() ;break;}return oper;}}最后我们把⼯⼚和产品做好以后就可以,将产品买给客户啦。

设计模式-工厂模式和单件模式

工厂模式和单件模式1.1 Factory模式(一)应用背景我们经常抽象出一些类的公共接口以形成抽象基类或者接口,这样就可以通过声明一个指向基类的指针来指向实际的子类实现,达到了多态的目的。

(二)存在问题N多的子类继承抽象基类,不得不在每次要用到子类的地方就编写诸如new XXX 的代码,此外必须知道实际子类的名字,在复杂系统中简直不可能,维护和扩展也很困难。

另外,在父类中并不知道具体要实例化哪一个具体的子类。

(三)程序举例#ifndef _PRODUCT_H#define _PRODUCT_H/************************************************************************/ /* Product */ /************************************************************************/ class Product{public:Product();virtual ~Product();virtual void operation();};/************************************************************************/ /* Concrete Product A *//************************************************************************/ class ConcreteProductA : public Product{public:ConcreteProductA();virtual ~ConcreteProductA();virtual void operation();};/************************************************************************/ /* Concrete Product B *//************************************************************************/ class ConcreteProductB : public Product{public:ConcreteProductB();virtual ~ConcreteProductB();virtual void operation();};/************************************************************************/ /* Concrete Product C *//************************************************************************/ class ConcreteProductC : public Product{public:ConcreteProductC();virtual ~ConcreteProductC();virtual void operation();};#endif#include "product.h"#include "stdio.h"/************************************************************************/ /* Product */ /************************************************************************/ Product::Product(){}Product::~Product(){}void Product::operation(){printf("Product operation...\n");}/************************************************************************/ /* Concrete Product A *//************************************************************************/ ConcreteProductA::ConcreteProductA(){}ConcreteProductA::~ConcreteProductA(){}void ConcreteProductA::operation(){printf("ConcreteProductA operation...\n");}/************************************************************************/ /* Concrete Product B *//************************************************************************/ ConcreteProductB::ConcreteProductB(){}ConcreteProductB::~ConcreteProductB(){}void ConcreteProductB::operation(){printf("ConcreteProductB operation...\n");}/************************************************************************/ /* Concrete Product C *//************************************************************************/ ConcreteProductC::ConcreteProductC(){}ConcreteProductC::~ConcreteProductC(){}void ConcreteProductC::operation(){printf("ConcreteProductC operation...\n");}#include "product.h"#include "stdio.h"void main(){Product *pProduct = NULL;pProduct = new ConcreteProductA();pProduct->operation();pProduct = new ConcreteProductB();pProduct->operation();pProduct = new ConcreteProductC();pProduct->operation();printf("\n");}程序结果:(四)工厂模式。

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

设计模式之工厂模式 背景: 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就 是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举 例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况, 新对象的建立就是一个“过程”,不仅是一个操作,像一部大机器中的一个齿 轮传动。

问题 你如何能轻松方便地建立这么" 复杂" 的对象即操作中不需要粘贴复制呢?

解决方法 建立一个工厂(一个函数或一个类方法)来制造新的对象。为了理解工厂的用处, 试想 以下的不同之处„„ 代码: $connection = new MySqlConnection($user, $password, $database); „„使你的代码可扩展和更简洁„„ $connection = create_connection();

结果 后者的代码片断集中在和数据库连接的create_connect()工厂上,就像刚才说的一样, 使创造数据库连接的过程成为一个简单的操作—就像new操作一样。工厂模式的优点就在创建对象上。它的任务就是把对象的创建过程都封装起来,然后返回一个所需要的新类。 想改变对象的结构和建立对象的方式吗? 你只需选择对象工厂,对代码的改变只需要一次 就够了。( 工厂模式的功能是如此强大, 它处于是应用的底层, 所以在许多其余的复杂模式 和应用中它会不停地出现。)

简单工厂例子:(简单工厂又叫静态工厂方法模式,这样理解可以确定,简单工厂模式是通过一个静态方法创建对象的。 ) 简单工厂模式: ①抽象基类:类中定义抽象一些方法,用以在子类中实现 ②继承自抽象基类的子类:实现基类中的抽象方法 ③工厂类:用以实例化对象 采用封装方式 class Calc{ /** * 计算结果 * * @param int|float $num1 * @param int|float $num2 * @param string $operator * @return int|float */ public function calculate($num1,$num2,$operator){ try { $result=0; switch ($operator){ case '+': $result= $num1+$num2; break; case '-': $result= $num1-$num2; break; case '*': $result= $num1*$num2; break; case '/': if ($num2==0) { throw new Exception("除数不能为0"); } $result= $num1/$num2; break; } return $result; }catch (Exception $e){ echo "您输入有误:".$e->getMessage(); } } } $test=new Calc(); // echo $test->calculate(2,3,'+');//打印:5 echo $test->calculate(5,0,'/');//打印:您输入有误:除数不能为0 ?>

优点:以上代码使用了面向对象的封装特性,只要有了include这个类,其他页面就可以随便使用了 缺点:无法灵活的扩展和维护 比如:想要增加一个“求余”运算,需要在switch语句块中添加一个分支语句,代码需要做如下改动 添加分支语句 class Calc{ public function calculate($num1,$num2,$operator){ try { $result=0; switch ($operator){ //......省略...... case '%': $result= $num1%$num2; break; //......省略...... } }catch (Exception $e){ echo "您输入有误:".$e->getMessage(); } } } ?>

代码分析:用以上方法实现给计算器添加新的功能运算有以下几个缺点 ①需要改动原有的代码块,可能会在为了“添加新功能”而改动原有代码的时候,不小心将原有的代码改错了 ②如果要添加的功能很多,比如:‘乘方’,‘开方’,‘对数’,‘三角函数’,‘统计’,或者添加一些程序员专用的计算功能,比如:And, Or, Not, Xor,这样就需要在switch语句中添加N个分支语句。想象下,一个计算功能的函数如果有二三十个case分支语句,代码将超过一屏,不仅令代码的可读性大大降低,关键是,为了添加小功能,还得让其余不相关都参与解释,这令程序的执行效率大大降低 解决途径:采用OOP的继承和多态思想 简单工厂模式的初步实现 /** * 操作类 * 因为包含有抽象方法,所以类必须声明为抽象类 */ abstract class Operation{ //抽象方法不能包含函数体 abstract public function getValue($num1,$num2);//强烈要求子类必须实现该功能函数 } /** * 加法类 */ class OperationAdd extends Operation { public function getValue($num1,$num2){ return $num1+$num2; } } /** * 减法类 */ class OperationSub extends Operation { public function getValue($num1,$num2){ return $num1-$num2; } } /** * 乘法类 */ class OperationMul extends Operation { public function getValue($num1,$num2){ return $num1*$num2; } } /** * 除法类 */ class OperationDiv extends Operation { public function getValue($num1,$num2){ try { if ($num2==0){ throw new Exception("除数不能为0"); }else { return $num1/$num2; } }catch (Exception $e){ echo "错误信息:".$e->getMessage(); } } } ?>

这里采用了面向对象的继承特性,首先声明一个虚拟基类,在基类中指定子类务必实现的方法(getValue())

/** * 求余类(remainder) * */ class OperationRem extends Operation { public function getValue($num1,$num2){ return $num1%$num12; } } ?> 分析:通过采用面向对象的继承特性,我们可以很容易就能对原有程序进行扩展,比如:‘乘方’,‘开方’,‘对数’,‘三角函数’,‘统计’等等。 我们只需要另外写一个类(该类继承虚拟基类),在类中完成相应的功能(比如:求乘方的运算),而且大大的降低了耦合度,方便日后的维护及扩展 现在还有一个问题未解决,就是如何让程序根据用户输入的操作符实例化相应的对象呢? 解决办法:使用一个单独的类来实现实例化的过程,这个类就是工厂 代码如下:

/** * 工程类,主要用来创建对象 * 功能:根据输入的运算符号,工厂就能实例化出合适的对象 * */ class Factory{ public static function createObj($operate){ switch ($operate){ case '+': return new OperationAdd(); break; case '-': return new OperationSub(); break; case '*': return new OperationSub(); break; case '/': return new OperationDiv(); break; } } } $test=Factory::createObj('/'); $result=$test->getValue(23,0); echo $result; ?>

工厂方法模式:(定义一个创建对象的接口,让子类决定哪个类实例化。 他可以解决简单工厂模式中的封闭开放原则问题。 )

/* *工厂方法模式: *定义一个创建对象的接口,让子类决定哪个类实例化。 他可以解决简单工厂模式中的封闭开放原则问题。 interface people { function jiehun(); } class man implements people{ function jiehun() { echo '送玫瑰,送戒指!'; } }

class women implements people { function jiehun() { echo '穿婚纱!'; }

相关文档
最新文档