设计模式——工厂这一家子

最新推荐文章于 2021-11-23 13:20:06 发布
最新推荐文章于 2021-11-23 13:20:06 发布
阅读量988 收藏
点赞数
分类专栏： 【设计模式】 【C#】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010955843/article/details/24843367
版权

    在《大话设计模式》中，开篇提到的第一个模式就是简单工厂模式，单单理解这个模式我觉得体现不出来它的好处，往后接着看得时候，发现还有工厂方法，再往后发现还有抽象工厂方法，心里有一种兴奋之感，因为既然相似，那么放一起肯定就好理解了。

单单从定义上看，不怎么好理解，定义再加上例子，这样比较着来吧。

    u  简单工厂模式

    简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

    在类图我们可以看出主要包括三个角色：工厂（Creator）角色、抽象产品（Product）角色、具体产品（Concrete Product）角色。

    u  工厂方法模式

    工厂方法(FactoryMethod)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

    在类图我们可以看出主要包括四个角色：抽象工厂(Creator)角色、具体工厂(ConcreteCreator)角色、抽象产品(Product)角色、具体产品(Concrete Product)角色。

    u  抽象工厂模式

    抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

    那我们以具体的实例来比较说明一下吧！

    u  简单工厂模式

用简单工厂模式实现一个计算器的程序代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    public class Operation    //运算类
    {
        private double _numberA=0;
        private double _numberB=0;
        public double NumberA
        {
            get {return _numberA ;}
            set {_numberA =value ;}

        }
        public double NumberB
        {
            get {return _numberB ;}
            set {_numberB =value ;}
        }
        public virtual double GetResult()
        {
            double result=0;
            return result ;
        }
    }
    class OperationAdd : Operation   //加减乘除类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0。");
            result = NumberA / NumberB;
            return result;
        }
    }
    class OperationFactory     //简单工厂的实现
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;

        }
}

    客户端代码； 

客户端代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            Operation oper;           简单工厂的实现
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
   	}
    }
}

    u  工厂方法模式

    实现一个计算器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    public class Operation
    {
        private double _numberA=0;
        private double _numberB=0;
        public double NumberA
        {
            get {return _numberA ;}
            set {_numberA =value ;}

        }
        public double NumberB
        {
            get {return _numberB ;}
            set {_numberB =value ;}
        }
        public virtual double GetResult()
        {
            double result=0;
            return result ;
        }
    }
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0。");
            result = NumberA / NumberB;
            return result;
        }
    }
    //class OperationFactory     //简单工厂的实现
    //{
    //    public static Operation createOperate(string operate)
    //    {
    //        Operation oper = null;
    //        switch (operate)
    //        {
    //            case "+":
    //                oper = new OperationAdd();
    //                break;
    //            case "-":
    //                oper = new OperationSub();
    //                break;
    //            case "*":
    //                oper = new OperationMul();
    //                break;
    //            case "/":
    //                oper = new OperationDiv();
    //                break;
    //        }
    //        return oper;

    //    }
    //}
    interface IFactory    //工厂方法实现
    {
        Operation CreateOperation();
    }
    class AddFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();

        }
    }
    class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();

        }
    }
    class MulFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationMul();

        }
    }
    class DivFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();

        }
    }
}

    客户端代码 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            //Operation oper;           简单工厂的实现
            //oper = OperationFactory.createOperate("+");
            //oper.NumberA = 1;
            //oper.NumberB = 2;
            //double result = oper.GetResult();
            IFactory operFactory = new AddFactory();    //工厂的实现
            Operation oper = operFactory.CreateOperation();
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
        }
    }
}

    u  抽象工厂方法

    这个以数据库访问程序为例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication5
{
    class User
    {
        private int _id;
        public int ID
        {
            get { return _id; }
            set { _id = value; }
        }
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }

        }
    }
    class Department
    {
        private int _id;
        public int ID
        {
            get { return _id; }
            set { _id = value; }
        }
        private string _deptName;
        public string DeptName
        {
            get { return _deptName; }
            set { _deptName = value; }

        }
    }

    interface IUser
    {
        void Insert(User user);
        User GetUser(int id);
    }
    class SqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在SQL Server中给User表添加一条记录");

        }
        public User GetUser(int id)
        {
            Console.WriteLine("在SQL Server中根据ID得到User表一条记录");
            return null;
        }
    }
    class AccessUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Access中给User表添加一条记录");

        }
        public User GetUser(int id)
        {
            Console.WriteLine("在Access中根据ID得到User表一条记录");
            return null;
        }
    }
    interface IDepartment
    {
        void Insert(Department department);
        Department GetDepartment(int id);
    }
    class SqlserverDepartment : IDepartment 
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在SQL Server中给Department表添加一条记录");

        }
        public Department GetDepartment(int id)
        {
            Console.WriteLine("在SQL Server中根据ID得到Department表一条记录");
            return null;
        }
    }
    class AccessDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在Access中给Department表添加一条记录");

        }
        public Department GetDepartment(int id)
        {
            Console.WriteLine("在Access中根据ID得到Department表一条记录");
            return null;
        }
    }
    interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment();
    }
    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
        public IDepartment CreateDepartment()
        {
            return new SqlserverDepartment();
        }
    }
    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }
}

    客户端代码 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            User user = new User();
            Department department = new Department();

            IFactory factory = new AccessFactory();

            IUser iu = factory.CreateUser();

            iu.Insert(user);
            iu.GetUser(1);

            IDepartment id = factory.CreateDepartment();
            id.Insert(department);
            id.GetDepartment(1);

            Console.Read();
        }
    }
}

    比较分析：

      简单工厂模式：

        优点：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类。对于客户端来说，去除了与具体产品的依赖。

例如在例子中，客户端不用管该用哪个类的实例，只要把“+”给工厂，那么工厂就会给出相应的实例。

        缺点：如果需要增加一个新的功能的运算，那么必须去改动运算工厂类的方法的“case”分支的，这样虽然扩展了功能，但是也修改了原来的类，这样可能会一不小心改错某个方法，同样违背了开放-封闭原则。

      工厂方法模式：

        优点：简单工厂模式里工厂类与分支耦合，造成修改时违背了开放-封闭原则，依赖倒转原则，便可以抽象出一个接口。如上例所示，这样工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行，增加功能修改客户端，而不用修改工厂类，完全实现了“开放-封闭原则”。

        缺点：工厂方法实现时，客户端要决定实例化哪一个工厂来实现运算类，选择判断的问题依然存在。

      抽象工厂模式：

        优点：1、易于交换产品系列。由于是具体工厂类，如上例IFactory factory=new AccessFactory（）；应用中只需初始化一次，便使得改变一个应用的具体工厂变得容易，即改变不同工厂时使用不同工厂的配置。

              2、分离了具体的类。它使得具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操作实例。如：IFactory factory=new AccessFactory（），产品的具体类名也被相应的工厂分离，不会出现在客户端中。

        缺点：难易支持新种类的产品。比如要是增加某个东西，那么就需要改动，例如在上例中增加项目表Project，那么需要改动IProject、SqlserverProject、AccessProject三个类，并且也需要改动IFactory下面的两个具体的实例，显然是不方便。此时出现的问题需要简单工厂来改进，但是又会出现问题，我们下篇再讲。

 

    u  小结

    简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

    抽象工厂模式抽象出多个接口，而工厂模式只是抽象抽一个接口，多个抽象接口使得具体类名和具体工厂实现分离，但是这同时也带来不好的地方，那就是新功能的增加使得改动的地方。

    总而言之，一句话，没有一个模式是尽善尽美的，都会存在一定的不足，我们在接触简单工厂时，认为她优于一般的方法，当其中出现不足了，后来看到了工厂模式，工厂模式出现不足了，又出现了抽象工厂模式，而抽象工厂模式的不足，又需要简单工厂的弥补，所谓物极必反，说的也就是这个道理吧，模式之间的相互协调，互补，整合，才能得一个程序变得尽善尽美，一个好的程序设计是这样，人与人之间协调工作也是这样，各尽其力，才能完美。

李晓娜
关注
专栏目录
Spring中的设计模式--工厂方法模式
zstu_cc的专栏
01-02 1万+
关于工厂模式的误会这是个老生常谈的问题，很多新手或者不太在意设计模式的同事会对工厂模式有极深的误解，总会把“工厂模式”与“静态工厂方法”混为一谈，什么是静态工厂方法呢？可以看一个非常简单的例子：public class SimpleClientFactory { public static Client createClient(){ return new Client();
23种设计模式-策略模式《商家打折》
热门推荐
yancyang的博客
07-20 2万+
对于许久不用的东西，容易忘记。百度许久，也未能找到自己所要。 从今日起，有些东西就记载下来，不仅方便自己，希望能帮到他人吧 最近开发一款电商App，对于商家推出的活动焦头烂额，好歹想起了设计模式中的策略模式，从容的解决这种问题。 商家的活动： 1.满100减10元。 2.三件8.5折。 3.五件送一件最近价格商品。 … 最开始使用swich，后来越来越多case，代码繁杂...
Spring--IoC--Bean的装配--工厂方法设计模式
赵亚兰的博客
04-18 483
引入工厂模式的原因：解耦合！！！ 工厂类： 使用工厂获取Bean:
设计模式之策略模式(商场打折)
laoyaozaici1023的博客
08-10 1959
Discount 类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 策略者模式 {     public interface IDiscountStragety   
超赞的GO语言设计模式和成例集锦
Joy0921的博客
09-07 3033
原文：Awesome Go Patterns 作者：tmrts 翻译：王嘉怡 责编：仲培艺 Go语言从面世就受到了业界的普遍关注，曾有文章分析，Go是最有可能改变未来IT技术的十大语言之一。本文作者列举了Go语言的设计模式和成例合集，并且还进行了详细的分类。创建型模式 抽象工厂模式：提供一个接口用于创建相关对象的家族； Builder模式：使用简单的对象来构建复杂的对象； 工厂方法模式...
Yii2设计模式——工厂方法模式
米粒人生
01-02 490
应用举例 yii\db\Schema抽象类中： //获取数据表元数据 public function getTableSchema($name, $refresh = false) { if (array_key_exists($name, $this->_tables) && !$refresh) { return $this...
决战前端设计模式——工厂篇
TM_Godspeed的博客
04-24 346
前言 设计模式属于前端的高级内容，建议开始学习之前先确保已经可以熟练使用 JS，无论是ES5、ES6都能较好地运用，同时还要了解面向对象编程的概念，如果还学过TS那就最好了，不过没学过也没关系，因为其语法和 JS 大同小异，如果熟悉 JS 那么上手 TS 就不会那么难了。 为什么要用设计模式 在开发逻辑较为复杂的项目时，学会设计模式会使得代码更加清晰，同时还会增加开发效率。不过说白了设计模式也不是...
23种设计模式——结构型设计模式（7种）
Steffen Dinn 的博客
05-01 1093
目录 ☞23 种设计模式——创建型设计模式（5种） ☞23 种设计模式——结构型设计模式（7种） ☞23 种设计模式——行为型设计模式（11种） 3. 结构型设计模式 结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合组合对象。 由于组合关系或聚合关系比较继承关系耦合度低，满足“...
软件设计模式复习
endzero00的博客
11-23 1623
软件设计模式复习 一、面向对象思想 二、面向对象设计 一句话总结软件设计七大原则 设计原则 一句话归纳 目的 开闭原则 对扩展开放，对修改关闭 降低维护带来的新风险 依赖倒置原则 高层不应该依赖低层，要面向接口编程 更利于代码结构的升级扩展 单一职责原则 一个类只干一件事，实现类要单一 便于理解，提高代码的可读性 接口隔离原则 一个接口只干一件事，接口要精简单一 功能解耦，高聚合、低耦合 迪米特法则 不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度 只和朋
Java设计模式菜鸟系列(十二)组合模式建模与实现
JAVE_LOVER
10-06 151
转载请注明出处：http://blog.csdn.net/lhy_ycu/article/details/39828653     组合模式(Composite)：组合模式有时又叫部分-整体模式，将对象组合成树形结构来表示“部分-整体”层次结构。组合模式在处理树形结构的问题时比较方便。 一、uml建模：   二、代码实现   /** * 示例：组合模式有时也称“整合-部分...
设计模式之---单例模式（Singleton Design Pattern）
陌路旧梦
04-26 2439
场景 对象只要利用自己的属性完成了自己的任务.那该对象就是承担了责任。 除了维持了自身的一致性，该对象无需承担其他任何责任。 如果该对象还承担着其他责任，而其他对象又依赖于该特定对象所承担的贵任，我们就需要得到该特定对象。 就像我和我的女朋友去超市购物使用的购物车一样。 意图 将类的责任集中到唯一的单体对象中，确保该类只有一个实例. 并且为该类提供一个全局访间点。 难点 不在于单体
设计模式之策略模式（包含与简单工厂模式的区别，实现了超市结账系统）
weixin_33896069的博客
05-07 170
今天看了策略模式，不知觉的和前天学的简单工厂模式做了对比，也百度了一些博客，最后的出一个结论，简单工厂模式主要负责初始化各种对象，而策略模式则是更多的对方法进行封装。同一个例子，如果使用简单工厂模式，则是根据需求返回不同的对象，而使用策略模式的话，就是根据需求来返回不同的方法。 下面的例子分别使用简单工厂模式和策略模式和写的超市结账系统，二者功能实现上没有区别。 using System;...
Java中设计模式之生产者消费者模式-4
weixin_30731287的博客
04-25 128
引言 生产者-消费者（producer-consumer）问题，也称作有界缓冲区（bounded-buffer）问题，两个进程共享一个公共的固定大小的缓冲区。其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行休眠，等待消费者从缓冲区中取走了一...
分享一个基于SSH的超市管理系统(附源码）
红太阳照大地
07-18 1938
本文来自：曹胜欢博客专栏。转载请注明出处：http://blog.csdn.net/csh624366188 首先声明：本小项目也是是因老师而做，但这个没有按老师说的做，我按我自己的想法来做的，相对于前段时间，这个小项目的业务逻辑相对于那个要复杂一些。本项目代码非常简单，分享出来时为了和我一样的小菜鸟共同学习一下，只适合初学者拿来学习，大牛可直接绕过。如有不妥之处，欢迎大家提出意见。这个程序是...
超市收银系统设计思路
敲键盘的猫
10-13 1万+
超市收银系统设计分析 一、系统整体架构 图1 从图1可以看出，系统框架很清晰，用户登录，根据用户权限的不同，对应不同的操作方法，操作对象为商品。 但本系统要求使用C/S框架结构来设计。 C/S框架介绍： C/S 结构，即大家熟知的客户机和服务器结构。 C/S 结构的基本原则是将计算机应用任务分解成多个子任务，由多台计算机分工完成，即采用“功能分布”原则。客户端完成数据处理，数据表
设计模式之--中介者模式
javasalatu
07-29 137
在很多情况下对象之间的交互是很复杂的，在开始设计的时候，你根本不知道它需要交互的对象是谁，是什么类型。我们知道如果要对象A与对象B之间能相互交互，A与B就会构成相互依赖，如果对象一多，这种依赖就会很复杂，况且很多时候我们都不知道需要互相交互的对象有哪些，因此，在设计的时候也没办法考虑这些情况。既然在设计的时候无法预先知道对象之间的交互具体情况，我们可以将这种交互放到一个“中间平台”进行，这个中间平...
三分钟理解“工厂模式”——设计模式轻松掌握
大闲人柴毛毛
09-01 2725
工厂模式和简单工厂模式的比较： 简单工厂模式把创建哪个运算类的对象放在工厂类中实现，也就是放在低层模块中实现；从而客户端在需要创建对象时仅仅需要给工厂传入一个key就能获取想要的对象。但当运算体系需要扩展的时候，就需要在工厂中增加新对象的判断，从而破坏了“封闭修改”的原则。 工厂模式由于抽象出了一个工厂父类，并且每一运算子类都有一个专门创建该子类对象的工厂子类，因此在增加运算子类的时候，工厂类不需要修改任何代码，只需要增加一个工厂子类即可。但客户端就需要给判断究竟给工厂父类创建哪个工厂子类对象。
大话设计模式笔记——策略模式（C++超市收银实现）
Ben_OnceMore
05-29 2310
可能没耐心的同学看大话设计模式
Java设计模式：简单工厂与抽象工厂模式实战解析
"本文主要探讨了Java编程中的两种设计模式——简单工厂模式和抽象工厂模式，它们都属于创建型设计模式。文章通过实例代码详细解释了这两种模式的应用，并指出了简单工厂模式的一些潜在问题以及可能的改进方式。" 在...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值