前面介绍了策略和单例模式，这篇文章说一下简单工厂，工厂，抽象工厂的概念和应该场景
首先，从简单工厂开始:
见上图，可以看出来，最核心的部分就是工厂类了，所有的变化都封装在这个工厂类里面，Client不用关心类的实例化
但是，可谓成也工厂类，败也工厂类
如果，实例化的对应有所变化，就需要修改核心工厂类，违背了开放-封闭原则(对修改封闭，对扩展开放)
C#版本代码实现
SimplyFactory
public abstract class Simplyfactory { public abstract string CreateFactory(); } public class SimplyA : Simplyfactory { public override string CreateFactory() { return "FactoryA"; } } public class SimplyB : Simplyfactory { public override string CreateFactory() { return "FactoryB"; } } class Factory { public static Simplyfactory Create(string Type)//核心工厂类负责所有对象的创建，属于创建型模式 { Simplyfactory s = null; switch (Type) { case "A": s = new SimplyA(); break; case "B": s = new SimplyB(); break; default: break; } return s; } } class Client { static void GetSimplyFactory() { Simplyfactory simplyfactory = Factory.Create("A"); Console.Write(simplyfactory.CreateFactory()); Console.Read(); } }
输出结果:FactoryA
简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类
简单工厂模式解决的问题是如何去实例化一个合适的对象。
简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。
好的，下面介绍下工厂模式
先来图
定义一个创建对象的抽象类,有子类来决定具体实例化哪个类,使一个类的创建延迟到子类中
创建的对象Product不会变，但是对象的具体实现经常变换，如果发生变化，增加新的FacotoryMethods子类就可以了
满足对开放--封闭原则
C#版本代码:
FactoryMethod
public abstract class Product { public abstract void work(); } public class ProductA : Product { public override void work() { Console.Write("ProductA"); } } public class ProductB : Product { public override void work() { Console.Write("ProductB"); } } public abstract class FactoryMethods { public abstract Product newproduct(); } //对不同产品的实例化，由不同的工厂来具体实现,每一个工厂生产具体的商品 public class FactoryMethodA : FactoryMethods//具体工厂 { public override Product newproduct() { return new ProductA();//实现具体的实例化 } } public class FactoryMethodB : FactoryMethods//具体工厂 { public override Product newproduct() { return new ProductB();//实现具体的实例化 } } public class FactoryMethodClient { public static void GetFactoryMethod() { //产品种类是变化的，如果发生变化，新增一个工厂就可以了,在调用的地方掉用新的方法 //体现出对修改封闭，对扩展开放，新增新的功能对原来的没有影响 FactoryMethods factorysubA = new FactoryMethodA(); FactoryMethods factorysubB = new FactoryMethodB(); Product pruductA = factorysubA.newproduct(); Product pruductB = factorysubB.newproduct(); pruductA.work(); pruductB.work(); } }
可以看出来，工厂模式的工厂，实例化的对象只有一个，如果实例化的对象是多个，就成了抽象工厂模式，其实工厂模式和抽象工厂也就这点区别
先来看看抽象工厂的UML图
看到了吧，唯一的区别就是工厂创建了多个对象，当然，还是在工厂子类中创建的，这一点和工厂模式是一致的
C#版本代码
AbstractFactory
/*其实工厂和抽象工厂没有多大区别，只不过是抽象工厂生产的商品是多个而已 通俗的说，就是抽象工厂模式的具体工厂里面会有多个实例具体对象的方法 更直观的就是，抽象工厂模式每个工厂一次造多个玩意,而工厂模式的每个工厂只造一个玩意*/ public abstract class Product { public abstract void work(); } public class ProductA : Product { public override void work() { Console.Write("ProductA"); } } public class ProductB : Product { public override void work() { Console.Write("ProductB"); } } public abstract class Car { public abstract void Build(); } public class CarA : Car { public override void Build() { Console.Write("Build CarA"); } } public class CarB : Car { public override void Build() { Console.Write("Build CarB"); } } public abstract class AbstractFactory { //工厂生产多个对象 public abstract Product newproduct(); public abstract Car newCar(); } public class AbstractFactoryA : AbstractFactory { public override Product newproduct() { return new ProductA();//子类里面实现具体的实例化 } public override Car newCar() { return new CarA(); } } public class AbstractFactoryB : AbstractFactory { public override Product newproduct() { return new ProductB();//子类里面实现具体的实例化 } public override Car newCar() { return new CarB(); } } public class AbstractFactoryClient { public static void GetFactoryMethod() { AbstractFactory factorysubA = new AbstractFactoryA(); AbstractFactory factorysubB = new AbstractFactoryA(); Product pruductA = factorysubA.newproduct(); Product pruductB = factorysubB.newproduct(); Car factorycarA = factorysubA.newCar(); factorycarA.Build(); pruductA.work(); pruductB.work(); } }
应用场景：封装变化点。创建一系列相互依赖的对象。