索引
别名
意图
结构
参与者
适用性
缺点
效果
相关模式
命名约定
实现
实现方式（一）：使用 Factory Method 来实现 Abstract Factory。
实现方式（二）：使用 Prototype 来实现 Abstract Factory。
实现方式（三）：定义可扩展的 Abstract Factory。
实现方式（四）：使用模板以避免创建子类。
别名
Kit
意图
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
结构
参与者
AbstractFactory
声明一个创建抽象产品对象的操作接口。
ConcreteFactory
实现创建具体产品对象的操作。
AbstractProduct
为一类产品对象声明一个接口。
ConcreteProduct
定义一个将被相应的具体工厂创建的产品对象。
实现 AbstractProduct 接口。
Client
仅适用由 AbstractFactory 和 AbstractProduct 类声明的接口。
适用性
在以下情况下可以使用 Abstract Factory 模式：
一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时。
当你提供一个产品类库，而只想显示它们的接口而不是实现时。
缺点
难以支持新种类的产品。支持新种类的产品就需要扩展 AbstractFactory 接口，这将引起所有子类的改变。
效果
它分离了具体的类。
它使得易于交换产品系列。
它有利于产品的一致性。
相关模式
Abstract Factory 经常用 Factory Method 来实现。
Abstract Factory 也可以用 Prototype来实现。
一个具体的工厂可以是一个 Singleton。
命名约定
使用命名约定是一个好习惯，例如，总是声明那些定义为抽象工厂的类为 XxxKit。
实现
实现方式（一）：使用 Factory Method 来实现 Abstract Factory。
一个具体的工厂将为每个产品重定义该工厂方法以指定产品。
namespace AbstractFactoryPattern.Implementation1
{
public abstract class AbstractOrInterfaceOfFactoryKit
{
public abstract AbstractOrInterfaceOfProductA CreateProductA();
public abstract AbstractOrInterfaceOfProductB CreateProductB();
} public abstract class AbstractOrInterfaceOfProductA
{
} public abstract class AbstractOrInterfaceOfProductB
{
} public class ConcreteFactoryKit1 : AbstractOrInterfaceOfFactoryKit
{
public override AbstractOrInterfaceOfProductA CreateProductA()
{
return new ConcreteProductA();
} public override AbstractOrInterfaceOfProductB CreateProductB()
{
return new ConcreteProductB();
}
} public class ConcreteProductA : AbstractOrInterfaceOfProductA
{
} public class ConcreteProductB : AbstractOrInterfaceOfProductB
{
} public class Client
{
public void TestCase1()
{
AbstractOrInterfaceOfFactoryKit kit = new ConcreteFactoryKit1();
AbstractOrInterfaceOfProductA productA = kit.CreateProductA();
AbstractOrInterfaceOfProductB productB = kit.CreateProductB();
}
}
}
实现方式（二）：使用 Prototype 来实现 Abstract Factory。
具体工厂使用产品系列中每一个产品的原型实例来初始化，且它通过复制它的原型来创建新的产品。
namespace AbstractFactoryPattern.Implementation2
{
public abstract class AbstractOrInterfaceOfFactoryKit
{
public abstract AbstractOrInterfaceOfProductA CreateProductA();
public abstract AbstractOrInterfaceOfProductB CreateProductB();
} public abstract class AbstractOrInterfaceOfProductA
{
public abstract AbstractOrInterfaceOfProductA Clone();
} public abstract class AbstractOrInterfaceOfProductB
{
public abstract AbstractOrInterfaceOfProductB Clone();
} public class ConcreteFactoryKit1 : AbstractOrInterfaceOfFactoryKit
{
public override AbstractOrInterfaceOfProductA CreateProductA()
{
return new ConcreteProductA();
} public override AbstractOrInterfaceOfProductB CreateProductB()
{
return new ConcreteProductB();
}
} public class ConcreteFactoryKit2 : AbstractOrInterfaceOfFactoryKit
{
private AbstractOrInterfaceOfProductA _prototypeOfProductA;
private AbstractOrInterfaceOfProductB _prototypeOfProductB; public ConcreteFactoryKit2(
AbstractOrInterfaceOfProductA prototypeOfProductA,
AbstractOrInterfaceOfProductB prototypeOfProductB)
{
_prototypeOfProductA = prototypeOfProductA;
_prototypeOfProductB = prototypeOfProductB;
} public override AbstractOrInterfaceOfProductA CreateProductA()
{
return _prototypeOfProductA.Clone();
} public override AbstractOrInterfaceOfProductB CreateProductB()
{
return _prototypeOfProductB.Clone();
}
} public class ConcreteProductA : AbstractOrInterfaceOfProductA
{
public override AbstractOrInterfaceOfProductA Clone()
{
return new ConcreteProductA();
}
} public class ConcreteProductB : AbstractOrInterfaceOfProductB
{
public override AbstractOrInterfaceOfProductB Clone()
{
return new ConcreteProductB();
}
} public class Client
{
public void TestCase2()
{
AbstractOrInterfaceOfFactoryKit kit1 = new ConcreteFactoryKit1();
AbstractOrInterfaceOfProductA productA1 = kit1.CreateProductA();
AbstractOrInterfaceOfProductB productB1 = kit1.CreateProductB(); AbstractOrInterfaceOfFactoryKit kit2 = new ConcreteFactoryKit2(productA1, productB1);
AbstractOrInterfaceOfProductA productA2 = kit2.CreateProductA();
AbstractOrInterfaceOfProductB productB2 = kit2.CreateProductB();
}
}
}
实现方式（三）：定义可扩展的 Abstract Factory。
Abstract Factory 通常为每一种它可以生产的产品定义一个操作。产品的种类被编码在操作型构中。
增加一种新的产品要求改变 Abstract Factory 的接口以及所有与它相关的类。
一个更灵活但不太安全的设计是给创建对象的操作增加一个参数。该参数指定了将被创建的对象的种类。
该参数可以是一个类标识符、一个整数、一个字符串，或其他任何可以标识这种产品的东西。
这样改动之后，Abstract Factory 只需要一个 "Make" 操作和一个指示要创建对象的种类的参数。
namespace AbstractFactoryPattern.Implementation3
{
public enum ProductCategory
{
ProductA,
ProductB,
} public abstract class AbstractOrInterfaceOfFactoryKit
{
public abstract object CreateProduct(ProductCategory category);
} public abstract class AbstractOrInterfaceOfProductA
{
} public abstract class AbstractOrInterfaceOfProductB
{
} public class ConcreteFactoryKit1 : AbstractOrInterfaceOfFactoryKit
{
public override object CreateProduct(ProductCategory category)
{
switch (category)
{
case ProductCategory.ProductA:
return new ConcreteProductA();
case ProductCategory.ProductB:
return new ConcreteProductB();
default:
throw new NotSupportedException();
}
}
} public class ConcreteProductA : AbstractOrInterfaceOfProductA
{
} public class ConcreteProductB : AbstractOrInterfaceOfProductB
{
} public class Client
{
public void TestCase3()
{
AbstractOrInterfaceOfFactoryKit kit = new ConcreteFactoryKit1();
AbstractOrInterfaceOfProductA productA = (AbstractOrInterfaceOfProductA)kit.CreateProduct(ProductCategory.ProductA);
AbstractOrInterfaceOfProductB productB = (AbstractOrInterfaceOfProductB)kit.CreateProduct(ProductCategory.ProductB);
}
}
}
实现方式（四）：使用模板以避免创建子类。
使用C#中的泛型实现抽象工厂。
namespace AbstractFactoryPattern.Implementation4
{
public abstract class AbstractOrInterfaceOfFactoryKit
{
public abstract AbstractOrInterfaceOfProductA CreateProductA();
public abstract AbstractOrInterfaceOfProductB CreateProductB();
public abstract AbstractOrInterfaceOfProductC CreateProductC<TC>()
where TC : AbstractOrInterfaceOfProductC, new();
} public abstract class AbstractOrInterfaceOfProductA
{
} public abstract class AbstractOrInterfaceOfProductB
{
} public abstract class AbstractOrInterfaceOfProductC
{
} public class ConcreteFactoryKit1<TA, TB> : AbstractOrInterfaceOfFactoryKit
where TA : AbstractOrInterfaceOfProductA, new()
where TB : AbstractOrInterfaceOfProductB, new()
{
public override AbstractOrInterfaceOfProductA CreateProductA()
{
return new TA();
} public override AbstractOrInterfaceOfProductB CreateProductB()
{
return new TB();
} public override AbstractOrInterfaceOfProductC CreateProductC<TC>()
{
return new TC();
}
} public class ConcreteProductA : AbstractOrInterfaceOfProductA
{
} public class ConcreteProductB : AbstractOrInterfaceOfProductB
{
} public class ConcreteProductC : AbstractOrInterfaceOfProductC
{
} public class Client
{
public void TestCase4()
{
AbstractOrInterfaceOfFactoryKit kit = new ConcreteFactoryKit1<ConcreteProductA, ConcreteProductB>();
AbstractOrInterfaceOfProductA productA = kit.CreateProductA();
AbstractOrInterfaceOfProductB productB = kit.CreateProductB();
AbstractOrInterfaceOfProductC productC = kit.CreateProductC<ConcreteProductC>();
}
}
}
《设计模式之美》为 Dennis Gao 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。
