（二）创建型—抽象工厂（Abstract Factory）

发表于 作者 chpdirector

常规的对象创建方法：Road road =new Road();

new 的问题：实现依赖，不能应对“具体实例化类型”的变化。

解决思路：封装变化点—–哪里变化，封装哪里

工厂模式的缘起：

  •     变化点在“对象创建”，因此就封装“对象创建”
  •     面向接口编程—-依赖接口，而非依赖实现

最简单的解决方法：

class RoadFactory
{
    public static Road CreateRoad()
    {    
        return new Road(); 
    }
}
//创建一个Road对象
Road road=roadFactory.CreateRoad();

创建一系列相互依赖对象的创建工作：假设一个游戏开场景，我们需要构造”道路”、”房屋”、”地道”，”从林”…等等对象

工厂方法如下：

class RoadFactory
{
    public static Road CreateRoad()
    {
        return new Road();
    }
    public static Building CreateBuilding()
    {
        return new Building();
    }
    public static Tunnel CreateTunnel()
    {
        return new Tunnel();
    }
    public static Jungle CreateJungle()
    {
        return new Jungle();
    }
}

调用方式如下：

Road road =  RoadFactory.CreateRoad();
Building building = RoadFactory.CreateBuilding();
Tunnel tunnel = RoadFactory.CreateTunnel();
Jungle jungle = RoadFactory.CreateJungle();

简单工厂的问题：

不能应对”不同系列对象”的变化。比如有不同风格的场景—对应不同风格的道路，房屋、地道….

如何解决：

使用面向对象的技术来”封装”变化点。

动机：

在软件系统中，经常面临着”一系统相互依赖的对象”的创建工作：同时，由于需求的变化，往往存在更多系列对象的创建工作。

意图：   

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

结构图：

适用性：

  • 一个系统要独立于它的产品的创建、组合和表示时。
  • 一个系统要由多个产品系统中的一个来配置时。
  • 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
  • 当你提供一个产品类库，而只想显示它们的接口不是实现时。

结构图代码实现：

abstract class AbstractFactory
{
    public abstract AbstractProductA CreateProductA();
    public abstract AbstractProductB CreateProductB();
}
abstract class AbstractProductA
{
    public abstract void Interact(AbstractProductB b);
}
abstract class AbstractProductB
{
    public abstract void Interact(AbstractProductA a);
}
class Client
{
    private AbstractProductA AbstractProductA;
    private AbstractProductB AbstractProductB;
    public Client(AbstractFactory factory)
    {
        AbstractProductA = factory.CreateProductA();
        AbstractProductB = factory.CreateProductB();
    }
    public void Run()
    {
        AbstractProductB.Interact(AbstractProductA);
        AbstractProductA.Interact(AbstractProductB);
    }
}
class ConcreteFactory1 : AbstractFactory
{
    public override AbstractProductA CreateProductA()
    {
        return new ProductA1();
    }
    public override AbstractProductB CreateProductB()
    {
        return new ProductB1();
    }
}
class ConcreteFactory2 : AbstractFactory
{
    public override AbstractProductA CreateProductA()
    {
        return new ProdcutA2();
    }
    public override AbstractProductB CreateProductB()
    {
        return new ProductB2();
    }
}
class ProductA1 : AbstractProductA
{
    public override void Interact(AbstractProductB b)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
    }
}
class ProdcutA2 : AbstractProductA
{
    public override void Interact(AbstractProductB b)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
    }
}
class ProductB1 : AbstractProductB
{
    public override void Interact(AbstractProductA a)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
    }
}
class ProductB2 : AbstractProductB
{
    public override void Interact(AbstractProductA a)
    {
        Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
    }
}
public static void Main()
{
    // Abstractfactory1
    AbstractFactory factory1 = new ConcreteFactory1();
    Client c1 = new Client(factory1);
    c1.Run();

    // Abstractfactory2
    AbstractFactory factory2 = new ConcreteFactory2();
    Client c2 = new Client(factory2);
    c2.Run();
}

Abstract Factory注意的几点：

  • 如果不存在”多系列对象创建“的需求变化，则没必要应用Abstract Factory模式，静态工厂方法足矣。
  • “系列对象”指的是这些对象之间有相互依赖、或作用的关系。例如游戏开发场景中的”道路”与”房屋”依赖，“道路”与“地道”的依赖。
  • Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对”新对象“的需求变动。
  • Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。

发表回复