设计模式之抽象工厂

一、抽象工厂：不管是简单工厂还是工厂方法，他们创建的都是同一类对象，有时候需要一组一组的创建对象，如果需要创建一组对象，抽象工厂是最好的方式，而抽象工厂的目的旨在创建一组包含多种不同类的对象。

二、实现思路 ：对每一组对象都创建一个对应的工厂类，这个工厂类包含了这组对象的中所有对象的创建方法。

三、代码举例： 

抽象类Factory：

namespace AbstractFactory
{
    public abstract class Factory
    {
        public abstract Mainboard CreateMainboard();
        public abstract Cpu CreateCpu();
    }
}

 抽象类cpu：

namespace AbstractFactory
{
    public abstract class Cpu
    {
        public abstract void RunCalculate();
    }
}

 抽象类Mainboard：

namespace AbstractFactory
{
    public abstract class Mainboard
    {
        public abstract void LoadCpu();
    }
}

 实现类AmdCpu：

namespace AbstractFactory
{
    public class AmdCpu:Cpu
    {
        public override void RunCalculate()
        {
            Console.WriteLine("AmdCpu正在执行计算任务！");
        }
    }
}

 实现类IntelCpu：

namespace AbstractFactory
{
    public class IntelCpu : Cpu
    {
        public override void RunCalculate()
        {
            Console.WriteLine("IntelCpu在执行计算任务！");
        }
    }
}

 实现类AmdMainboard：

namespace AbstractFactory
{
    public class AmdMainboard : Mainboard
    {
        public override void LoadCpu()
        {
            Console.WriteLine("Amd主板装载了Cpu！");
        }
    }
}

 实现类IntelMainboard：

namespace AbstractFactory
{
    public class IntelMainboard : Mainboard
    {
        public override void LoadCpu()
        {
            Console.WriteLine("Intel主板装载了Cpu！");
        }
    }
}

 实现类AmdFactory：

namespace AbstractFactory
{
    public class AmdFactory : Factory
    {
        public override Cpu CreateCpu()
        {
            Console.WriteLine("Amd公司生产了AmdCpu");
            return new AmdCpu();
        }

        public override Mainboard CreateMainboard()
        {
            Console.WriteLine("Amd公司生产了Amd主板");
            return new AmdMainboard();
        }
    }
}

 实现类IntelFactory：

namespace AbstractFactory
{
    public class IntelFactory : Factory
    {
        public override Cpu CreateCpu()
        {
            Console.WriteLine("Intel公司生产了IntelCpu");
            return new IntelCpu();
        }

        public override Mainboard CreateMainboard()
        {
            Console.WriteLine("Intel公司生产了Intel主板");
            return new IntelMainboard();
        }
    }
}

 客户类：

  {  //抽象工厂：专用于创建一组对象，每个工厂提供多个对象的创建，本例中cpu和mainboard合起来就是一组对象,本模式中有2种对应（业务类抽象和业务类实现，工厂类抽象和工厂类实现），共4种角色
       AbstractFactory.Factory amdfac = new AbstractFactory.AmdFactory();
       AbstractFactory.Cpu  amdcpu= amdfac.CreateCpu();     
       AbstractFactory.Mainboard amdmainboard= amdfac.CreateMainboard();
       amdmainboard.LoadCpu();
       amdcpu.RunCalculate();
       AbstractFactory.Factory Intelfac = new AbstractFactory.IntelFactory();
       AbstractFactory.Cpu Intelcpu = Intelfac.CreateCpu();
       AbstractFactory.Mainboard Intelmainboard = Intelfac.CreateMainboard();
       Intelmainboard.LoadCpu();
       Intelcpu.RunCalculate();
    }

运行结果：

四、抽象工厂的优缺点及应用：抽象工厂适合扩展需要增加一组对象（产品簇）的情况，不适合对一组对象中增加某一类对象（工厂职责不能扩展）的情况，所以当工厂的职责不能确定的情况下 不要使用抽象工厂。

标签：Mainboard,class,namespace,public,工厂,抽象,AbstractFactory,设计模式,Cpu
来源： https://www.cnblogs.com/zqhIndex/p/10284510.html