抽象工厂模式

简介

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供了一种接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。
抽象工厂模式通过引入抽象工厂类和具体工厂类的层次结构，使得客户端可以根据所需的产品族选择对应的工厂，进而创建一系列相关对象。
抽象工厂模式适用于需要创建多个相互关联的产品对象，并且希望避免客户端直接依赖具体产品类的情况。

示例

假设我们的汽车公司生产不同类型的车型，每种类型的车型在不同地区都有不同的特点。

using System;

// 抽象汽车工厂类
public abstract class AbstractCarFactory
{
    public abstract AbstractSedan CreateSedan();
    public abstract AbstractSUV CreateSUV();
}

// 瑞士汽车工厂，生产雪地性能好的汽车
public class SwissCarFactory : AbstractCarFactory
{
    public override AbstractSedan CreateSedan()
    {
        return new SwissSedan();
    }

    public override AbstractSUV CreateSUV()
    {
        return new SwissSUV();
    }
}

// 沙特汽车工厂，生产耐高温性能好的汽车
public class SaudiCarFactory : AbstractCarFactory
{
    public override AbstractSedan CreateSedan()
    {
        return new SaudiSedan();
    }

    public override AbstractSUV CreateSUV()
    {
        return new SaudiSUV();
    }
}

// 抽象轿车类
public abstract class AbstractSedan
{
    public abstract void Drive();
}

// 瑞士轿车，具有雪地性能
public class SwissSedan : AbstractSedan
{
    public override void Drive()
    {
        Console.WriteLine("Driving sedan in the snow with Swiss car.");
    }
}

// 沙特轿车，具有耐高温性能
public class SaudiSedan : AbstractSedan
{
    public override void Drive()
    {
        Console.WriteLine("Driving sedan in the desert with Saudi car.");
    }
}

// 抽象SUV类
public abstract class AbstractSUV
{
    public abstract void Drive();
}

// 瑞士SUV，具有雪地性能
public class SwissSUV : AbstractSUV
{
    public override void Drive()
    {
        Console.WriteLine("Driving SUV in the snow with Swiss car.");
    }
}

// 沙特SUV，具有耐高温性能
public class SaudiSUV : AbstractSUV
{
    public override void Drive()
    {
        Console.WriteLine("Driving SUV in the desert with Saudi car.");
    }
}
class Program
{
    static void Main(string[] args)
    {
        AbstractCarFactory swissFactory = new SwissCarFactory();
        AbstractSedan swissSedan = swissFactory.CreateSedan();
        AbstractSUV swissSUV = swissFactory.CreateSUV();

        swissSedan.Drive();
        swissSUV.Drive();

        AbstractCarFactory saudiFactory = new SaudiCarFactory();
        AbstractSedan saudiSedan = saudiFactory.CreateSedan();
        AbstractSUV saudiSUV = saudiFactory.CreateSUV();

        saudiSedan.Drive();
        saudiSUV.Drive();
    }
}

 

在这个例子中，每个工厂方法负责生产一系列车型的不同产品。 SwissCarFactory 负责生产瑞士的轿车和SUV，而 SaudiCarFactory 负责生产沙特的轿车和SUV。这样，每个具体工厂类都负责一系列产品的创建。

此时再增加一个商务车类型

// 抽象商务车类
public abstract class AbstractMinivan
{
    public abstract void Drive();
}

// 瑞士商务车
public class SwissMinivan : AbstractMinivan
{
    public override void Drive()
    {
        Console.WriteLine("Driving minivan on business trips with Swiss car.");
    }
}

// 沙特商务车
public class SaudiMinivan : AbstractMinivan
{
    public override void Drive()
    {
        Console.WriteLine("Driving minivan on business trips with Saudi car.");
    }
}

// 抽象汽车工厂类
public abstract class AbstractCarFactory
{
    public abstract AbstractSedan CreateSedan();
    public abstract AbstractSUV CreateSUV();
    public abstract AbstractMinivan CreateMinivan();
}

// 瑞士汽车工厂，生产雪地性能好的汽车
public class SwissCarFactory : AbstractCarFactory
{
    public override AbstractSedan CreateSedan()
    {
        return new SwissSedan();
    }

    public override AbstractSUV CreateSUV()
    {
        return new SwissSUV();
    }

    public override AbstractMinivan CreateMinivan()
    {
        return new SwissMinivan();
    }
}

// 沙特汽车工厂，生产耐高温性能好的汽车
public class SaudiCarFactory : AbstractCarFactory
{
    public override AbstractSedan CreateSedan()
    {
        return new SaudiSedan();
    }

    public override AbstractSUV CreateSUV()
    {
        return new SaudiSUV();
    }

    public override AbstractMinivan CreateMinivan()
    {
        return new SaudiMinivan();
    }
}

class Program
{
    static void Main(string[] args)
    {
        AbstractCarFactory swissFactory = new SwissCarFactory();
        AbstractSedan swissSedan = swissFactory.CreateSedan();
        AbstractSUV swissSUV = swissFactory.CreateSUV();
        AbstractMinivan swissMinivan = swissFactory.CreateMinivan();

        swissSedan.Drive();
        swissSUV.Drive();
        swissMinivan.Drive();

        AbstractCarFactory saudiFactory = new SaudiCarFactory();
        AbstractSedan saudiSedan = saudiFactory.CreateSedan();
        AbstractSUV saudiSUV = saudiFactory.CreateSUV();
        AbstractMinivan saudiMinivan = saudiFactory.CreateMinivan();

        saudiSedan.Drive();
        saudiSUV.Drive();
        saudiMinivan.Drive();
    }
}

 

优点：

1. 抽象工厂模式提供了一种创建一系列相关或相互依赖对象的方式，客户端无需直接关注对象的创建细节。
2. 客户端通过选择不同的具体工厂类，可以创建一系列相关的产品对象，提高了系统的灵活性和可扩展性。
3. 抽象工厂模式将对象的创建与使用解耦，使得客户端与具体产品类解耦，降低了系统的耦合度。

缺点：

1. 添加新的产品等级结构（新的产品族）时，需要修改抽象工厂接口及所有具体工厂类，违反了开闭原则。
2. 抽象工厂模式在增加新产品族时可能会导致类的数量激增，增加了系统的复杂度。
3. 不太容易支持新种类的产品，因为抽象工厂接口中已经确定了一系列产品的种类，无法灵活地增加新种类的产品。