软件设计：设计模式-创建型-抽象工厂模式

　　抽象工厂模式是所有形态的工厂设计模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

　　前一章节，我们介绍了简单工厂模式以及工厂方法模式，但是这两种模式都存在一定的局限性，只能生产某一类型下的某一种产品，如果需求变更，同类型下出现了不同的产品，比如芝士披萨不仅有口味上的不同，同时存在外观上的不同。这种时候，工厂模式显然不再满足要求，该怎么办呢？于是我们想到DIP原则，它不正是为了解决这种情况而存在的吗？接下来我们来介绍下抽象工厂模式：

　　1、抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

　　2、抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

　　3、从设计层面来说，抽象工厂模式就是对简单工厂模式的改进（即进一步抽象化）

　　4、将工厂抽象成两层，抽象工厂和具体的实现工厂。

　　还是拿pizza订购举例,我们定义一个抽象工厂AbsFactory，由子类工厂实现该抽象工厂；订购披萨OrderPizza依赖抽象，不依赖具体的实现。

　　internalclassProgram

　　{

　　privatestaticvoidMain(string[]args)

　　{

　　newOrderPizza(newBJFactory());

　　}

　　}

　　internalclassOrderPizza

　　{

　　privateAbsFactoryfactory;

　　publicOrderPizza(AbsFactoryfactory)

　　{

　　setFactory(factory);

　　Order();

　　}

　　privatevoidsetFactory(AbsFactoryfactory)

　　{

　　this.factory=factory;

　　}

　　privatevoidOrder()

　　{

　　Pizzapizza=null;

　　stringorderType="";

　　do

　　{

　　Console.Write("请输入订购类型：");

　　orderType=Console.ReadLine();

　　pizza=this.factory.createPizza(orderType);

　　if(pizza==null)

　　{

　　Console.WriteLine("订购失败");

　　break;

　　}

　　//开始制作

　　pizza.prepare();

　　pizza.bake();

　　pizza.cut();

　　pizza.box();

　　}while(true);

　　}

　　}

　　internalinterfaceAbsFactory

　　{

　　PizzacreatePizza(stringorderType);

　　}

　　internalclassBJFactory:AbsFactory

　　{

　　publicPizzacreatePizza(stringorderType)

　　{

　　Pizzapizza=null;

　　if(orderType=="cheese")

　　{

　　pizza=newBJCheesePizza();

　　pizza.setName("北京芝士披萨");

　　}

　　elseif(orderType=="greek")

　　{

　　pizza=newBJGreekPizza();

　　pizza.setName("北京希腊披萨");

　　}

　　returnpizza;

　　}

　　}

　　internalclassLDFactory:AbsFactory

　　{

　　publicPizzacreatePizza(stringorderType)

　　{

　　Pizzapizza=null;

　　if(orderType=="cheese")

　　{

　　pizza=newLDCheesePizza();

　　pizza.setName("伦敦芝士披萨");

　　}

　　elseif(orderType=="greek")

　　{

　　pizza=newLDGreekPizza();

　　pizza.setName("伦敦希腊披萨");

　　}

　　returnpizza;

　　}

　　}

　　internalabstractclassPizza

　　{

　　privatestringname;

　　publicabstractvoidprepare();

　　publicvoidbake()

　　{

　　Console.WriteLine($"{this.name}烘培");

　　}

　　publicvoidcut()

　　{

　　Console.WriteLine($"{this.name}修剪");

　　}

　　publicvoidbox()

　　{

　　Console.WriteLine($"{this.name}打包");

　　}

　　publicvoidsetName(stringname)

　　{

　　this.name=name;

　　}

　　}

　　internalclassBJCheesePizza:Pizza

　　{

　　publicoverridevoidprepare()

　　{

　　Console.WriteLine("北京的芝士披萨准备中");

　　}

　　}

　　internalclassBJGreekPizza:Pizza

　　{

　　publicoverridevoidprepare()

　　{

　　Console.WriteLine("北京的希腊披萨准备中");

　　}

　　}

　　internalclassLDCheesePizza:Pizza

　　{

　　publicoverridevoidprepare()

　　{

　　Console.WriteLine("伦敦的芝士披萨准备中");

　　}

　　}

　　internalclassLDGreekPizza:Pizza

　　{

　　publicoverridevoidprepare()

　　{

　　Console.WriteLine("伦敦的希腊披萨准备中");

　　}

　　}

　　读过一些博主的博文以及评论，有一些理解还是蛮到位的：

　　1、抽象工厂比工厂方法复杂的多，它们的目的不同。工厂方法意在延迟加载，而抽象方法意在高内聚低耦合。

　　2、工厂方法模式的具体工厂类只能创建一个具体具体产品类的实例，而抽象工厂可以创建多个。

　　根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。