设计模式之简单工厂模式

基本简介

　　从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种 GOF 设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

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

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

　　工厂（Creator）角色

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

　　抽象产品（Product）角色

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

　　具体产品（Concrete Product）角色

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

编辑本段

优缺点

　　优点

　　工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个 软件体系结构 的优化。

　　缺点

　　由于工厂类集中了所有实例的创建逻辑，违反了 高内聚 责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

　　当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

　　这些缺点在 工厂方法模式 中得到了一定的克服。

使用场景

　　工厂类负责创建的对象比较少；

　　客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

　　由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

实例

C#

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
 namespace 简单工厂模式
 {
     /**
      * 简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。
      * 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
      * 简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
      * 
      * 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
      */
 
     public class Operation 
     {
         //抽象产品（Product）角色
         //简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
         private double _numberA = 0;
 
         public double NumberA
         {
             get { return _numberA; }
             set { _numberA = value; }
         }
         private double _numberB = 0;
 
         public double NumberB
         {
             get { return _numberB; }
             set { _numberB = value; }
         }
 
         public virtual double GetResult()
         {
             double result = 0;
             return result;
         }
 
     }
     /**
      * 具体产品（Concrete Product）角色
      * 是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
      */
     class OperationAdd : Operation
     { 
         public override double  GetResult()
         {
           double result = 0;
           result = NumberA + NumberB;
  	      return result;
         }
     }
 
     class OperationSub : Operation
     {
         public override double GetResult()
         {
             double result = 0;
             result = NumberA - NumberB;
             return result;
         }
     }
     class OperationMul : Operation
     {
         public override double GetResult()
         {
             double result = 0;
             result = NumberA * NumberB;
             return result;
         }
     }
     class OperationDiv : Operation
     {
         public override double GetResult()
         {
             double result = 0;
             result = NumberA / NumberB;
             return result;
         }
     }
     /**
      *工厂（Creator）角色
      *简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
      */
     public class OperationFactory
     {
         public static Operation createOperate(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;
                 default:
                     oper = null;
                     break;
             }
             return oper;
         }
     }
     /**
      *测试程序 
      */
     class Program
     {
         static void Main(string[] args)
         {
             Operation oper = null;
             oper = OperationFactory.createOperate("+");
             oper.NumberA = 1;
             oper.NumberB = 2;
             Console.WriteLine("sum:{0}\n",oper.GetResult());
             Console.ReadKey();
         }
     }
 }
 

JAVA

Operati on.java

/**
  * 抽象产品（Product）角色 简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
  * 
  * @author Administrator
  * 
  */
 public class Operation {
 
 	private double numberA;
 	private double numberB;
 
 	public double getNumberA() {
 		return numberA;
 	}
 
 	public void setNumberA(double numberA) {
 		this.numberA = numberA;
 	}
 
 	public double getNumberB() {
 		return numberB;
 	}
 
 	public void setNumberB(double numberB) {
 		this.numberB = numberB;
 	}
 
 	public double GetResult(){
 		return 0;
 	}
 
 }

OperationType.java

public class OperationType {
 
 	/**
 	 * 
 	 * @author Administrator 具体产品（Concrete Product）角色
 	 *         是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
 	 */
 	public static class OperationAdd extends Operation {
 		
 		public double GetResult() {
 			return getNumberA() + getNumberB();
 		}
 	}
 	
 	public static class OperationSub extends Operation{
 
 		public double GetResult() {
 			return getNumberA() - getNumberB();
 		}
 	}
 	
 	public static class OperationMul extends Operation{
 
 		public double GetResult() {
 			return getNumberA() * getNumberB();
 		}
 	}
 	
 	public static class OperationDiv extends Operation{
 
 		public double GetResult() {
 			return getNumberA() / getNumberB();
 		}
 	}
 }
 

OperationFactory.java

public class OperationFactory {
 	public static Operation createOperate(char operate)
     {
         Operation oper = null;
         switch (operate)
         {
             case '+':
                 oper = new OperationType.OperationAdd();
                 break;
             case '-':
                 oper = new OperationType.OperationSub();
                 break;
             case '*':
                 oper = new OperationType.OperationMul();
                 break;
             case '/':
                 oper = new OperationType.OperationDiv();
                 break;
             default:
                 oper = null;
                 break;
         }
         return oper;
     }
 }
 

测试类StaticFactory.java

public static void main(String[] args) {
 		Operation oper = null;
 		oper = OperationFactory.createOperate('*');
 		oper.setNumberA(12);
 		oper.setNumberB(6);
 		System.out.println("Result:"+oper.GetResult());
 	}

UML类图