zoukankan      html  css  js  c++  java
  • 设计模式学习笔记四:简单工厂模式抽象工厂模式工厂方法模式

    一.简单工厂模式:

      1.简介

        简单工厂模式(Simple Factory Pattern):又称静态工厂方法(Static Factory Method)模式,专门定义一个类负责创建其他类的实例,被创建的实例通常都具有相同的父类,可以根据参数指定创建的类实例.

      2.简单工厂模式实现类图:

     

      3.简单工厂模式实现(C#)

    /************************************
    * 创建人:movin
    * 创建时间:2021/8/7 11:54:56
    * 版权所有:个人
    ***********************************/
    using System;
    using System.Collections.Generic;
    using System.Text;
    
    namespace DesignPatternsCore
    {
        /// <summary>
        /// 简单工厂
        /// </summary>
        public class SimpleFactory
        {
            /// <summary>
            /// 工厂创建方法
            /// </summary>
            /// <param name="productType"></param>
            /// <returns></returns>
            public ISimpleFacroryProduct Create(ESimpleFactoryProductType productType)
            {
                switch (productType)
                {
                    case ESimpleFactoryProductType.A:
                        return new SimpleFactoryProductA();
                    case ESimpleFactoryProductType.B:
                        return new SimpleFactoryProductB();
                    default:
                        return null;
                }
            }
        }
        /// <summary>
        /// 工厂产品接口
        /// </summary>
        public interface ISimpleFacroryProduct
        {
            void Print();
        }
        /// <summary>
        /// 产品A
        /// </summary>
        public class SimpleFactoryProductA : ISimpleFacroryProduct
        {
            public void Print()
            {
                Console.WriteLine("product a");
            }
        }
        /// <summary>
        /// 产品B
        /// </summary>
        public class SimpleFactoryProductB : ISimpleFacroryProduct
        {
            public void Print()
            {
                Console.WriteLine("product b");
            }
        }
        /// <summary>
        /// 产品类型
        /// </summary>
        public enum ESimpleFactoryProductType
        {
            A,
            B,
        }
    }

      4.总结:简单工厂模式直观地呈现了工厂模式的创建方式,非常有助于理解工厂模式,也非常容易理解,但是这个工厂模式对创建类对象仍然对对象创建不够友好,当我们要拓展一种新的产品时,需要定义好新的产品子类新的枚举类型,尤其是还要在工厂的创建方法中添加相应的条件分支语句,我们还是希望能不改动创建工厂实现产品的拓展,显然简单工厂模式很难实现这个需求.

    二.工厂方法模式

      1.概念:

        工厂方法模式(Factory Method),定义了一个创建对象的接口,让字类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其字类.

        工厂方法模式可以理解为在简单工厂模式的基础上的拓展.简单工厂模式违背了开闭原则,

      2.工厂方法模式实现类图

      3.工厂方法模式实现

    /************************************
    * 创建人:movin
    * 创建时间:2021/8/7 11:54:56
    * 版权所有:个人
    ***********************************/
    using System;
    using System.Collections.Generic;
    using System.Text;
    
    namespace DesignPatternsCore
    {
        /// <summary>
        /// 工厂接口
        /// </summary>
        public interface IFactoryMethod
        {
            IFactoryMethodProduct Create();
        }
        /// <summary>
        /// 工厂A
        /// </summary>
        public class FactoryMethodA : IFactoryMethod
        {
            /// <summary>
            /// 工厂创建方法
            /// </summary>
            /// <param name="productType"></param>
            /// <returns></returns>
            public IFactoryMethodProduct Create()
            {
                return new FactoryMethodProductA();
            }
        }
        /// <summary>
        /// 工厂B
        /// </summary>
        public class FactoryMethodB : IFactoryMethod
        {
            public IFactoryMethodProduct Create()
            {
                return new FactoryMethodProductB();
            }
        }
        /// <summary>
        /// 工厂产品接口
        /// </summary>
        public interface IFactoryMethodProduct
        {
            void Print();
        }
        /// <summary>
        /// 产品A
        /// </summary>
        public class FactoryMethodProductA : IFactoryMethodProduct
        {
            public void Print()
            {
                Console.WriteLine("product a");
            }
        }
        /// <summary>
        /// 产品B
        /// </summary>
        public class FactoryMethodProductB : IFactoryMethodProduct
        {
            public void Print()
            {
                Console.WriteLine("product b");
            }
        }
    }
            static void Main(string[] args)
            {
                //使用时决定创建哪个工厂
                IFactoryMethod factorya = new FactoryMethodA();
                IFactoryMethodProduct producta = factorya.Create();
                producta.Print();
    
                IFactoryMethod factoryb = new FactoryMethodB();
                IFactoryMethodProduct productb = factoryb.Create();
                productb.Print();
    
                Console.ReadKey();
            }

    三.抽象工厂模式

      1.概念

        抽象工厂模式(Abstract Factory):提供了一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类.

        抽象工厂模式可以理解为是工厂方法模式的进一步拓展,工厂方法模式中的工厂只能生产一种产品,但是抽象工厂模式中的工厂可以生产多种产品..

      2.抽象工厂模式实现类图

      3.抽象工厂模式实现代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace DesignPatternsCore
    {
        /// <summary>
        /// 工厂接口
        /// </summary>
        public interface IAbstractFactory
        {
            IAbstractFactoryProduct Create1();
            IAbstractFactoryProduct Create2();    
        }
        /// <summary>
        /// 工厂A
        /// </summary>
        public class AbstractFactoryA : IAbstractFactory
        {
            /// <summary>
            /// 工厂创建方法
            /// </summary>
            /// <param name="productType"></param>
            /// <returns></returns>
            public IAbstractFactoryProduct Create1()
            {
                return new AbstractFactoryProductA1();
            }
    
            public IAbstractFactoryProduct Create2()
            {
                return new AbstractFactoryProductA2();
            }
        }
        /// <summary>
        /// 工厂B
        /// </summary>
        public class AbstractFactoryB : IAbstractFactory
        {
            public IAbstractFactoryProduct Create1()
            {
                return new AbstractFactoryProductB1();
            }
    
            public IAbstractFactoryProduct Create2()
            {
                return new AbstractFactoryProductB2();
            }
        }
        /// <summary>
        /// 工厂产品接口
        /// </summary>
        public interface IAbstractFactoryProduct
        {
            void Print();
        }
        /// <summary>
        /// 产品A1
        /// </summary>
        public class AbstractFactoryProductA1 : IAbstractFactoryProduct
        {
            public void Print()
            {
                Console.WriteLine("product a1");
            }
        }
        /// <summary>
        /// 产品A2
        /// </summary>
        public class AbstractFactoryProductA2 : IAbstractFactoryProduct
        {
            public void Print()
            {
                Console.WriteLine("product a2");
            }
        }
        /// <summary>
        /// 产品B1
        /// </summary>
        public class AbstractFactoryProductB1 : IAbstractFactoryProduct
        {
            public void Print()
            {
                Console.WriteLine("product b1");
            }
        }
        /// <summary>
        /// 产品B2
        /// </summary>
        public class AbstractFactoryProductB2 : IAbstractFactoryProduct
        {
            public void Print()
            {
                Console.WriteLine("product b2");
            }
        }
    }
            static void Main(string[] args)
            {
                //使用时决定创建哪个工厂
                IAbstractFactory factorya = new AbstractFactoryA();
                IAbstractFactoryProduct producta1 = factorya.Create1();
                producta1.Print();
                IAbstractFactoryProduct producta2 = factorya.Create2();
                producta2.Print();
    
                IAbstractFactory factoryb = new AbstractFactoryB();
                IAbstractFactoryProduct productb1 = factoryb.Create1();
                productb1.Print();
                IAbstractFactoryProduct productb2 = factoryb.Create2();
                productb2.Print();
    
                Console.ReadKey();
            }

    四.改进

      尽管抽象工厂模式和工厂方法模式都没有违背开闭原则,但是还是需要使用者在使用时创建具体的工厂,这就意味着使用者一定程度上还是需要了解实现细节(至少要了解有哪些工厂)才能使用,这个问题我们将简单工厂模式和抽象工厂模式结合起来,借助于配置文件的方式实现.我们不再需要抽象工厂和具体的工厂实现类,只需要一个创建工厂,然后使用配置文件的方式配置我们要创建的产品,使用反射的方式获取要创建的产品类.当需要改变创建的产品时只需要修改配置文件即可.

  • 相关阅读:
    define vs const vs enum
    解决Ubuntu 14.04 LTS 浏览网页速度慢的问题
    C语言两种产生矩阵的方法
    GTK 添加图标
    Unix Socket 端口 reuse
    Linux GTK Hello,World
    插件使用记录
    原型链和new
    each函数循环数据表示列举,列举循环的时候添加dom的方法
    字体圆润属性的使用-webkit-font-smoothing: antialiased
  • 原文地址:https://www.cnblogs.com/movin2333/p/15111653.html
Copyright © 2011-2022 走看看