using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace 简单的工厂模式
{
//我们是一个食品生产工厂，都是生成吃的
class Program
{
static void Main(string[] args)
{
var doxing= CreateFoodFactory.Cook("雪饼");
doxing.PrintFood();
var doxing2= CreateFoodFactory.Cook("酸奶");
doxing2.PrintFood();
}
}
//生产工厂
public class CreateFoodFactory
{
public static Food Cook(string type)
{
Food food = null;
switch (type)
{
case "雪饼":
food = new 雪饼();
break;
case "酸奶":
food = new 酸奶();
break;
}
return food;
}
}
//生成食品的抽象类
public abstract class Food
{
public abstract void PrintFood();
}
//生产食物
public class 雪饼 : Food
{ public override void PrintFood()
{
Console.WriteLine("雪饼，雪饼……");
}
} public class 酸奶 : Food
{
public override void PrintFood()
{
Console.WriteLine("酸奶，酸奶……");
}
}
}
以上的代码很简单吧，基本都能够理解吧。
优点与缺点
看完简单工厂模式的实现之后，你和你的小伙伴们肯定会有这样的疑惑（因为我学习的时候也有）——这样我们只是把变化移到了工厂类中罢了，好像没有变化的问题，因为如果客户想吃其他菜时，此时我们还是需要修改工厂类中的方法（也就是多加case语句，没应用简单工厂模式之前，修改的是客户类）。我首先要说：你和你的小伙伴很对，这个就是简单工厂模式的缺点所在（这个缺点后面介绍的工厂方法可以很好地解决），然而，简单工厂模式与之前的实现也有它的优点：
- 简单工厂模式解决了客户端直接依赖于具体对象的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。简单工厂模式实现了对责任的分割。
- 简单工厂模式也起到了代码复用的作用，因为之前的实现（自己做饭的情况）中，换了一个人同样要去在自己的类中实现做菜的方法，然后有了简单工厂之后，去餐馆吃饭的所有人都不用那么麻烦了，只需要负责消费就可以了。此时简单工厂的烧菜方法就让所有客户共用了。（同时这点也是简单工厂方法的缺点——因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响，也没什么不好理解的，就如事物都有两面性一样道理）
虽然上面已经介绍了简单工厂模式的缺点，下面还是总结下简单工厂模式的缺点：
- 工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响（通俗地意思就是：一旦餐馆没饭或者关门了，很多不愿意做饭的人就没饭吃了）
- 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，这样就会造成工厂逻辑过于复杂。
了解了简单工厂模式之后的优缺点之后，我们之后就可以知道简单工厂的应用场景了：
- 当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式（）
- 客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式
然后还有什么工厂方法，抽象工厂方法。其实也都是演变下而已。把工厂抽象下
简单工厂模式是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。
一般涉及到三种角色：
工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，
它往往由一个具体的类实现。
抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或她们共同拥有的接口。一般由接口或抽象类实现。
具体产品角色：工厂方法模式所创建的任何对
象都是这个角色的实例，由具体类实现。
简单工厂模式优缺点：
模式的核心是工厂类，这个类负责产品的创建，而客户端可以免去产品创建的责任，这实现了责任的分割。
但由于工厂类集中了所有产品创建逻辑的，如果不能正常工作的话会对系统造成很大的影响。如果增加新产品必须修改工厂角色的源码。
例2
/// <summary>
/// 运算类
/// </summary>
public abstract class Operation
{
public double NumberA { get; set; }
public double NumberB { get; set; } public virtual double GetResult()
{
const double result = ;
return result;
}
}
public class Divide : Operation
{
public override double GetResult()
{
return NumberA / NumberB;
}
}
/// <summary>
/// 减法运算
/// </summary>
public class Minus : Operation
{
public override double GetResult()
{
return NumberA - NumberB;
}
}
public class Multiply : Operation
{
public override double GetResult()
{
return NumberA * NumberB;
}
}
/// <summary>
/// 加法运算
/// </summary>
public class Plus : Operation
{
public override double GetResult()
{
return NumberA + NumberB;
}
}
public class OperationFactory
{
public static Operation CreateOperate(string operate)
{
Operation operation = null; switch (operate)
{
case "+":
operation = new Plus();
break;
case "-":
operation = new Minus();
break;
case "*":
operation = new Multiply();
break;
case "/":
operation = new Divide();
break;
} return operation;
}
} class Program
{
static void Main(string[] args)
{
Operation operateion = OperationFactory.CreateOperate("+");
operateion.NumberA = ;
operateion.NumberB = ;
Console.WriteLine(operateion.GetResult());
Console.ReadKey();
}
}
例3:
简单工厂模式的应用以及代码实现
在某个炎热的夏天，我们的学校突然来了一群新伙伴，那就是一批自动售货机，分布在学校的每一个角落，包括我们的五楼电梯口。当你投入硬币取出一瓶冰凉的饮料时，有没有想过我们可以把它写成一个简单工厂模式呢？至少去年的夏天还没有学设计模式的我不会。
当一个人想要喝里面的饮料时，他自己是不会做饮料或者是冰镇的，这说明人这个对象不用自己去创建各种饮料的对象；每个人都有每个人的爱好，来到售货机前，只要投入钱自己点按钮就可以了。这个时候我们就抽象出一些对象的类。例如要买饮料的人就是一个类、各种饮料抽象成为一个饮料类、每种饮料包括（美年达、雪碧、奶咖）之类的就是具体的饮料对象。uml类图如下：
我们首先写这个抽象的类，饮料类
//抽象出的一个父类角色
public abstract class Drink
{
public abstract string DrinkShow();
}
接着是一些具体的饮料子类，它们有共同的父类饮料类。有共同的行为和属性。
//具体角色
class 美年达:Drink
{
//获取一瓶美年达
public override string DrinkShow()
{
return "你选择的是美年达";
}
}
class 雪碧:Drink
{
//获取一瓶雪碧
public override string DrinkShow()
{
return "您选择的是雪碧";
}
}
class 可口可乐:Drink
{
//获取一瓶可口可乐
public override string DrinkShow()
{
return "您选择的是可口可乐";
}
}
然后建立一个自动售货机的工厂来出饮料：
//现在建立一个自动售货机工厂类
public class DrinkFactory
{
public static Drink createDrink(string type)
{
Drink dri=null ;
switch (type )
{
case "美年达":
dri = new 美年达();
break;
case "雪碧":
dri = new 雪碧();
break;
case "可口可乐":
dri = new 可口可乐();
break;
}
return dri;
}
}
最后建立测试客户端，就是主函数main
static void Main(string[] args)
{
try
{
//实例化各种饮料
Drink 美年达 = DrinkFactory.createDrink("美年达");
Drink 雪碧 = DrinkFactory.createDrink("雪碧");
Drink 可口可乐 = DrinkFactory.createDrink("可口可乐");
//获取饮料
if (美年达 != null)
{
Console.WriteLine(美年达.DrinkShow());
}
if (雪碧 != null)
{
Console .WriteLine ( 雪碧.DrinkShow());
}
if (可口可乐 != null)
{
Console .WriteLine(可口可乐.DrinkShow());
}
}
catch(Exception ex)
{
Console.WriteLine("您输入有错：" + ex.Message);
}
}
三个抽象的产品方法是一样的 都是DrinkShow() 区别在于drinkshow 下边实现的内容不一样