架构师_设计模式_创建型之简单工厂,工厂方法,抽象工厂

使用场景：创建复杂对象的时候使用

 

一般写法： 产品直接到工厂,要生产什么 都堆在产品里面  产品  工厂

简单工厂： 发送指令给工厂,由工厂来生成具体产品对象   产品 抽象产品  工厂

工厂方法：                                                                          产品 抽象产品  工厂 抽象工厂

抽象工厂：对工厂方法的拓展

具体使用方法：更加业务来,没有最好的设计模式,只有最适合的设计模式

 

简单工厂：对象>弄到工厂里面去

　　使用条件:自动实例化类

 　　产品class 抽象产品class 工厂class

 

 

工厂方法:对象>更加抽象的工厂

　　使用条件：复杂对象的创建

　　产品class 抽象产品 工厂class 抽象工厂class

 

using System;

namespace 工厂模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //简单工厂调用
            Phone Phone = new MakeFactory().MakeStandard("我要生产华为");
            Phone.MakeStandard();

            //工厂方法调用
            Phone phone_abstract = new HuaWeiFactory().makePhone();
            phone_abstract.MakeStandard();

            //抽象工厂模式 只不过是工厂方法的需求扩展
        }
    }

    #region 简单工厂模式

    #region 手机产品
    /// <summary>
    /// 手机抽象产品
    /// </summary>
    public interface Phone
    {
        /// <summary>
        /// 制造手机的标准规范
        /// </summary>
        void MakeStandard();
    }

    //具体产品依赖于抽象产品

    /// <summary>
    /// 华为产品
    /// </summary>
    public class huawei : Phone
    {
        public void MakeStandard() { Console.WriteLine("华为手机"); }
    }

    /// <summary>
    /// 小米产品
    /// </summary>
    public class xiaomi : Phone
    {
        public void MakeStandard() { Console.WriteLine("小米手机"); }
    }
    #endregion

    /// <summary>
    /// 工厂
    /// </summary>
    public class MakeFactory
    {
        /// <summary>
        /// 接收指令,工厂然后开始生产手机
        /// </summary>
        /// <param name="Type"></param>
        /// <returns></returns>
        public Phone MakeStandard(string Type)
        {
            switch (Type)
            {
                case "我要生产华为": return new huawei();
                case "我要生产小米": return new xiaomi();
                default: return new huawei();//如果不发送指令,默认制造华为手机
            }

        }
    }
    #endregion

    #region  工厂方法

    //抽象工厂
    public interface AbstractFactor
    {
        /// <summary>
        /// 生产手机
        /// </summary>
        /// <returns></returns>
        Phone makePhone();

        /// <summary>
        /// 生产电脑
        /// </summary>
        /// <returns></returns>

        PC makePC();
    }

    /// <summary>
    /// 具体生产华为的工厂
    /// </summary>
    public class HuaWeiFactory : AbstractFactor
    {
        public Phone makePhone()
        {
            return new huawei();
        }

        public PC makePC()
        {
            return new huaweiPC();
        }
    }
    /// <summary>
    /// 具体生产小米的工厂
    /// </summary>
    public class XiaoMiFactory : AbstractFactor
    {
        public Phone makePhone()
        {
            return new xiaomi();
        }

        public PC makePC()
        {
            return new huaweiPC();
        }
    }


    #endregion


    #region 抽象工厂模式 只不过是在工厂方法的基础上  在抽象工厂多拓展一个产品类型

    //生产电脑
    public interface PC
    {
        void make();
    }

    public class xiaomiPC : PC
    {
        public void make()
        {
            Console.WriteLine("小米电脑产品");
        }
    }

    public class huaweiPC : PC
    {
        public void make()
        {
            Console.WriteLine("华为电脑产品");
        }
    }

    #endregion





}