理解概念：
在设计模式中,简单工厂模式我们也可以理解为负责生产对象的一个类。平常编程中，当使用"new"关键字创建一个对象时，此时该类就依赖与这个对象，也就是他们之间的耦合度高，当需求变化时，我们就不得不去修改此类的源码。
我们可以运用面向对象（OO）的很重要的原则去解决这一的问题，该原则就是——封装改变，既然要封装改变，自然也就要找到改变的代码，然后把改变的代码用类来封装。
没用简单工厂模式的代码：
/// <summary>
/// 没有简单工厂之前
/// </summary>
public class Customer
{
/// <summary>
/// 烧菜方法
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Food Cook(string type)
{
Food food = null;
if (type.Equals("西红柿炒蛋"))
{
food = new TomatoScrambledEggs();
}
else if (type.Equals("土豆肉丝"))
{
food = new ShreddedPorkWithPotatoes();
}
return food;
}
static void Main(string[] args)
{
Food food1 = Cook("西红柿炒蛋");
food1.Print();
Food food2 = Cook("土豆肉丝");
food2.Print();
Console.Read();
}
}
用普通抽象类：
1 /// <summary> 2 /// 菜抽象类 3 /// </summary> 4 public abstract class Food 5 { 6 // 输出点了什么菜 7 public abstract void Print(); 8 } 9 10 /// <summary> 11 /// 西红柿炒鸡蛋这道菜 12 /// </summary> 13 public class TomatoScrambledEggs : Food 14 { 15 public override void Print() 16 { 17 Console.WriteLine("一份西红柿炒蛋！"); 18 } 19 } 20 21 /// <summary> 22 /// 土豆肉丝这道菜 23 /// </summary> 24 public class ShreddedPorkWithPotatoes : Food 25 { 26 public override void Print() 27 { 28 Console.WriteLine("一份土豆肉丝"); 29 } 30 }
我的理解是这样，有了抽象工厂类之后，这个抽象类知识约束了我们的行为，具体实现是留给了继承的类，这样就降低了对象之间的耦合度。
看看简单工厂的实现：
1 /// <summary> 2 /// 顾客充当客户端，负责调用简单工厂来生产对象 3 /// 即客户点菜，厨师（相当于简单工厂）负责烧菜(生产的对象) 4 /// </summary> 5 class Customer 6 { 7 static void Main(string[] args) 8 { 9 // 客户想点一个西红柿炒蛋 10 Food food1 = FoodSimpleFactory.CreateFood("西红柿炒蛋"); 11 food1.Print(); 12 13 // 客户想点一个土豆肉丝 14 Food food2 = FoodSimpleFactory.CreateFood("土豆肉丝"); 15 food2.Print(); 16 17 Console.Read(); 18 } 19 } 20 21 /// <summary> 22 /// 菜抽象类 23 /// </summary> 24 public abstract class Food 25 { 26 // 输出点了什么菜 27 public abstract void Print(); 28 } 29 30 /// <summary> 31 /// 西红柿炒鸡蛋这道菜 32 /// </summary> 33 public class TomatoScrambledEggs : Food 34 { 35 public override void Print() 36 { 37 Console.WriteLine("一份西红柿炒蛋！"); 38 } 39 } 40 41 /// <summary> 42 /// 土豆肉丝这道菜 43 /// </summary> 44 public class ShreddedPorkWithPotatoes : Food 45 { 46 public override void Print() 47 { 48 Console.WriteLine("一份土豆肉丝"); 49 } 50 } 51 52 /// <summary> 53 /// 简单工厂类, 负责 炒菜 54 /// </summary> 55 public class FoodSimpleFactory 56 { 57 public static Food CreateFood(string type) 58 { 59 Food food = null; 60 if (type.Equals("土豆肉丝")) 61 { 62 food= new ShreddedPorkWithPotatoes(); 63 } 64 else if (type.Equals("西红柿炒蛋")) 65 { 66 food= new TomatoScrambledEggs(); 67 } 68 69 return food; 70 } 71 }
看完简单工厂模式的实现之后，你和你的小伙伴们肯定会有这样的疑惑（因为我学习的时候也有）——这样我们只是把变化移到了工厂类中罢了，好像没有变化的问题，因为如果客户想吃其他菜时，此时我们还是需要修改工厂类中的方法（也就是多加case语句，没应用简单工厂模式之前，修改的是客户类）。我首先要说：你和你的小伙伴很对，这个就是简单工厂模式的缺点所在（这个缺点后面介绍的工厂方法可以很好地解决），然而，简单工厂模式与之前的实现也有它的优点：
虽然上面已经介绍了简单工厂模式的缺点，下面还是总结下简单工厂模式的缺点：
了解了简单工厂模式之后的优缺点之后，我们之后就可以知道简单工厂的应用场景了：
简单工厂模式又叫静态方法模式（因为工厂类都定义了一个静态方法），由一个工厂类根据传入的参数决定创建出哪一种产品类的实例（通俗点表达：通过客户下的订单来负责烧那种菜）。简单工厂模式的UML图如下：
原文：http://www.cnblogs.com/HKKD/p/6971265.html