设计模式-抽象工厂模式

设计模式-抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）

工厂方法模式：针对单一对象的创建

抽象工厂模式：针对一组对象的创建

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

上篇文章中讲解了工厂方法，这篇文章为了说明问题，现在加入Server这个基类，也就是说Server和PC是同等级别的，PC下面包括各种品牌，Server下面同样包括各种品牌。

先看下UML模型图



个人电脑基类

abstract class PC
{
private string name;

public PC(string name)
{
this.name = name;
}

public virtual string Name { get { return name; } set { name = value; } }

public abstract void Describe();
}

Dell电脑具体类

class DellPC : PC
{
public DellPC(string name) : base(name)
{

}

public override void Describe()
{
System.Console.WriteLine("I am {0} personal computer", Name);
}
}

IBM电脑具体类

class IBMPC : PC
{
public IBMPC(string name) : base(name)
{

}

public override void Describe()
{
System.Console.WriteLine("I am {0} personal computer", Name);
}
}

服务器基类

abstract class Server
{
private string name;

public Server(string name)
{
this.name = name;
}

public virtual string Name { get { return name; } set { name = value; } }

public abstract void Describe();
}

Dell服务器具体类

class DellServer : Server
{
public DellServer(string name) : base(name)
{

}

public override void Describe()
{
System.Console.WriteLine("I am {0} server", Name);
}
}

IBM服务器具体类

class IBMServer : Server
{
public IBMServer(string name) : base(name)
{

}

public override void Describe()
{
System.Console.WriteLine("I am {0} server", Name);
}
}

抽象工厂

abstract class Factory
{
public abstract PC CreatePC();//生产电脑
public abstract Server CreateServer();//生产服务器
}

具体Dell工厂

class DellFactory : Factory
{
public override PC CreatePC()
{
return new DellPC("DellPC");//生产Dell电脑
}

public override Server CreateServer()
{
return new DellServer("DellServe");//生产Dell服务器
}
}

具体IBM工厂

class IBMFactory : Factory
{
public override PC CreatePC()
{
return new IBMPC("IBMPC");//生产IBM电脑
}
public override Server CreateServer()
{
return new IBMServer("IBMServer");//生产IBM服务器
}
}

以下代码是错误的类别划分方式

abstract class DellInc { }  //Dell公司的产品
class dpc : DellInc { }     //Dell电脑
class dsrv : DellInc { }    //Dell服务器

abstract class IBMInc { }
4000
//IBM公司的产品
class ipc : IBMInc { }      //IBM电脑
class isrv : IBMInc { }     //IBM服务器

abstract class FactoryMix   //混合工厂
{
public abstract DellInc CreateDell();   //生产Dell产品
public abstract IBMInc CreateIBM();     //生产IBM产品
//假设这里再来一个HP呢，可想而知情况将会变得多么复杂
}
abstract class Dell_Factory : FactoryMix
{
public abstract dpc CreateDellPC();     //生产Dell电脑
public abstract dsrv CreateDellServer();//生产Dell服务器
//请问IBM产品在这里实现吗，注意为了说明问题现在Dell_Factory是抽象类
}

abstract class IBM_Factory : FactoryMix
{
public abstract ipc CreateIBMPC();      //生产IBM电脑
public abstract isrv CreateIBMServer(); //生产IBM服务器
}

class Dell_Factory2 : FactoryMix
{
//又或者同时实现4样产品
public override DellInc CreateDell() { return new dpc(); }      //只能生产Dell电脑
//public override DellInc CreateDell() { return new dsrv(); }   //或者只生产Dell服务器
public override IBMInc CreateIBM() { return new ipc(); }        //只能生产IBM电脑
//public override IBMInc CreateIBM() { return new isrv(); }     //或者只生产IBM服务器
}

调用方式

Console.WriteLine("Dell Production");

Factory dellfactory = new DellFactory();        //Create dell factory

PC dellpc = dellfactory.CreatePC();             //make dell pc
dellpc.Name = "d-pc";
dellpc.Describe();

Server dellserver = dellfactory.CreateServer(); //make dell server
dellpc.Name = "d-srv";
dellserver.Describe();

Console.Write("\n");
System.Console.WriteLine("IBM Production");

Factory ibmfactory = new IBMFactory();           //Create ibm factory

PC ibmpc = ibmfactory.CreatePC();                //make ibm pc
ibmpc.Name = "R60e";
ibmpc.Describe();

Server ibmserver = ibmfactory.CreateServer();    //make ibm server
ibmserver.Name = "x860";
ibmserver.Describe();

运行结果



抽象工厂模式的优点

抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

抽象工厂模式的缺点

产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

适用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

版权所有，转载请注明文章出处 http://blog/csdn.net/cadenzasolo