抽象工厂模式

使用抽象工厂模式来解决问题

定义

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

应用抽象工厂模式来解决问题的思路

这里要解决的问题是，要创建一系列的产品对象，而且这一系列对象是构建新的对象所需要的组成部分，也就是这一系列被创建的对象相互之间是有约束的。

解决这个问题的一个解决方案就是抽象工厂模式。在这个模式里面，会定义一个抽象工厂，在里面虚拟地创建客户端需要的这一系列对象，所谓虚拟的就是定义创建这些对象的抽象方法，并不去真正地实现，然后由具体的抽象工厂的子类来提供这一系列对象的创建。这样一来可以为同一个抽象工厂提供很多不同的实现，那么创建的这一系列对象也就不一样了，也就是说，抽象工厂在这里起到一个约束的作用，并提供所有子类的一个统一外观，来让客户端使用。

抽象工厂模式的结构和说明

• Abstract Factory:抽象工厂，定义创建一系列产品对象的操作接口。
• Concrete Factory:具体的工厂，实现抽象工厂定义的方法，具体实现一系列产品对象的创建。
• Abstract Product;定义一类产品对象的接口。
• Concrete Product:具体的产品实现对象，通常在具体工厂里面，会选择具体的产品实现对象，来创建符合抽象工厂定义的方法返回的产品类型的对象。
• Clicnt: 客户端，主要使用抽象工厂来获取一系列所需要的产品对象，然后面向这些产品对象的接口编程，以实现需要的功能。

示例代码

namespace NetCore3Console.AbstractMethod
{
    /// <summary>
    /// 抽象工厂接口，生命创建抽象产品对象的操作
    /// </summary>
    public interface IAbstractFactory
    {
        /// <summary>
        /// 示例方法，创建抽象产品A的对象
        /// </summary>
        /// <returns></returns>
        IAbstractProductA CreateProductA();

        /// <summary>
        /// 示例方法，创建抽象产品B的对象
        /// </summary>
        /// <returns></returns>
        IAbstractProductB CreateProductB();
    }

    /// <summary>
    /// 抽象产品A的接口
    /// </summary>
    public interface IAbstractProductA
    {
        //定义抽象产品A的相关操作
    }

    /// <summary>
    /// 抽象产品B的接口
    /// </summary>
    public interface IAbstractProductB
    {
        //定义抽象产品B的相关操作
    }

    /// <summary>
    /// 产品A的具体实现
    /// </summary>
    public class ProductA1 : IAbstractProductA
    {
        //实现产品A的接口中定义的操作
    }
    public class ProductA2 : IAbstractProductA
    {
        //实现产品A的接口中定义的操作
    }

    /// <summary>
    /// 产品B的具体实现
    /// </summary>
    public class ProductB1 : IAbstractProductB
    {
        //实现产品B的接口中定义的操作
    }
    public class ProductB2 : IAbstractProductB
    {
        //实现产品B的接口中定义的操作
    }

    /// <summary>
    /// 具体的工厂实现对象，实现创建具体的产品对象的操作
    /// </summary>
    public class ConcreteFactory1 : IAbstractFactory
    {
        public IAbstractProductA CreateProductA()
        {
            return new ProductA1();
        }

        public IAbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    /// <summary>
    /// 具体的工厂实现对象，实现创建具体的产品对象的操作
    /// </summary>
    public class ConcreteFactory2 : IAbstractFactory
    {
        public IAbstractProductA CreateProductA()
        {
            return new ProductA2();
        }

        public IAbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }
}

认识抽象工厂模式

抽象工厂式的能

抽象工厂的功能是为一系列相关对象或相互依赖的对象创建一个接口。一定要注意这个接口内的方法不是任意堆砌的，而是一系列相关或相互依赖的方法。

实现成接口

AbstractFactory 在 Java 中通常实现成为接口，大家不要被名称误导了，以为是实现成为抽象类。当然，如果需要为这个产品簇提供公共的功能，也不是不可以把AbstractFactory 实现成为抽象类，但一般不这么做。

定义可扩展的工厂

抽象工厂里面不需要定义那么多方法，定义一个方法就可以了，给这个方法设置一个参数，通过这个参数来判断具体创建什么产品对象:由于只有一个方法，在返回类型上就不能是具体的某个产品类型了，只能是所有的产品对象都继承或者实现的这么一个类型，比如让所有的产品都实现某个接口，或者干脆使用 Object 类型。

namespace NetCore3Console.AbstractMethod1
{
    /// <summary>
    /// 可扩展的抽象工厂的接口
    /// </summary>
    public interface IAbstractFactory
    {
        /// <summary>
        /// 一个通用的创建产品对象的方法，为了简单，直接返回object
        /// 也可以为所有被创建的产品定义一个公共接口
        /// </summary>
        /// <param name="type"></param>
        /// <returns>创建出的产品对象</returns>
        object CreateProduct(int type);
    }

    public class Schema1 : IAbstractFactory
    {
        public object CreateProduct(int type)
        {
            object retObj = null;
            if (type == 1)
                retObj = new IntelCPU();
            else if(type==2)
                retObj=new GAMainboard(1156)
            return retObj;
        }
    }
}