当前位置：首页 > 实用文档 > 其他范文> 设计模式之工厂模式

设计模式之工厂模式

时间：2022-11-17 07:59:50 其他范文收藏本文下载本文

设计模式之工厂模式（合集10篇）由网友“大侦探皮埃尔”投稿提供，下面是小编为大家整理后的设计模式之工厂模式，如果喜欢可以分享给身边的朋友喔!

设计模式之工厂模式

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

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

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

篇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：五分钟一个设计模式之工厂方法模式

下面定义一个抽象类，这个类中有一个具体方法（MyMethod）和一个抽象方法（AbstractMethod），具体方法调用了抽象方法。

public abstract class AbstractClass{ public void MyMethod { string str = AbstractMethod(); Console.WriteLine(str); } protected abstract string AbstractMethod();}

具体方法调用了抽象方法，并且，抽象方法需要在子类中实现，所以，子类实现的抽象方法会对父类中的具体方法产生影响。下面定义两个子类

public class Class1 : AbstractClass{ protected override string AbstractMethod() { return ”I am class1“; }}public class Class2 : AbstractClass{ protected override string AbstractMethod() { return ”I am class2“; }}

在上面的代码中，子类实现的AbstractMethod方法的返回值，直接决定了父类中MyMethod方法中的输出，

下面是场景类

class Program{ static void Main(string[] args) { AbstractClass class1 = new Class1(); AbstractClass class2 = new Class2(); class1.MyMethod(); class2.MyMethod(); }}

输出结果为：

I am class1

I am class2

篇4：五分钟一个设计模式之工厂方法模式

百度百科是这么定义工厂方法模式的：

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

篇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()<

篇7：(C/C++ 版) 设计模式学习之工厂模式

大话设计模式这本书使用 C# 语言写的，我用的是 C++ 语言，最近在看这本书，所以用 C++ 语言走了一遍，

以下是部分笔记，包括代码

若不涉及面向对象这个概念，我们写的简易计算器可能是下面这个样子

//User.cpp --- 客户端#include iostreamint main{ using namespace std; cout<>number_a; cout<>opera; cout<>number_b; int avaliable = 1; float result = 0; switch(opera) { case '+': result = number_a + number_b; break; case '-': result = number_a - number_b; break; case '*': result = number_a * number_b; break; case '/': { if(number_b) { result = number_a / number_b; break; } else avaliable = 0; } default: result = 0; } if(avaliable) cout<可以看出，很呆板，很麻烦，自能实现特定计算，不可调用，没有移植的可能。

而 C++ 是一种面向对象的语言，下面我们用 OOP 思想来重写这段代码。

下面是一个简单的例子，不是很合题，循序渐进，可配合这本书来看。

” int=“int” number_a=“number_a;” number_b=“number_b;” operatepublic:=“operate{public:” pre=“pre” resultpublic:=“result;public:” sign=“sign;”>

//Factory.cpp#include Factory.hfloat operate::calculate(){ switch(sign) { case '+': result = number_a + number_b; break; case '-': result = number_a - number_b; break; case '*': result = number_a * number_b; break; case '/': { if(number_b) { result = number_a / number_b;break; } } default: result = 0; } return result;}

//User.cpp --- 客户端#include Factory.h#include iostreamint main(){ using namespace std; operate myOpera; cout<>myOpera.number_a; cout<>myOpera.number_b; cout<>myOpera.sign; float my_result = myOpera.calculate(); cout<上面就是 OOP 模式了。咱们继续设计模式，下面实现工厂模式。

篇8：工厂模式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

篇9：薪酬模式设计探讨

薪酬模式的设计是薪酬体系设计的核心模块之一，如何针对不同行业、不同企业、不同岗位业务自身的差异和特点，进行薪酬模式的选择和设计，对薪酬体系设计具有重要的意思。设计一个科学的薪酬模式，会将薪酬的激励效用充分发挥，从而保障组织绩效的达成。

本文将对薪酬模式的选择和设计进行讨论：

一、岗位序列

岗位序列是按照根据岗位的工作内容和工作性质的不同，将不同的岗位进行划分、归类管理的方法。企业所有的岗位均可划分为5大序列：

1、管理序列：从事管理工作并拥有一定职务的职位。通俗的理解是“手下有兵”的人，企业因其承担的计划、组织、领导、控制职责作为主要的付薪依据。如：企业的基层、中层和高层管理者。

2、职能序列：从事某个方面的职能管理工作且不具备或不完全具备独立管理职责的职位。如：会计、人力资源专员、市场专员等。

3、技术序列：从事技术研发、设计等工作的岗位。

4、营销序列：从事销售工作的岗位。

5、操作序列：从事生产作业的岗位。

二、五大薪酬模式分析和设计

1、年薪制

（1）适用对象：核心管理人员，包括高层管理者和核心管理中层的管理序列岗位。

（2）工资结构：年收入=岗位工资+年度绩效工资+效益奖金

（3）模式优点：其一，薪酬与公司的整体效益直接挂钩，将公司的发展与个人的回报进行捆绑，充分激励核心管理人员对公司的发展负责。其二，将掌握公司最多信息和资源的岗位与公司的荣辱兴衰紧密相连，促进了资源、权利等的效用最大化，有利于公司年度绩效的提升。

（4）模式缺点：与年度公司业绩密切相关，容易导致高管的短期行为，缺乏对企业长期受益的有效激励。

2、岗位绩效工资制

（1）适用对象：中层管理人员，财务管理、品质、采购、生产等职能管理序列岗位。

（2）工资结构：收入=岗位工资+绩效工资

（3）模式优点：其一，薪酬的发放兼顾岗位对企业的贡献价值和员工的具体工作业绩表现，岗位工资较为固定，其体现了工作岗位对技能、知识、经验等的要求，而且有很好的保健功效，增加了员工的稳定感和安全感。其二，绩效工资能激励员工对工作目标的达成，在稳定团队的同时最大限度的追求了企业整体绩效提升的平衡。

（4）模式缺点：其一，需要有一套科学的岗位价值评估体系对不同类型的岗位进行价值评价。其二，相对较为稳定的岗位工资部分，会削弱绩效工资的激励效果，对于能力、绩效特别突出的优秀员工的激励不足，对于绩效平庸的员工压力也相对较弱，需要通过其它方式进行调和，

3、项目工资制

（1）适用对象：按照项目制方式工作的岗位。

（2）工资结构：收入=技能工资+项目奖金或收入=技能工资+项目奖金+绩效工资

（3）模式优点：其一，技能工资的设定突出了技术能力水平等个人要素，有利于吸引该领域的优秀的人才。其二，按照项目制运作和考核发放的项目奖金对于提升项目团队的整体合作和工作效率，促使项目目标的达成具有较好的激励效果。

（4）模式缺点：不同类型或者性质的项目奖金的确定会有较大的差异性和难度，需要建立完善和科学的项目评价和管理体系，才能保证项目奖金分配公平、公正、合理。

（5）绩效工资的运用：绩效工资在这里作为备选结构，主要是用来针对不同行业、不同类型项目所带来的项目差异性进行灵活处理运用的方式。由于项目这个大概念包含的范围很广，概括的来讲具有复杂度、周期、规模和间歇周期1四个主要评价维度的差异。对于那些公司的项目大都是属于复杂度较大，周期较长，规模较大和间歇周期较短项目的公司，其从事这类项目工作的岗位，可以不设置绩效工资；反之，从事周期短，项目小和间歇周期长项目的岗位，常出现一人需要参与多个项目或者需要从事一定量的非项目性工作，为了充分利用人力资源，提高组织的人均生产效率，是需要考虑设计绩效工资的。

4、计件（时）工资制

（1）适用对象：生产操作序列岗位。

（2）工资结构：收入=计件（时）工资+加班工资

（3）模式优点：与工作业绩密切挂钩，易于量化，对于生产操作岗位有较好的激励效果。

（4）模式缺点：对企业的生产管理水平有一定的要求，生产基础资料要完善，能够进行企业所有工序的生产工时定额。

5、业绩提成制

（1）适用对象：销售序列岗位。

（2）工资结构：收入=底薪+销售提成奖金

销售提成奖金=销售提成基数×提成比例

（3）模式优点：其一，底薪很低，起到保障作用，最小化了人工成本。其二，销售提成奖金力度很大，工资弹性很大，对业绩激励效果十分显著。

（4）模式缺点：其一，这种模式针对性很强，具有浓烈的企业的特性，普遍性较差，在销售提成基数和提成比例的设计过程中需要对行业、企业产品、地区差异性状况有较深入的了解。其二，因为弹性很大，员工的业绩压力较大。

总的来说，每种薪酬模式和其适用对象基本都遵循以上设计的原则。但是薪酬不是万能的，它不可能完全实现激励的作用，还要辅助其它的管理手段。比如说：高管可以配合适用股权激励等长期激励方式；核心骨干人员可以设计职业发展通道进行激励；基层员工可以采用轮岗等方式不断提高其技能，促进个人发展以实现激励效果等等，而这些又和企业的实际状况和市场环境有密切的关系。因此，在薪酬模式的设计中，一定要结合实际状况，进行灵活的运用，才能达到科学构建薪酬管理体系的目标。

篇10：设计模式面试题

近几年来，设计模式试题已广泛出现在一些IT企业(包括一些巨牛型企业)的面试和笔试题中，从本文开始我将通过几篇文章来介绍一下一些已出现过的设计模式面试和笔试题，欢迎大家讨论。

某房地产公司欲开发一套房产信息管理系统，根据如下描述选择合适的设计模式进行设计：

(1) 该公司有多种房型，如公寓、别墅等，在将来可能会增加新的房型；

(2) 销售人员每售出一套房子，主管将收到相应的销售消息。

参考解答：【个人观点】

对于描述(1)可以选择使用工厂方法模式，对于描述(2)可以选择使用观察者模式，本题参考类图如下所示：

在类图中，HouseCreator是抽象房屋工厂类，其子类VilladomCreator用于创建别墅Villadom，子类ApartmentCreator用于创建公寓Apartment，Villadom和Apartment都是抽象房屋类House的子类，此时应用了工厂方法模式，如果增加新类型的房屋，只需对应增加新的房屋工厂类即可，原有代码无须做任何修改;House类同时作为抽象观察目标，子类Villadom和Apartment作为具体观察目标，相关人员类Stakeholder作为抽象观察者，其子类Manager(主管)作为具体观察者，实现了在Stakeholder中声明的response()方法，当房屋售出时，房屋的状态status将发生变化，在setStatus()方法中调用观察者的response()方法，即主管将收到相应消息，此时应用了观察者模式。

[设计模式面试题]

★ 策划书模式

★ 试析高中化学教学中的模式创新与实践论文

★ 从韩国设计教育模式看中国设计教育之缺失

★ 浅谈电站项目进口的管理方法

★ 加工厂整改计划书

★ 计划书范文面粉加工厂