工厂模式是用工厂方法代替new操作的一种模式。工厂方法封装了多个相关联类的new方法，每次实例化这些类的时候不需要new多次，只需要调用工厂类的对应方法即可实例化这些类，并且是通过使用一个共同的接口来指向新创建的对象。
目录
3.抽象工厂（Abstract Factory Pattern）
1.简单工厂（SimpleFactoryPattern）
简单工厂模式是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。一般涉及到三种角色。
简单工厂模式优缺点：
优点：模式的核心是工厂类，这个类负责产品的创建，而客户端可以免去产品创建的责任，这实现了责任的分割。
缺点：但由于工厂类集中了所有产品创建逻辑的，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中。它所能创建的类只能是事先考虑到的，如果增加新产品必须修改工厂角色的源码。
简单工厂模式由三种角色组成：
1、工厂类角色：这是本模式的核心，含有一定的判断逻辑，根据逻辑不同，产生具体的工厂产品。
2、抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3、具体产品角色：工厂类所创建的对象就是此角色的实例。
抽象产品：
//绘图接口
public interface IDraw
{
//绘制图形
void draw();
//擦除图形
void erase();
}工厂类：
//绘图工厂
public class DrawFactory
{
public IDraw GetDraw(string DrawName)
{
IDraw draws = null;
switch (DrawName.ToLower())
{
case "circular":
draws = new Circular(); break;
case "rectangular":
draws = new Rectangular(); break;
}
return draws;
}
}具体产品：
//接口实现类：圆形
public class Circular : IDraw
{
public void draw()
{
Debug.Log("绘制圆形");
}
public void erase()
{
Debug.Log("擦除圆形");
}
}
//接口实现类：矩形
public class Rectangular : IDraw
{
public void draw()
{
Debug.Log("绘制矩形");
}
public void erase()
{
Debug.Log("擦除矩形");
}
}运行测试：
void Start()
{
DrawFactory drawFactory = new DrawFactory();
IDraw draws;
//使用字符串可以通过读取外部文件来改变要创建的类
draws = drawFactory.GetDraw("Circular");
draws.draw();
draws.erase();
draws = drawFactory.GetDraw("Rectangular");
draws.draw();
draws.erase();
}结果：
2.工厂模式（Factory Pattern）
工厂模式是简单工厂模式的进一步抽象和推广。它遵循了“开放—封闭”原则。
工厂模式的优点:
在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。
工厂模式的缺点：
1.工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来执行；每增加一产品就要增加一个产品工厂的类，增加了额外的开发量。
2.由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
工厂模式由四种角色组成：
1、抽象工厂类角色：它一般是具体工厂类继承的父类或者实现的接口。
2、工厂类角色：产生具体的工厂产品，可以写入一定的判断逻辑，或者不写交给客户端判断。
3、抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
4、具体产品角色：工厂类所创建的对象就是此角色的实例。
和简单工厂对比起来，工厂模式就是把工厂类也抽象化了。
抽象产品：
public interface I_Hamburg
{
void GetHamburg();
}抽象工厂：
public interface I_HamburgFactory
{
I_Hamburg NewHamburg();
}具体产品：
public class Beef_Hamburg : I_Hamburg
{
public void GetHamburg()
{
Debug.Log("牛肉汉堡");
}
}
public class Fish_Hamburg : I_Hamburg
{
public void GetHamburg()
{
Debug.Log("鳕鱼堡");
}
}
具体工厂：
class BeefHamburg_Factory : I_HamburgFactory //继承自抽象产品类
{
public I_Hamburg NewHamburg()
{
return new Beef_Hamburg();
}
}
class FishHamburg_Factory : I_HamburgFactory
{
public I_Hamburg NewHamburg()
{
return new Fish_Hamburg();
}
}
运行测试：
void Start()
{
I_HamburgFactory imageFactory; //工厂类
imageFactory = new BeefHamburg_Factory();//实例化 牛肉汉堡 工厂
imageFactory.NewHamburg().GetHamburg(); //工厂生产 牛肉汉堡 .得到汉堡
imageFactory = new FishHamburg_Factory();//实例化 鳕鱼汉堡 工厂
imageFactory.NewHamburg().GetHamburg(); //工厂生产 鳕鱼汉堡 .得到汉堡
}结果：
3.抽象工厂（Abstract Factory Pattern）
抽象工厂模式与工厂方法模式的区别
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。
如果工厂的产品全部属于同一个等级结构，则属于工厂方法模式；
如果工厂的产品来自多个等级结构，则属于抽象工厂模式。
抽象工厂模式的优点：
1.抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易，所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
2.当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
3.增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。
抽象工厂模式的缺点：
增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。
抽象产品：
public interface I_Hamburg //抽象产品：汉堡
{
void GetHamburg();
}
public interface I_Fries //抽象产品：薯条
{
void GetFries();
}抽象工厂：
public interface I_HamburgFactory //抽象工厂
{
I_Hamburg NewHamburg();
I_Fries NewFries();
}具体产品：
public class KFC_Hamburg : I_Hamburg //具体产品：肯德基 的 汉堡
{
public void GetHamburg()
{
Debug.Log("肯德基的鳕鱼汉堡");
}
}
public class M_Hamburg : I_Hamburg //具体产品：麦当劳 的 汉堡
{
public void GetHamburg()
{
Debug.Log("麦当劳的牛肉汉堡");
}
}public class KFC_Fries : I_Fries //具体产品：肯德基 的 薯条
{
public void GetFries()
{
Debug.Log("肯德基的薯条");
}
}
public class M_Fries : I_Fries //具体产品：麦当劳 的 薯条
{
public void GetFries()
{
Debug.Log("麦当劳的薯条");
}
}具体工厂：
class KFC_Factory : I_HamburgFactory //具体工厂：肯德基
{
public I_Hamburg NewHamburg()
{
return new KFC_Hamburg();
}
public I_Fries NewFries() //生产方式
{
return new KFC_Fries();
}
}
class M_Factory : I_HamburgFactory //具体工厂：麦当劳
{
public I_Hamburg NewHamburg()
{
return new M_Hamburg();
}
public I_Fries NewFries() //生产方式
{
return new M_Fries();
}
}运行测试：
void Start()
{
I_HamburgFactory hamburgFactory;//工厂类
hamburgFactory = new KFC_Factory();//实例化 肯德基 工厂
hamburgFactory.NewHamburg().GetHamburg();//制作一个汉堡并拿到它
hamburgFactory.NewFries().GetFries();//制作一个薯条并拿到它
hamburgFactory = new M_Factory();//实例化 麦当劳 工厂
hamburgFactory.NewHamburg().GetHamburg();//制作一个汉堡并拿到它
hamburgFactory.NewFries().GetFries();//制作一个薯条并拿到它
}结果：
