抽象工厂模式(Abstract Factory)

模式定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
分析：抽象工厂模式中的工厂类负责创建多种相关产品，工厂模式中的工厂类只负责创建一种产品。
关联定义
产品等级结构: 继承于同一抽象类的产品
产品族: 由同一工厂类生产的产品

UML类图

? AbstractFactory：抽象工厂
? ConcreteFactory：具体工厂
? AbstractProduct：抽象产品
? Product：具体产品

代码结构

    public static class AbstractFactoryAPP
    {
        public static void Run()
        {
            AbstractFactory factory1 = new ConcreteFactory1();
            AbstractProductA productA1 = factory1.CreateProductA();
            AbstractProductB productB1 = factory1.CreateProductB();
            productB1.Interact(productA1);
        }
    }

    public abstract class AbstractProductA
    { }

    public class ProductA1 : AbstractProductA
    { }

    public class ProductA2 : AbstractProductA
    { }

    public abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    public class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
        }
    }

    public class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
        }
    }

    public abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    public class ConcreteFactory1:AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }
    public class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

情景案例

现在好多公司都在做自己的生态圈，好像只要利润的产品都生产（比如做手机的非要造汽车）。本例子举海尔与美的两家电器商，海尔与美的都生产冰箱与空调。冰箱、空调为抽象产品，海尔、美的为两个具体工厂。

    public static class AbstractFactoryAPP
    {
        public static void Run()
        {
            Company haier = new HaierCompany();
            AirConditioner productA1 = haier.CreateProductA();
            Refrigerator productB1 = haier.CreateProductB();
            productB1.Interact(productA1);
        }
    }

    public abstract class AirConditioner
    { }

    public class HaierAir : AirConditioner
    { }

    public class MideaAir : AirConditioner
    { }

    public abstract class Refrigerator
    {
        public abstract void Interact(AirConditioner a);
    }

    public class HaierRefrigerator : Refrigerator
    {
        public override void Interact(AirConditioner a)
        {
            Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
        }
    }

    public class MideaRefrigerator : Refrigerator
    {
        public override void Interact(AirConditioner a)
        {
            Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
        }
    }

    public abstract class Company
    {
        public abstract AirConditioner CreateProductA();
        public abstract Refrigerator CreateProductB();
    }

    public class HaierCompany : Company
    {
        public override AirConditioner CreateProductA()
        {
            return new HaierAir();
        }
        public override Refrigerator CreateProductB()
        {
            return new HaierRefrigerator();
        }
    }
    public class MediaCompany : Company
    {
        public override AirConditioner CreateProductA()
        {
            return new MideaAir();
        }
        public override Refrigerator CreateProductB()
        {
            return new MideaRefrigerator();
        }
    }