简单工厂模式及实例

    简单工厂模式又叫静态工厂模式，顾名思义，它是用来实例化目标类的静态类。下面我主要通过一个简单的实例说明简单工厂及其优点。

    简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

 

该模式中包含的角色及其职责

　　工厂（Creator）角色

　　简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

　　抽象（Product）角色

　　简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

　　具体产品（Concrete Product）角色

　　是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

　　一般来讲它是抽象产品类的子类，实现了抽象产品类中定义的所有接口方法。

下面我们来看下具体的实例：

我们使用一个计算器的实例来看

 

创建运算类
public class Operation { private double numberA; private double numberB; public double NumberA { get { return numberA; } set { numberA = value; } } public double NumberB { get { return numberB; } set { numberB = value; } } public virtual double GetResult() { double result = 0; return result; } } public class Operation { private double numberA; private double numberB; public double NumberA { get { return numberA; } set { numberA = value; } } public double NumberB { get { return numberB; } set { numberB = value; } } public virtual double GetResult() { double result = 0; return result; } }

 

写子类 实现父类的虚方法

/// <summary> /// 加法类 /// </summary> class OPerationAdd:Operation { public override double GetResult() { double resule = 0; resule=NumberA+NumberB; return resule; } } /// <summary> /// 减法类 /// </summary> class OPerationSub : Operation { public override double GetResult() { double resule = 0; resule = NumberA - NumberB; return resule; } } /// <summary> /// 乘法类 /// </summary> class OPerationMul : Operation { public override double GetResult() { double resule = 0; resule = NumberA * NumberB; return resule; } } /// <summary> /// 除法类 /// 进行了验证 /// </summary> class OPerationDiv : Operation { public override double GetResult() { double resule = 0; if (NumberB==0) { throw new Exception("除数不能为0"); } resule = NumberA / NumberB; return resule; } } /// <summary> /// 加法类 /// </summary> class OPerationAdd:Operation { public override double GetResult() { double resule = 0; resule=NumberA+NumberB; return resule; } } /// <summary> /// 减法类 /// </summary> class OPerationSub : Operation { public override double GetResult() { double resule = 0; resule = NumberA - NumberB; return resule; } } /// <summary> /// 乘法类 /// </summary> class OPerationMul : Operation { public override double GetResult() { double resule = 0; resule = NumberA * NumberB; return resule; } } /// <summary> /// 除法类 /// 进行了验证 /// </summary> class OPerationDiv : Operation { public override double GetResult() { double resule = 0; if (NumberB==0) { throw new Exception("除数不能为0"); } resule = NumberA / NumberB; return resule; } }

现在我们有个4个类实现了运算的方法，需要调用时只要创建他的实例就可以直接使用了

可是那样是很麻烦的，可是到底实例化那个对象呢？将来会不会增加实例化的对象呢？

所以我们使用一个单独的类，来实现专门的实例化，也就是我们今天要说的工厂类

/// <summary> /// 工厂类 /// 实现具体的实例化 /// </summary> class OPerationFactory { public static Operation CreateOperate(string operation) { Operation oper = null; switch (operation) { case "+": oper = new OPerationAdd(); break; case "-": oper = new OPerationSub(); break; case "*": oper = new OPerationMul(); case "/": oper = new OPerationDiv(); break; } return oper; } } /// <summary> /// 工厂类 /// 实现具体的实例化 /// </summary> class OPerationFactory { public static Operation CreateOperate(string operation) { Operation oper = null; switch (operation) { case "+": oper = new OPerationAdd(); break; case "-": oper = new OPerationSub(); break; case "*": oper = new OPerationMul(); case "/": oper = new OPerationDiv(); break; } return oper; } }

这样使用一个工厂类，只需要把参数传进去就可以实现具体的实例化，产生合适的对象，通过多态返回父类的方式实现结果。

这样我们在界面就可以直接调用就可以啦，举个小例子啦

我们计算5+5

/// <summary> /// 界面调用工厂方法 /// 实现了我们需要的运算 /// </summary> static void Main(string[] args) { Operation.Operation oper; oper = Operation.OPerationFactory.CreateOperate("+"); oper.NumberA = 5; oper.NumberB = 5; double result = oper.GetResult(); Console.Write(oper.NumberA + "+" + oper.NumberB + "=" + result); } /// <summary> /// 界面调用工厂方法 /// 实现了我们需要的运算 /// </summary> static void Main(string[] args) { Operation.Operation oper; oper = Operation.OPerationFactory.CreateOperate("+"); oper.NumberA = 5; oper.NumberB = 5; double result = oper.GetResult(); Console.Write(oper.NumberA + "+" + oper.NumberB + "=" + result); }

简单工厂类图

 

简单工厂模式的特点:

　　简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

　　在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

　　不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

简单工厂只是入门级模式，关于他的弊端，我们可以使用反射序列化的方法解决，读取XML或*.config的内容是他去掉switch这个破坏OOP的家伙，使我们的程序更加灵活

<?xml version="1.0" encoding="utf-8" ?> <Operators> <operator name="+" value="Operation.OPerationAdd"></operator> <operator name="-" value="Operation.OPerationSub"></operator> <operator name="*" value="Operation.OPerationMul"></operator> <operator name="/" value="Operation.OPerationDiv"></operator> </Operators>

简单工厂可以这么写：

 public static Operation CreateOperate(string op)

{

 Operation oper= Assembly.Load("Operation").CreateInstance(op) as Operation ;

}

这样我们就可以灵活的添加删除了，只需要在XML中修改和添加实现类就可以了，彻底实现OOP原则

高内聚，低耦合。

好了，简单工厂介绍完了。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/java343837022/archive/2009/02/16/3896889.aspx