『创建型』简单工厂SimpleFactory、工厂方法FactoryMethod、抽象工厂AbstractFactory

几点说明

永远不要纠结于在什么时候使用什么模式
永远不要纠结于什么模式适用于什么情景
永远不要去死记任何的模式
并不是说，23种设计模式可以应付所有的问题，要知道，使用一种方法的时候，往往伴随着新问题的出现
只有最适合你当前所遇到问题的解决方案，而没有最适合的设计模式，任何一种设计模式在应用的时候，都应该根据问题的实际情况去做适当的改变，不然一定会陷入设计模式的陷阱之中

三种工厂的说明

简单工厂（SimpleFactory）：定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口。

工厂方法（FactoryMethod）：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到了子类。

抽象工厂（AbstractFactory）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

三种工厂的实现

注意：Singleton.SingletonOperateClass_1/2/3/4/5/6 是使用之前写的一个关于单例模式的笔记时创建的。

简单工厂的实现思路：在工厂类中，使用一个以「产品基类」作为返回值类型的方法，用于生产。这个方法需要有一个参数，用于表述需要创建的是哪一种「产品子类」。然后再在这个方法中进行判断，以返回相应的对象。

简单工厂的好处：通过使用工厂方法来创建对象，可以有效的解决在创建对象时耦合性过高的问题。如果我在客户类中，直接使用New来实例化产品类，那么，如果当我想使用另一种更好的类来替代之前的类的时候，我就得每一个客户类中都去修改。而使用工厂方法，就可以做到只修改这一个方法，从而实现低耦合性。当然，简单工厂的一个很致命的缺点，就是必须要知道传入什么以及会传出什么。这样对于类的扩展不是十分的方便。

「抽象工厂 - Abstract Factory」
public interface IFactory_A
{
ProductBass_1 getProduct_1();
ProductBass_2 getProduct_2();
}

public sealed class OperateFactory_1 : IFactory_A
{
public static ProductBass_1 getProduct_1()
{
return new ProductClass_1_1();
}
public static ProductBass_2 getProduct_2()
{
return new ProductClass_2_1();
}
}

public class OperateFactory_2 : IFactory_A
{
public ProductBass_1 getProduct_1()
{
return new ProductClass_1_2();
}
public ProductBass_2 getProduct_2()
{
return new PorductClass_2_2();
}
}

/// <summary>
/// Description of ProductBass_1.
/// </summary>
public abstract class ProductBass_1
{
}

public class ProductClass_1_1 : ProductBase_1
{
public ProductClass_1_1()
{
}
}

public class ProductClass_1_2 : ProductBase_1
{
public ProductClass_1_2()
{
}
}

public abstract class ProductBass_2
{
}

public class ProductClass_2_1 : ProductBase_2
{
public ProductClass_2_1()
{
}
}
public class ProductClass_2_2 : ProductBase_2
{
public ProductClass_2_2()
{
}
}

三种工厂的区别

相比较而言，简单工厂在实现上是最简单的，工厂方法在实现上，较简单工厂更复杂一点，但在灵活性上，更好一些。而抽象工厂方法是这三种方法中，最复杂的一种，当然，其与之前两种要解决的问题也有一定的区别。

我们可以认为，抽象工厂的实现是依托于之前两种方法的。我们也可以认为，抽象工厂是对之前两种方法在创建一系列对象上不足的一个有效补充。

如果说，在设计上做到极致，或整体项目比较小的话，在简单工厂与工厂方法中，个人比较倾向于简单工厂这种方式。因为其不用包含太多的子类。

有文章指出，简单工厂在内聚方面不够充分。这在OOP方面，确实是简单工厂的一个感伤。但是如果我们的换种思路去考虑的话，将工厂类看做是一个静态不变对象，其也是一个高内聚的实现，因为其只有一个作用，就是生产……当然，这是有点阿Q了……

参考

http://www.cnblogs.com/anlyren/archive/2008/01/25/simple_factory_pattern.html

/article/4923306.html

http://www.cnblogs.com/terrylee/archive/2005/12/13/295965.html

http://www.cnblogs.com/terrylee/archive/2006/01/04/310716.html

/article/5578157.html

/article/5139502.html