设计模式-创建型-工厂模式

工厂模式包含三种，简单工厂模式，工厂方法模式，抽象工厂模式。这三种都是解决了一个问题，那就是对象的创建问题。他们的职责就是将对象的创建和对象的使用分离开来。
针对接口编程，可以隔离掉以后系统可能发生的一大堆改变，为什么呢？如果代码是针对接口而写，那么通过多态，他可以与任何新类实现该接口，但是，当代码使用大量的具体类时，一旦加入新的具体类，就必须改变代码。违反了开闭原则了。
核心本质：
实例化对象，用工厂方法代理new操作
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦
一、简单工厂
用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）

类图关系图

封装改变。将改变的代码用类来封装
专门生产pizza的这个对象，我们可以叫他为工厂

public class SimpleFactory
    {
        public Pizza CreatePizza(string pizzaType)
        {
            switch (pizzaType)
            {
                case "cheese":
                    return new CheesePizza();
                case "ApplePie":
                    return new ApplePiePizza();
                default:
                    return new SomeOtherPizza();
            }
        }
    }

把创建对象的逻辑放到一个单独的类中的原因是它可以被多个客户端使用。并且把对象的创建和使用分离开来。但是这样的设计也存在很多缺陷，首先，SimpleFactory是一个具体的类，那么我们就必须针对实现编程，使得系统失去了这方面的弹性，二是如果增加新的产品我们还得修改simplefactory中的代码，这违反了开闭原则。上面这个模式也叫做简单工厂。他没有在GOF的模式中出现，它更像是一个编程的习惯。
优点：
解决了客户端直接依赖于具体对象的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。实现了对责任的分割。
实现了代码复用
缺点：
工厂类中集中了所有产品的创建逻辑，一旦不能正常工作，整个系统都会受到影响。
系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，变得复杂。
要点：
简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接受参数的不同来返回不同的对象实例。
对于增加新产品需要修改原有代码，否则无法扩展，这与OCP开闭原则冲突。
二、工厂方法
用来生产同一等级结构中的固定产品。（支持增加任意产品）
定义一个创建对象的工厂接口，由其子类决定要实例化的类，将实际创建工作推迟到子类中。强调的是“单个对象”的变化。
动机：这个对象的具体实现"经常面临着剧烈的变化，但它却有比较稳定的接口
如何应对这种变化呢？提供一种封装机制来隔离出"这个易变对象"的变化，从而保持系统中"其它依赖的对象"不随需求的变化而变化。

  public abstract class Car
    {
        public abstract void Run();
    }
    public interface CarFactory
    {
        Car CarCreate();
    }
    public class HongQiCarFactory : CarFactory
    {
        public Car CarCreate()
        {
            return new HongQiCar();
        }
    }
    public class BMWCarFactory : CarFactory
    {
        public Car CarCreate()
        {
            return new BMWCar();
        }
    }
    public class HongQiCar : Car
    {
        public override void Run()
        {
            Console.WriteLine("The HongQiCar run is very quickly!");
        }
    }
    public class BMWCar : Car
    {
        public override void Run()
        {
            Console.WriteLine("The BMWCar run is quitely fast and safe!!!");
        }
    }

类图关系图

工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

简单工厂模式和工厂方法模式PK：

结构复杂度
从这个角度比较，显然简单工厂模式要占优势。简单工厂模式只需要一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。
代码复杂度
代码复杂度和结构复杂度是一个矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂了，简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或者代码），而工厂方法模式每个具体工厂类只完成简单一任务，代码简洁。
客户端编程难度
工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类实例化，而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。
管理上的难度
这是个关键的问题
我们先谈扩展，众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性，那是否说明了简单工厂模式就没有扩展性呢？答案是否定的，简单工厂模式同样具备良好的扩展性----扩展的时候仅需要修改少量的代码（修改工厂类的代码）就可以满足扩展性的要求了。尽管这没有满足OCP，但我们不需要太拘泥于设计理论，要知道，sun提供的java官方工具包中也有想到没有满足OCP的例子啊。
然后我们从维护性的角度分析下，假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求，大不了这个类重写）
根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式。
（三）、抽象工厂
用来生产不同产品族的全部产品。（对于增加新的产品，无能为力，支持增加产品族）
抽象工厂模式是工厂方法模式的升级版本，在有很多业务品种、业务分类时，通过抽象工厂模式产生需要的对象时一种非常好的解决方式。
类关系图

优点：
将具体产品的创建延迟到具体工厂的子类中，将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度降低，更有利于后期的维护和扩展
缺点：
很难支持新种类产品的变化。因为抽象工厂接口中已经确定了可以被创建的产品集合，如果要添加新产品，此时就需要去修改抽象工厂的接口，这样就涉及到抽象工厂类及其所有子类的改变，这违反了“开闭原则”。

abstract class AbstractFactory
{
    public abstract AbstractProductA CreateProductA();
    public abstract AbstractProductB CreateProductB();
}
abstract class AbstractProductA
{
    public abstract void Interact(AbstractProductB b);
}

abstract class AbstractProductB
{
    public abstract void Interact(AbstractProductA a);
}

class Client
{
    private AbstractProductA AbstractProductA;
    private AbstractProductB AbstractProductB;
    public Client(AbstractFactory factory)
    {
        AbstractProductA = factory.CreateProductA();
        AbstractProductB = factory.CreateProductB();
    }
    public void Run()
    {
        AbstractProductB.Interact(AbstractProductA);
        AbstractProductA.Interact(AbstractProductB);
    }
}
class ConcreteFactory1 : AbstractFactory
{
    public override AbstractProductA CreateProductA()
    {
        return new ProductA1();
    }
    public override AbstractProductB CreateProductB()
    {
        return new ProductB1();
    }
}
class ConcreteFactory2 : AbstractFactory
{
    public override AbstractProductA CreateProductA()
    {
        return new ProdcutA2();
    }
    public override AbstractProductB CreateProductB()
    {
        return new ProductB2();
    }
}
class ProductA1 : AbstractProductA
{
    public override void Interact(AbstractProductB b)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
    }
}
class ProductB1 : AbstractProductB
{
    public override void Interact(AbstractProductA a)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
    }
}
class ProdcutA2 : AbstractProductA
{
    public override void Interact(AbstractProductB b)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
    }
}
class ProductB2 : AbstractProductB
{
    public override void Interact(AbstractProductA a)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
    }
}
static void Main(string[] args)
        {

            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();
            // Abstractfactory2
            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();
        }

工厂模式总结：
工厂模式要点：
简单工厂模式（静态工厂模式）
虽然某种程度不符合设计原则，但实际使用最多
工厂方法模式
不修改已有类的前提下，通过新的工厂类实现扩展
抽象工厂模式
不可以增加产品，可以增加产品族