设计模式-工厂模式

工厂模式：简单工厂模式，工厂方法模式，抽象工厂模式
首先总结下它们的区别：
简单工厂模式：一个工厂可以生产多种产品。一个方法生产多种产品
工厂方法模式：多个工厂，不同工厂各自生产各自种类的产品。一个工厂生产一种产品
抽象工厂模式：多个工厂，每个工厂生产多种产品。一个工厂生产同种产品的不同规格的产品

我们就拿蛋糕店生产的蛋糕为例。
1，简单工厂模式
蛋糕有多种口味（香草味，焦糖味，奶油味，葱香味等），现在蛋糕店目前只卖香草味，焦糖味，奶油味的蛋糕，蛋糕店有一台制作蛋糕的机器，这台机器上有3个按钮，当点击不同的按钮就会做出对应口味的蛋糕。
首先要有一个蛋糕的抽象类
//定义抽象的蛋糕类
public abstract class AbstractCake
{
public abstract void CakeTaste();
}
定义3个不同口味的蛋糕，继承上面的抽象类
//定义香草味蛋糕
public class VanillaCake : AbstractCake
{
public override void CakeTaste()
{
Console.WriteLine(“香草口味蛋糕”);
}
}
//定义焦糖味蛋糕
public class CaramelCake : AbstractCake
{
public override void CakeTaste()
{
Console.WriteLine(“焦糖口味蛋糕”);
}
}
//定义奶油味蛋糕
public class CreamCake : AbstractCake
{
public override void CakeTaste()
{
Console.WriteLine(“奶油口味蛋糕”);
}
}
定义一个工厂来生产这些蛋糕
//定义蛋糕工厂类
public class CakeFactory
{
public static AbstractCake ProducteCake(string taste)
{
switch (taste)
{ case “Vanilla”:
return new VanillaCake();
case “Caramel”:
return new CaramelCake();
case “Cream”:
return new CreamCake();
default:
return null;
}
}
}
客户端操作
public class Client
{
public static void main(String[] args)
{
AbstractCake vanillaCake = CakeFactory.ProducteCake(“Vanilla”);
vanillaCake.CakeTaste();
AbstractCake caramelCake = CakeFactory.ProducteCake(“Caramel”);
caramelCake.CakeTaste();
AbstractCake creamCake = CakeFactory.ProducteCake(“Cream”);
creamCake.CakeTaste();
}
}
可以看到，简单工厂模式确实很“简单”。一般，简单工厂方法模式中，工厂类中有一个方法，通过switch中不同的值或者if else语句来创建不同的对象并返回，通常这个方法是一个静态方法，(顺便一提:简单工厂模式也被称作“静态工厂模式”)在客户端直接调用工厂类的该方法就可以。

2，工厂方法模式
简单工厂模式，确实很简单，但一个机器却只能坐3种口味的蛋糕，如果有一个蛋糕店决定要添加一种葱香味口味的蛋糕，但是机器一定做成，要想添加制作葱香味的蛋糕，就必须要把机器拆开再添加一种制作葱香味的方法，那一定是不行的。这样就违背了开闭原则，扩展性差。
但工厂方法模式，就可以解决到这个问题，不用一个工厂去生产多种口味的蛋糕，可以多建几个工厂，每个工厂去生产对应口味的蛋糕。这样就可以吧制作蛋糕口味的蛋糕机器分成多个机器，蛋糕店想制作哪种口味的蛋糕只要购置对应口味的机器就好了。
首先定义一个抽象工厂类
/定义抽象蛋糕工厂
public abstract class AbstractCakeFactory
{
public abstract AbstractCake ProducteCake();
}
在定义3个生产原有口味的工厂，继承抽象工厂
//定义生产香草口味的蛋糕工厂
public class VanillaCakeFactory : AbstractCakeFactory
{
public override AbstractCake ProducteCake()
{
return new VanillaCake();
}
}
//定义生产焦糖口味的蛋糕工厂
public class CaramelCakeFactory : AbstractCakeFactory
{
public override AbstractCake ProducteCake()
{
return new CaramelCake();
}
}
//定义生产奶油口味的蛋糕工厂
public class CreamCakeFactory : AbstractCakeFactory
{
public override AbstractCake ProducteCake()
{
return new CreamCake();
}
}
现在我们要多加一种口味（葱香味）的蛋糕
我们可以定义一个葱香味的蛋糕继承抽象蛋糕类
定义一个生产葱香味的工厂继承抽象工厂，去专门生产葱香味的蛋糕
/定义葱香味蛋糕
public class OnionCake : AbstractCake
{
public override void CakeTaste()
{
Console.WriteLine(“葱香口味蛋糕”);
}
}
/定义生产葱香口味的蛋糕工厂
public class OnionCakeFactory : AbstractCakeFactory
{
public override AbstractCake ProducteCake()
{
return new OnionCake();
}
}
客户端操作：
public class Client_1
{
public static void Main(String[] args)
{
//生产香草味
AbstractCakeFactory vanillaCakeFactory = new VanillaCakeFactory();
AbstractCake vanillaCake = vanillaCakeFactory.ProducteCake();
vanillaCake.CakeTaste();
//生产焦糖味
AbstractCakeFactory caramelCakeFactory = new CaramelCakeFactory();
AbstractCake caramelCake = caramelCakeFactory.ProducteCake();
caramelCake.CakeTaste();
//生产奶油味
AbstractCakeFactory creamCakeFactory = new CreamCakeFactory();
AbstractCake creamCake = creamCakeFactory.ProducteCake();
creamCake.CakeTaste();
//生产葱香味味
AbstractCakeFactory onionCakeFactory = new OnionCakeFactory();
AbstractCake onionCake = vanillaCakeFactory.ProducteCake();
onionCake.CakeTaste();
}
}
这样就不会违背开闭原则，每个工厂只生产一种产品，客户端通过不同的工厂去生产不同的产品，而生产哪一产品的逻辑交给客户端这边去处理了。
3，抽象工厂模式
现在蛋糕，但人和人有差异，有的人食量大，他喜欢买大蛋糕，有的人食量小，他就喜欢买小蛋糕，假如现在的蛋糕机都是做大蛋糕的，如果要再去购置一批小蛋糕机，来专门制作小蛋糕，那么机器的数量就会增加一倍，有点不太合理。但大小蛋糕的制作材料与工艺都是一样，那我们就可以在蛋糕机的上面增加一个按钮来控制制作蛋糕的分量，这样就比较合理了。
首先需要定义大，小蛋糕的抽象类
public abstract class BigCake
{
public abstract void CakeTaste();
}

public abstract class SmallCake
{
public abstract void CakeTaste();
}
具体口味的蛋糕类分别大小蛋糕继承这两个抽象类
//定义大香草味蛋糕
public class BigVanillaCake : BigCake
{
public override void CakeTaste()
{
Console.WriteLine(“大香草口味蛋糕”);
}
}
//定义大焦糖味蛋糕
public class BigCaramelCake : BigCake
{
public override void CakeTaste()
{
Console.WriteLine(“大焦糖口味蛋糕”);
}
}
//定义大奶油味蛋糕
public class BigCreamCake : BigCake
{
public override void CakeTaste()
{
Console.WriteLine(“大奶油口味蛋糕”);
}
}

//定义小香草味蛋糕
public class SmallVanillaCake : SmallCake
{
public override void CakeTaste()
{
Console.WriteLine(“小香草口味蛋糕”);
}
}
//定义小焦糖味蛋糕
public class SmallCaramelCake : SmallCake
{
public override void CakeTaste()
{
Console.WriteLine(“小焦糖口味蛋糕”);
}
}
//定义小奶油味蛋糕
public class SmallCreamCake : SmallCake
{
public override void CakeTaste()
{
Console.WriteLine(“小奶油口味蛋糕”);
}
}
定义抽象工厂类
//定义抽象蛋糕工厂
public abstract class Factory
{
public abstract BigCake ProducteBigCake();
public abstract SmallCake ProducteSmallCake();
}
不同口味的工厂继承这个抽象类
//定义生产香草口味的蛋糕工厂
public class VanillaCakeFactory_ : Factory
{
public override BigCake ProducteBigCake()
{
return new BigVanillaCake();
}
public override SmallCake ProducteSmallCake()
{
return new SmallVanillaCake();
}
}
//定义生产焦糖口味的蛋糕工厂
public class CaramelCakeFactory_ : Factory
{
public override BigCake ProducteBigCake()
{
return new BigCaramelCake();
}
public override SmallCake ProducteSmallCake()
{
return new SmallCaramelCake();
}
}
//定义生产奶油口味的蛋糕工厂
public class CreamCakeFactory_ : Factory
{
public override BigCake ProducteBigCake()
{
return new BigCreamCake();
}
public override SmallCake ProducteSmallCake()
{
return new SmallCreamCake();
}
}
客户端操作
public class Client_2
{
public static void main(String[] args)
{
//生产香草味
Factory vanillaCakeFactory = new VanillaCakeFactory_();
BigCake vanillaCakeBig = vanillaCakeFactory.ProducteBigCake();
vanillaCakeBig.CakeTaste();
SmallCake vanillaCakeSmall = vanillaCakeFactory.ProducteSmallCake();
vanillaCakeSmall.CakeTaste();
//生产焦糖味
Factory caramelCakeFactory = new CaramelCakeFactory_();
BigCake caramelCakeBig = caramelCakeFactory.ProducteBigCake();
caramelCakeBig.CakeTaste();
SmallCake caramelCakeSmall = caramelCakeFactory.ProducteSmallCake();
caramelCakeSmall.CakeTaste();
//生产奶油味
Factory creamCakeFactory = new CreamCakeFactory_();
BigCake creamCakeBig = creamCakeFactory.ProducteBigCake();
creamCakeBig.CakeTaste();
SmallCake creamCakeSmall = creamCakeFactory.ProducteSmallCake();
creamCakeSmall.CakeTaste();
}
}
之所以叫抽象工厂，是因为和工厂方法相比每个抽象产品类可以派生出多个具体的产品，生产的是系列产品，其工厂接口相对于工厂方法模式而言，是有多个方法的，用来生产不同的抽象产品。
不过，我们也很容易看出，抽象工厂模式的弊端。比如现在，蛋糕的想要提供的是大、中、小三种系列产品，那么现在，需要改动的代码就有点多了。首先需要创建一个接口，用来生产中份的冰激凌，然后还要实现具体的类，还需要修改工厂接口，并修改具体的工厂类。

本内容为个人理解，若有错误请指出，部分借鉴于网上。