当前位置：首页 > 范文大全 > 实用文>工厂模式Unix系统

工厂模式Unix系统

2023-03-12 08:28:08 收藏本文下载本文

“小猫咪爱吃鱼”通过精心收集，向本站投稿了6篇工厂模式Unix系统，下面是小编给大家带来关于工厂模式Unix系统，一起来看看吧，希望对您有所帮助。

工厂模式Unix系统

篇1：工厂模式Unix系统

工厂模式简单代码，为了给同时讲工厂模式写的范例代码。 /***************************************** *简单工厂模式例子 * 封装一个支持多种数据库的访问层操作 * 利用简单工厂模式，达到客户端调用不关心后台数据库类型 * liqinglin@gmail.com .7.7

工厂模式简单代码。为了给同时讲工厂模式写的范例代码。

/*****************************************

*简单工厂模式例子

* 封装一个支持多种数据库的访问层操作

* 利用简单工厂模式，达到客户端调用不关心后台数据库类型

* 2005.7.7

#include

using namespace std;

class DbHelper{

public:

virtual bool createConnect =0;

virtual bool closeConnect() =0;

};

class MsDbHelper: public DbHelper{//支持MSSQL

public:

MsDbHelper()

{

cout <<“start ms sql”<

}

bool createConnect(){

cout << “this is MS SQL” << endl;

return false;

}

bool closeConnect(){

return true;

}

};

class MysqlDbHelper: public DbHelper{//支持MYSQL

public:

MysqlDbHelper()

{

cout <<“startmysql”<

}

bool createConnect(){

cout << “this is Mysql” << endl;

return false;

}

bool closeConnect(){

return true;

}

};

class Factory{

public:

DbHelper* creator(int flag)//flag更通用的做法是从XML配置文件中来读取

{

if(flag==1)

return new MsDbHelper();

else if(flag==2)

return new MysqlDbHelper();

}

};

void testIt(DbHelper *hd)

{

hd->createConnect();

}

int main(int argc,char **argv)

{

Factory fy;

DbHelper *hd=fy.creator(2);

testIt(hd);

exit(0);

}

运行结果：

[root@stone pattern]# ./factory

start mysql

this is Mysql

原文转自：www.ltesting.net

篇2：工厂模式

工厂模式标签： Java与设计模式

工厂模式

用工厂方法代替了new操作, 将选择实现类,创建对象统一管理和控制.从而将调用者(Client)与实现类进行解耦.实现了创建者与调用者分离;

使用场景

JDK中Calendar的getInstance方法; JDBC中Connection对象的获取; MyBatis中SqlSessionFactory创建SqlSession; SpringIoC容器创建并管理Bean对象; 反射Class对象的newInstance; ….

静态工厂模式

静态工厂模式是工厂模式中最简单的一种，他可以用比较简单的方式隐藏创建对象的细节，一般只需要告诉工厂类所需要的类型，工厂类就会返回需要的产品类，而客户端看到的也只是产品的抽象对象(interface)，因此无需关心到底是返回了哪个子类

我们以运算符类为例, 解释静态工厂模式.

Operator接口

/** * 运算符接口 * Created by jifang on 15/12/7. */public interface Operator{ T getResult(T... args);}实现类

public class AddOperator implements Operator{ @Override public Integer getResult(Integer... args) { int result = 0; for (int arg : args) {result += arg; } return result; }}

public class MultiOperator implements Operator{ @Override public Integer getResult(Integer... args) { int result = 1; for (int arg : args) {result *= arg; } return result; }}工厂

/** * 静态工厂(注: 只返回产品的抽象[即接口]) * 包含两种实现策略 * 1. 根据传入的operator名进行实例化对象 * 2. 直接调用相应的构造实例的方法 * Created by jifang on 15/12/7. */public class OperatorFactory { public static OperatorcreateOperator(String operName) { Operatoroperator; switch (operName) {case +: perator = new AddOperator(); break;case *: perator = new MultiOperator(); break;default: throw new RuntimeException(Wrong Operator Name: + operName); } return operator; } /* ** 第二种实现策略 ** */ public static OperatorcreateAddOper() { return new AddOperator(); } public static OperatorcreateMultiOper() { return new MultiOperator(); }}Client

public class Client { @Test public void testAdd() { Operatoroperator = OperatorFactory.createOperator(+); System.out.println(operator.getResult(1, 2, 3, 4, 6)); } @Test public void testMultiplication() { Operatoroperator = OperatorFactory.createOperator(*); System.out.println(operator.getResult(1, 2, 3, 4, 6)); } @Test public void testAddName(){ Operatoroperator = OperatorFactory.createAddOper(); System.out.println(operator.getResult(1, 2, 3, 4, 6)); } @Test public void testMultiplicationName() { Operatoroperator = OperatorFactory.createMultiOper(); System.out.println(operator.getResult(1, 2, 3, 4, 6)); }}

优点

隐藏了对象创建的细节，将产品的实例化过程放到了工厂中实现，

工厂模式

。客户端基本不用关心使用的是哪个产品，只需要知道用工厂的那个方法(或传入什么参数)就行了. 方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。遵循了依赖倒转原则。

缺点

适用于产品子类型差不多, 使用的方法名都相同的情况. 每添加一个产品子类，都必须在工厂类中添加一个判断分支(或一个方法)，这违背了OCP(开放-封闭原则)。

工厂方法模式

由于静态工厂方法模式不满足OCP, 因此就出现了工厂方法模式; 工厂方法模式和静态工厂模式最大的不同在于:静态工厂模式只有一个(对于一个项目/独立模块)只有一个工厂类, 而工厂方法模式则有一组实现了相同接口的工厂类.

工厂

/** * Created by jifang on 15/12/7. */public interface Factory{ OperatorcreateOperator();}工厂实现

/** * 加法运算符工厂 * Created by jifang on 15/12/7. */public class AddFactory implements Factory{ @Override public OperatorcreateOperator() { return new AddOperator(); }}

/** * 乘法运算符工厂 * Created by jifang on 15/12/7. */public class MultiFactory implements Factory{ @Override public OperatorcreateOperator() { return new MultiOperator(); }}

Operator,AddOperator与MultiOperator与上例相同.

此时, 如果要在静态工厂中新增加一个开根运算类, 要么需要在createOperator方法中增加一种case, 要么得增加一个createSqrtOper方法, 都是需要修改原来的代码的. 而在工厂方法中只需要再添加一个SqrtFactory即可:

/** * 开根运算符 * Created by jifang on 15/12/7. */public class SqrtOperator implements Operator{ @Override public Double getResult(Double... args) { if (args != null && args.length >= 1) {return Math.sqrt(args[0]); } else {throw new RuntimeException(Params Number Error + args.length); } }}

/** * 开根工厂 * Created by jifang on 15/12/7. */public class SqrtFactory implements Factory{ @Override public OperatorcreateOperator() { return new SqrtOperator(); }}

优点

基本与静态工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。

缺点

与静态工厂模式差不多, 但是增加了类组织的复杂性;

小结

虽然根据理论原则, 需要使用工厂方法模式, 但实际上, 常用的还是静态工厂模式.

抽象工厂模式

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

抽象工厂模式与工厂方法模式的区别:

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构. 在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类(如下面的Engine, Tyre, Seat).

在抽象工厂模式中，提出了产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族(如Engine, Tyre, Seat)。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构.

示例:

现在我们要生产两款车: 高档(LuxuryCar)与低档(LowCar), 他们分别配有高端引擎(LuxuryEngine), 高端座椅(LuxurySeat), 高端轮胎(LuxuryTyre)和低端引擎(LowEngine), 低端座椅(LowSeat), 低端轮胎(LowTyre), 下面我们用抽象工厂实现它:

LuxuryCarFactory与LowCarFactory分别代表一类产品族的两款产品, 类似于数据库产品族中有MySQL, Oracle, SqlServer

1. 产品

Engine

public interface Engine { void start(); void run();}class LowEngine implements Engine { @Override public void start() { System.out.println(启动慢 ...); } @Override public void run() { System.out.println(转速慢 ...); }}class LuxuryEngine implements Engine { @Override public void start() { System.out.println(启动快 ...); } @Override public void run() { System.out.println(转速快 ...); }}

Seat

public interface Seat { void massage();}class LowSeat implements Seat { @Override public void massage() { System.out.println(不能按摩 ...); }}class LuxurySeat implements Seat { @Override public void massage() { System.out.println(可提供按摩 ...); }}

Tyre

public interface Tyre { void revolve();}class LowTyre implements Tyre { @Override public void revolve() { System.out.println(旋转 - 不耐磨 ...); }}class LuxuryTyre implements Tyre { @Override public void revolve() { System.out.println(旋转 - 不磨损 ...); }}

注意: 其中并没有车类

2. 产品族Factory

Factory

/** * Created by jifang on 15/12/7. */public interface CarFactory { Engine createEngine(); Seat createSeat(); Tyre createTyre();}低端车

public class LowCarFactory implements CarFactory { @Override public Engine createEngine() { return new LowEngine(); } @Override public Seat createSeat() { return new LowSeat(); } @Override public Tyre createTyre() { return new LowTyre(); }}高端车

public class LuxuryCarFactory implements CarFactory { @Override public Engine createEngine() { return new LuxuryEngine(); } @Override public Seat createSeat() { return new LuxurySeat(); } @Override public Tyre createTyre() { return new LuxuryTyre(); }}

3. Client

/** * Created by jifang on 15/12/7. */public class Client { @Test public void testLow(){ CarFactory factory = new LowCarFactory(); Engine engine = factory.createEngine(); engine.start(); engine.run(); Seat seat = factory.createSeat(); seat.massage(); Tyre tyre = factory.createTyre(); tyre.revolve(); } @Test public void testLuxury(){ CarFactory factory = new LuxuryCarFactory(); Engine engine = factory.createEngine(); engine.start(); engine.run(); Seat seat = factory.createSeat(); seat.massage(); Tyre tyre = factory.createTyre(); tyre.revolve(); }}优点

封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了，

电脑资料

可以支持不同类型的产品，使得模式灵活性更强。可以非常方便的使用一族中间的不同类型的产品。缺点

结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

使用静态工厂优化抽象工厂

由于抽象工厂模式存在结构臃肿以及改动复杂的缺点(比如我们每次需要构造Car, 都需要进行CarFactory factory = new XxxCarFactory();, 而一般一个项目中只会生产一种Car, 如果我们需要更改生产的车的类型, 那么客户端的每一处调用都需要修改), 因此我们可以使用静态工厂对其进行改造, 我们使用CarCreator来统一创建一个产品族不同产品, 这样如果我们的工厂将来更改了产品路线, 改为生产高端车时, 我们仅需改变CAR_TYEP的值就可以了:

/** * Created by jifang on 15/12/7. */public class CarCreator { private static final String CAR_TYPE = low; private static final String CAR_TYPE_LOW = low; private static final String CAR_TYPE_LUXURY = luxury; public static Engine createEngine() { Engine engine = null; switch (CAR_TYPE) {case CAR_TYPE_LOW: engine = new LowEngine(); break;case CAR_TYPE_LUXURY: engine = new LuxuryEngine(); break; } return engine; } public static Seat createSeat() { Seat seat = null; switch (CAR_TYPE) {case CAR_TYPE_LOW: seat = new LowSeat(); break;case CAR_TYPE_LUXURY: seat = new LuxurySeat(); break; } return seat; } public static Tyre createTyre() { Tyre tyre = null; switch (CAR_TYPE) {case CAR_TYPE_LOW: tyre = new LowTyre(); break;case CAR_TYPE_LUXURY: tyre = new LuxuryTyre(); break; } return tyre; }}

其实我们还可以通过反射, 将CarCreator中的switch-case去掉, 而且在实际开发中, 字符串的值我们还可以从配置文件中读取, 这样, 如果需要更改产品路线, 我们连程序代码都懒得改了, 只需要修改配置文件就可以了.

/** * Created by jifang on 15/12/7. */public class CarCreatorReflect { /** * 在实际开发中, 下面这些常量可以从配置文件中读取 */ private static final String PACKAGE = com.feiqing.abstractfactory; private static final String ENGINE = LuxuryEngine; private static final String TYRE = LuxuryTyre; private static final String SEAT = LuxurySeat; public static Engine createEngine() { String className = PACKAGE + . + ENGINE; try {return (Engine) Class.forName(className).newInstance(); } catch (InstantiationException e) {e.printStackTrace(); } catch (IllegalAccessException e) {e.printStackTrace(); } catch (ClassNotFoundException e) {e.printStackTrace(); } return null; } public static Seat createSeat() { String className = PACKAGE + . + SEAT; try {return (Seat) Class.forName(className).newInstance(); } catch (InstantiationException e) {e.printStackTrace(); } catch (IllegalAccessException e) {e.printStackTrace(); } catch (ClassNotFoundException e) {e.printStackTrace(); } return null; } public static Tyre createTyre() { String className = PACKAGE + . + TYRE; try {return (Tyre) Class.forName(className).newInstance(); } catch (InstantiationException e) {e.printStackTrace(); } catch (IllegalAccessException e) {e.printStackTrace(); } catch (ClassNotFoundException e) {e.printStackTrace(); } return null; }}

这样, 客户端调起来就清爽多了

/** * Created by jifang on 15/12/7. */public class StaticClient { @Test public void testLow() { Engine engine = CarCreator.createEngine(); engine.run(); engine.start(); Seat seat = CarCreator.createSeat(); seat.massage(); Tyre tyre = CarCreator.createTyre(); tyre.revolve(); } @Test public void testLuxury() { Engine engine = CarCreatorReflect.createEngine(); engine.run(); engine.start(); Seat seat = CarCreatorReflect.createSeat(); seat.massage(); Tyre tyre = CarCreatorReflect.createTyre(); tyre.revolve(); }}

小结

分类说明静态工厂模式用来生成同一等级结构中的任意产品, 对于增加新的产品,需要修改已有代码工厂方法模式用来生成同一等级结构的固定产品, 支持增加任意产品;抽象工厂模式用来生成不同产品族的全部产品, 对于增加新的产品无能为力;

篇3：设计模式之工厂模式

1、概念

Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。）

工厂模式是经常用到的设计模式之一。其作用是，延迟子类初始化，客户端只需从工厂中获取产品，而不用了解产品生产的细节，降低了模块之间的耦合。也是面向接口编程体现。

2、通用类图

图片摘自HeadFirst<?www.2cto.com/kf/ware/vc/“ target=”_blank“ class=”keylink“>vcD4NCjxwPrTTwODNvMnPv7SjrNPQsvrGt73Tv9qjrNbG1OzV39Kyvs3Kx7mks6e907/aoaO+38zlsvrGt8q1z9ay+sa3vdO/2qOsvt/M5bmks6fKtc/WuaSzp73Tv9qho8i7uvO5pLOntcTKtc/WwOCjrLnYwaq+38zltcSy+sa3oaPOqsHLuPy6w7XYwO294tXiuPbEo8q9o6zHw8HL0ru49tChwP3X06OsvNPS1Lio1vqjrM+jzfu/ydLUyKG1w9K70KnW+rmloaOhvsnuyOvBy73i1eK49sSjyr2/ydLUss6/vCChtsnovMbEo8q91q7s+KG3ILrNobZIZWFkRmlyc3ShtyDV4sG9sb7K6ba8ysfBvNDE1q7X9yDOxLW1z8LU2Lz7ss6/vNfKwc+hvzwvcD4NCjxoMSBpZD0=”3例子“>3、例子

例子背景：有个平板工厂，工厂可以生产苹果平板，安卓平板。平板可以连接wifi关闭wifi等功能。

例子类图如下：

PAD接口代码：

package phlin.samples.factory.pad;public interface PAD { /** * 联网功能 */ public void linkToNet; /** * 打开wifi功能 */ public void openWifi(); /** * 关闭wifi功能 */ public void closeWifi(); /** * other functions */}

工厂接口代码：

package phlin.samples.factory.pad;/** *平板工厂接口 * @author lin * */public interface PADFactoryI { public PAD createPad(String padType); }

安卓平板代码：【实现平板接口】

package phlin.samples.factory.pad;public class AndroidPad implements PAD { @Override public void linkToNet() { // TODO Auto-generated method stub UtilClass.Dis(I use a android pad to get msg from Intener); } @Override public void openWifi() { // TODO Auto-generated method stub UtilClass.Dis(open android pad wifi); } @Override public void closeWifi() { // TODO Auto-generated method stub UtilClass.Dis(close android pad wifi); }}

苹果平板代码：【实现平板接口】

package phlin.samples.factory.pad;public class IOSPad implements PAD{ @Override public void linkToNet() { // TODO Auto-generated method stub UtilClass.Dis(I use a IOS pad to get msg from Intener); } @Override public void openWifi() { // TODO Auto-generated method stub UtilClass.Dis(open IOS pad wifi); } @Override public void closeWifi() { // TODO Auto-generated method stub UtilClass.Dis(close IOS pad wifi); }}

工厂实现代码：【实现工厂接口】

package phlin.samples.factory.pad;public class PadFactory implements PADFactoryI{ PAD pad=null; @Override public PAD createPad(String padType) { // TODO Auto-generated method stub if(padType.equals(android)) {pad=new AndroidPad(); }else if(padType.equals(iso)) {pad=new IOSPad(); }else {UtilClass.Dis(no instance); } return pad; }}

辅助显示类：

package phlin.samples.factory.pad;public final class UtilClass { /** * 终端显示 * @param str */ public static void Dis(String str) { System.out.println(str); }}

测试类代码：

package phlin.samples.factory.pad;public class TestClass { public static void main(String[] args) { PAD andPad=null,iosPad=null; //pad工厂实例化 PadFactory factory=new PadFactory(); //生产安卓平板 andPad=factory.createPad(android); andPad.linkToNet(); //生产苹果平板 iosPad=factory.createPad(iso); iosPad.linkToNet(); }}

测试结果：

I use a android pad to get msg from IntenerI use a IOS pad to get msg from Intener

可以发现，

测试类代码中只需实例化工厂，然后通过createPad方法就可以实例化相对应的平板，而且，关键是，测试类中，无需关系平板是如何生产的，极大降低了模块直接耦合，有利于拓展。

但是这种通过 String padType 的方式来判断那类产品要生产，似乎比较麻烦，如果款式比较多，还得一个个加。这里有一种比较好的优化方案，用泛型来实现，直接通过类名来实例化子类。

下面对工厂接口和工厂实现类做一些改动：

注意不同之处：

工厂接口：

package phlin.samples.factory.pad;/** *平板工厂接口 * @author lin * */public interface PADFactoryI { publicT ceratePad(Classc);}

工厂实现类：

package phlin.samples.factory.pad;public class PadFactory implements PADFactoryI{ PAD pad=null;@Override publicT ceratePad(Classc) { // TODO Auto-generated method stub PAD pad=null; try { pad=(PAD)Class.forName(c.getName()).newInstance(); } catch (Exception e) { // TODO: handle exception } return (T)pad; }}

测试类代码：

package phlin.samples.factory.pad;public class TestClass { public static void main(String[] args) { PAD andPad=null,iosPad=null; PadFactory factory=new PadFactory(); andPad=factory.ceratePad(AndroidPad.class); andPad.linkToNet(); iosPad=factory.ceratePad(IOSPad.class); iosPad.linkToNet(); }}

测试结果：

I use a android pad to get msg from IntenerI use a IOS pad to get msg from Intener

测试结果一样，但是对于工厂实现类，要添加新类型产品是，该类几乎不用改动。对于产品，只需拓展产品也就是平板类型即可。

篇4：抽象工厂Unix系统

为了给同事介绍抽象工厂写的小代码， /************************** *抽象工厂模式 **************************/ #include iostream #include sstream #include string using namespace s td ; class Ram{ public: virtual void showSize()=0; }; class Cpu{ p

为了给同事介绍抽象工厂写的小代码。

/**************************

*抽象工厂模式

**************************/

#include

using namespace std;

class Ram{

public:

virtual void showSize()=0;

};

class Cpu{

public:

virtual void showHz()=0;

};

class Factory{

public:

virtual Ram *createRam()=0;

virtual Cpu *createCpu()=0;

};

class pcRam:public Ram{

public:

void showSize(){

cout << ”this Pc Ram size show“<

}

};

class macRam:public Ram{

public:

void showSize(){

cout << ”this mac Ram size show“<

}

};

class pcCpu:public Cpu{

public:

void showHz(){

cout << ”this pc cpu hz show“<

}

};

class macCpu:public Cpu{

public:

void showHz(){

cout << ”this mac cpu hz show“<

}

};

class pcFactory:public Factory{

public:

Ram *createRam(){

cout << ”this pc ram...“<

return new pcRam();

}

Cpu *createCpu(){

cout << ”this pc cpu...“<

return new pcCpu();

}

};

class macFactory:public Factory{

public:

Ram *createRam(){

cout << ”this mac ram...“<

return new macRam();

}

Cpu *createCpu(){

cout << ”this mac cpu...“<

return new macCpu();

}

};

class Computer{

public:

Computer *createComputer(Factory &factory)

{

Ram *ram=factory.createRam();

Cpu *cpu=factory.createCpu();

ram->showSize();

cpu->showHz();

return this;

}

};

int main()

{

Factory *pcfy=new pcFactory();

Factory *macfy=new macFactory();

Computer pc;

pc.createComputer(*macfy);

exit(0);

}

运行结果：

[root@stone pattern]# ./afactory

this mac ram...

this mac cpu...

this mac Ram size show

this mac cpu hz show

原文转自：www.ltesting.net

篇5：php设计模式 ― 抽象工厂模式

在什么情况下应当使用抽象工厂模式：

1、一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有的形态的工厂模式都是重要的，

2、这个系统的产品有多余一个的产品族，而系统只消费其中某一个族的产品。

3、同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

4、系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

案例1：

还是以农场为例。

我们的农场分了多个产品线，一个是专门卖北方的蔬菜水果。一个专门卖南方的蔬菜水果。大家可以试着不写一下，这里就不给出示例了，uml类图大家可以试着画一下。

案例2：

以电脑为例

电脑分为PC电脑，mac电脑。pc电脑有他组装需要的cpu、主板、键盘 | mac电脑同样需要这些组件，但是型号不一样，下面是此示例的uml类图。

代码示例:

此示例是依据女娲造人而写的。

复制代码

3 //此实例是根据女娲造人写的

5 //首先定义一个全局的工厂接口

6 //由阴绳阳绳来继承都要实现举绳子这个方法

7 interface nvwaRope{

8 public function liftPeopleRope($name);

9 public function liftAnimalRope($name);

10 }

12 //定义阴绳来继承 nvwaRope

13 class yinRope implements nvwaRope{

14 public function liftPeopleRope($name){

15 return new girl($name);

16 }

18 public function liftAnimalRope($name){

19 return new muAnimal($name);

20 }

21 }

23 //定义阳绳

24 class yangRope implements nvwaRope{

25 public function liftPeopleRope($name){

26 return new boy($name);

27 }

29 public function liftAnimalRope($name){

30 return new gongAnimal($name);

31 }

32 }

35 //定义一个人的抽象接口

36 interface people{

37 public function eat;

38 public function getName();

39 }

42 abstract class abstractPeople implements people{

43 private $name;

45 public function __construct($name){

46 $this->name = $name;

47 }

49 public function eat(){

50 echo $this->name . ” eat“;

51 }

53 public function getName(){

54 echo $this->name;

55 return $this->name;

56 }

58 //检查是否有胸

59 public function checkChest(){

60 return $this->haveChest;

61 }

62 }

64 class boy extends abstractPeople{

65 public $haveChest = false; //男孩没有胸

66 }

68 class girl extends abstractPeople{

69 public $haveChest = true; //女孩有胸

70 }

73 //定义一个动物的抽象接口

74 interface animal{

75 public function eat();

76 public function sleep();

77 }

79 abstract class abstractAnimal implements animal{

80 private $name;

82 public function __construct($name){

83 $this->name = $name;

84 }

86 public function eat(){

87 echo $this->name . ” eating“;

88 }

90 public function sleep(){

91 echo $this->name . ” sleeping“;

92 }

94 public function getName(){

95 echo $this->name;

96 return $this->name;

97 }

98 }

篇6：大话设计模式第一章简单工厂模式

一、UML图

vcfJq6O6o6gxo6m5pLOnwOBGYWN0b3J5o6gyo6mz6c/zsvrGt8DgQWJzdHJhY3RQcm9kdWN0o6gzo6m+38zlsvrGt8DgQ29uY3JldGVQcm9kdWN0oaM8L3A+CjxwPqOoMaOpRmFjdG9yeaO6uaSzp8DgysfTw8C01sbU7LL6xre1xKGj0vK0y6Os1NpGYWN0b3J51tDT0NK7uPbTw9Pa1sbU7LL6xre1xENyZWF0Zbqvyv278tXfR2VuZXJhdGW6r8r91q7A4LXEuq/K/aGj1eK49rqvyv3E3Lm7uPm+3aGwserKtrf7obG1xLK7zazJ+rPJsrvNrLXEQ29uY3JldGVQcm9kdWN0o6y1sci71eLQqUNvbmNyZXRlUHJvZHVjdLa8yse8zLPQ19RBYnN0cmFjdFByb2R1Y3S1xKGjPC9wPgo8cD6jqDKjqUFic3RyYWN0UHJvZHVjdKO6s+nP87L6xrfKx7TTxuTL+77fzOWy+sa3s+nP87P2wLS1xKGjs+nP87L6xrfA4Na709DSu7j2oaM8L3A+CjxwPqOoM6OpQ29uY3JldGVQcm9kdWN0o7q+38zlsvrGt8DgvMyz0NfUs+nP87L6xrfA4KOsv8nS1NPQtuC49qGjtbHQ6NKq1Pa809DCtcSy+sa3tcTKsbryvs3U9rzT0ru49rzMs9DX1LPpz/Oy+sa3wOC1xL7fzOWy+sa3wOC8tL/JoaM8L3A+CjxwPjxzdHJvbmc+yP2hotPFysajujwvc3Ryb25nPjwvcD4KPHA+yrXP1sHLy8nx7rrPo6y1sdDo0qrU9rzT0rvW1tDCsvrGt6Oo1Nq087uwyei8xsSjyr3W0KOswP3X08rHINTLy+NPcGVyYXRpb26jqaOs1rvQ6NKq1/bBvbXjuMS2r6O6PC9wPgo8cD6jqDGjqdT2vNPSu7j2vMyz0NfUs+nP87L6xrejqLPpz/O1xNTLy+OjqbXEvt/M5bL6xrejqNK71ta+38zltcTUy8vjo6mjuzwvcD4KPHA+o6gyo6nU2rmks6fA4NbQo6xzd2l0Y2jW0KOs1Pa809K71ta4+b7dserKtrf7svrJ+tDC1MvL47XEY2FzZby0v8mhozwvcD4KPHA+PHN0cm9uZz7LxKGiQyYjNDM7JiM0MzvKtc/WPC9zdHJvbmc+PC9wPgo8cD48L3A+CjxwcmUgY2xhc3M9”brush:java;“>#include#includeusing namespace std;//抽象产品类class Operation{protected: double numberA; double numberB;public: double getA() { return numberA; } double getB() { return numberB; } void setA(double number) { numberA=number; } void setB(double number) { numberB=number; } virtual double GetResult() { double result=0; return result; }};//下面是四种具体产品类class OperationAdd:public Operation{public: double GetResult() { double result=0; result=numberA+numberB; return result; }};class OperationSub:public Operation{public: double GetResult() { double result=0; result=numberA-numberB; return result; }};class OperationMul:public Operation{public: double GetResult() { double result=0; result=numberA*numberB; return result; }};class OperationDiv:public Operation{public: double GetResult() { double result=0; if(numberB!=0) result=numberA/numberB; return result; }};//工厂类 class OperationFactory{public: Operation* createOperation(char type) { Operation* per=new Operation; switch(type) { case '+': per=new OperationAdd; break; case '-': per=new OperationSub; break; case '*': per=new OperationMul; break; case '/': per=new OperationDiv; break; } return oper; }};//客户端void main(){ Operation* oper; OperationFactory of; per=of.createOperation('/'); oper->setA(1); oper->setB(2); cout<GetResult()<

【工厂模式Unix系统】相关文章：

1.Win8大百科27期：安全模式和系统性能