【大话设计模式】——工厂模式家族

最新推荐文章于 2024-09-12 10:00:00 发布
最新推荐文章于 2024-09-12 10:00:00 发布
阅读量83 收藏
点赞数
文章标签： 设计模式
原文链接：https://my.oschina.net/zhumenzhongren/blog/672767
版权

     本博客可能有异常，请结合这篇看：http://www.cnblogs.com/stonehat/archive/2012/04/16/2451891.html

     在工厂模式家族中最出名的是工厂三姐妹，根据抽象的程度不同分为简单工厂、工厂模式和抽象工厂模式。他们在我们平时的编程中会经常使用。所以我们应该详细地了解一下他们三者之间优缺点。

简单工厂

定义

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

举例说明：  

        25958655_1399530326s3Z6.jpg

代码实现：

 

<span style="font-size:18px;">// 客户端代码
    static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("*"); // 父类直接实例化
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();

            
        }
    }

    // Operation运算类
    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;
        }
    }
</span>

 

 

简单工厂的优点：

 

1、工厂类是整个模式的关键.包含了必要的逻辑判断,根据给定的信息,决定究竟应该创建哪个具体类的实例。

2、明确了各自的职责和权利，有利于整个软件体系结构的优化。

简单工厂的缺点：

    1、由于工厂类集中了所有实例的创建逻辑，违反了高内聚低耦合原则，将全部创建逻辑集中到了一个工厂类中；

    2、它所能创建的类只能是事先考虑到的，每次扩展都需要更改工厂类，违反了开放封闭原则（即：软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的；适用于抽象编程）。

 

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的实例。

工厂模式

定义：

    用于创建对象的接口，让子类决定实例化哪一个类。工厂模式对类的实例化延迟到其子类。

    简单来说，工厂模式首先抽象出对对象的共通操作（接口，工厂），之后创建各个具体操作（类，不同工厂），之后创建工厂（类），工厂内部有个方法可以调用具体操作类（实现）。

    这个和简单工厂有区别，简单工厂模式只有一个工厂，工厂方法模式对每一个产品都有相应的工厂

举例说明：数据访问程序       

                25958655_1399530481VM7v.jpg

代码实现：

 

<span style="font-size:18px;">
    static void Main(string[] args)
        {
            // 新用户对象
            User user = new User();
            // 建造工厂，此时没有实例化
            IFactory factory = new SqlServerFactory();
            // 工厂创建用户操作类：工厂内部实现了具体用户操作对象SqlserverUser(基础接口操作IUser实现)，实例化
            IUser iu = factory.CreateUser();
            // 用户操作类在表中新增一条用户信息：执行具体用户操作对象SqlserverUser中的操作
            iu.Insert(user);
            // 用户操作类根据ID获得一条用户信息：执行具体用户操作对象SqlserverUser中的操作
            iu.GetUser(1);
            // 下面代码 1：等待键盘输入 2：终止一个程序的执行
            Console.Read();
        }
    }

    // User类
    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 ;}
        }
    }

    // IUser接口（用户填入和获取用户对象）
    interface IUser
    {
        void Insert(User user);
        User GetUser(int id);
    }

    // SqlserverUser类
    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;
        }
    }

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

    // IFactory接口（获取IUser接口，这里是按照抽象工厂的方法写的，实际使用的时候，可直接用下面两个实例化方法）
    interface IFactory
    {
        IUser CreateUser();
    }

    // SqlServerFactory :IFactory
    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
    }

    // AccessFactory类
    class AccessFactory:IFactory 
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
    }
</span>

 

 

工厂模式的优点：

        1、克服了简单工厂违背开放封闭原则的缺点，保持了封装的优点。工厂模式集中封装了对象的创建，更换对象时更加容易。
        2、使用了多态性，保持了简单工厂的优点。
        3、降低耦合度。降低了客户程序与产品对象的耦合。

        4、增加一个运算类（例如N次方类），只需要增加运算类和相对应的工厂，两个类，不需要修改工厂类（右图）。

     缺点：

        1、增加运算类，会修改客户端代码，工厂方法只是把简单工厂的内部逻辑判断移到了客户端进行（右图）。 

 

抽象工厂

定义：

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

举例说明：数据访问程序

 

             25958655_1399530523DmFr.jpg

代码实现：

 

<span style="font-size:18px;"> 
    static void Main(string[] args)
        {
            // 新用户对象
            User user=new User ();
            // 部门，专业
            Department dept = new Department();
            //IFactory factory = new SqlServerFactory();
            // access工厂
            IFactory factory = new AccessFactory();
            
            // 工厂内部用户对象操作方法“实例化”
            IUser iu = factory.CreateUser();

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

            // 工厂内部部门对象操作方法“实例化”
            IDepartment id = factory.CreateDepartment();
            id.Insert(dept);
            id.GetDepartment(1);

            Console.Read();
            
        }
    }

    // 用户类
    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 ;}
        }
    }

    // IUser接口
    interface IUser 
    {
        void Insert(User user);
        User GetUser(int id);
    }

    // IUser接口的子SqlserverUser类,用于访问SQL Server的User
    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;
        }
    }

    // IUser接口的子AccessUser类，用于访问Access的User
    class AccessUser :IUser 
    {
        public void Insert(User user)
        {
            Console.WriteLine ("在Access中给User表增加一条记录");
        }
        public User GetUser(int id)
        {
            Console.WriteLine ("在Access中根据ID得到User表中一条记录");
            return null;
        }
    }

    // 增加一个Department表
    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; }
        }
    }

    // IDpartment接口
    interface IDepartment
    {
        void Insert(Department department);

        Department GetDepartment(int id);
    }

    // sqlserverDepartment类
    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;
            }
    }

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

    // 抽象工厂的接口
    interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment(); //增加的接口方法
    }

    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }

    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }
</span>

 

抽象工厂的优点：

 

    抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部创建不同的产品对象。

抽象工厂的缺点：

    对于增加需求，扩展程序时，需要增加许多子类，使得程序变得臃肿，麻烦。（此时可以利用反射+抽象工厂的方法避免）。

 

总结:

 

        无论是简单工厂模式，工厂模式，还是抽象工厂模式，他们都属于工厂模式，并且是创建型模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。

转载于:https://my.oschina.net/zhumenzhongren/blog/672767

chuoyingzao4930
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android之大话设计模式——：抽象工厂模式借鉴.pdf
12-25
Android之大话设计模式——：抽象工厂模式借鉴.pdf
设计模式笔记（一）—— 设计原则与工厂方法模式详解
Orcas
08-01 591
七大设计原则；简单工厂；工厂方法模式；抽象工厂
曾经案例中问题 与 工厂模式解耦
qq_39368007的博客
03-14 176
一个创建Bean对象的工厂 * Bean：在计算机英语中，有可重用组件的含义。 * JavaBean：用java语言编写的可重用组件。 * javabean > 实体类 * * 它就是创建我们的service和dao对象的。 * * 第一个：需要一个配置文件来配置我们的service和dao * 配置的内容：唯一标识=全限定类名（key=value)...
大话设计模式总结.pdf
03-29
大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
Android之大话设计模式——：抽象工厂模式参考.pdf
12-01
Android之大话设计模式——：抽象工厂模式参考.pdf
大话设计模式读书笔记docx文档
08-31
大话设计模式读书笔记docx文档
MVC设计模式与delegate,tablview，Appdelegate,SceneDelegate
M3151549808的博客
09-08 806
tableView.dataSource=self 设置了UITableView的数据源为当前视图控制器对象 tableView.delegate=self 表格视图的代理对象为当前的视图控制器 那么代理有什么用呢？ 代理可以让两个视图关联起来，例如 现有两个视图控制器AVC与BVC,你要通过B视图控制器同时修改A，B两个view的背景颜色
24下半年学习计划
2301_80336512的博客
09-08 1748
上课的时候认真听，不要以为提前了解一些知识就认为不重要，不听也要坚持看书，不要被外界吸引。我以后大概率走后端方向，对于后端的一些技术栈目前只是跟着网上的教程学，网上的教程大部分。只适合入门，对其原理背后的实行的机制还是需要看一些经典书籍，因此在这一学期除了完成实验。《设计模式之美》，提高自己编写代码的规范性，了解设计原理，养成良好的写代码习惯。，数据库对于后端开发者来说十分重要，这一部分知识要熟悉掌握。早睡早起，少熬夜，最好是每天早晨记10个单词，晚上睡前复习。
【c++23种设计模式概述】
m0_45463480的博客
09-09 706
c++23种设计模式概述。
最佳实践-模板设计模式
2303_80050865的博客
09-08 569
1）设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式2）设计模式就像经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们再思考和摸索1、基本介绍抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式2、模板设计模式能解决的问题1）当功能内部一部分实现是确定的，一部分是不确定的，这时可以把不确定的部分暴露出去，让子类去实现。
漫谈设计模式 [15]：观察者模式
刘炫320的博客
09-07 639
老鸟：我们先从生活中的例子聊起吧。假设你是个新闻记者，每当有重大新闻发生时，你需要通知各种媒体平台，比如电视、电台、报纸等。每次你都得一个一个通知，感觉很麻烦吧？菜鸟：是啊，如果能一次通知所有人就好了。老鸟：没错，这就是观察者模式的核心思想。你可以把自己看作"被观察者"（Subject），而那些需要通知的媒体平台看作"观察者"（Observer）。当有新闻发生时，你只需要告诉所有观察者，他们自己会去更新。老鸟：今天我们聊了观察者模式，主要解决了同步更新的问题，核心是解耦和易于扩展。
设计模式-行为型模式-迭代器模式
LB_bei的博客
09-06 627
迭代器模式提供一种对容器对象中的各个元素进行访问的方法，而不需要暴露该对象的内部细节；在软件系统中，容器对象有两个职责：一是存储数据，二是遍历数据；从依赖性上看，前者是基本职责，而后者是可以变化的，又是可以分离的，因此可以将遍历数据的行为从容器中抽取出来，封装到迭代器对象中，由迭代器来提供遍历数据的行为，这将简化聚合对象的设计，更加符合单一职责原则；对于迭代器模式，设计时很少用到，但编码时经常用到，目前大多数编程语言中，迭代器已经成为一个基础的类库，直接能用来遍历集合对象；
Spring 中使用的设计模式全面解析
项目git同名HuYaochao
09-07 1269
Spring 框架作为Java开发的核心技术栈之一，广泛应用了多种设计模式来简化复杂系统的开发，提升代码的复用性、可维护性和扩展性。本文将全面解析Spring框架中所应用的设计模式，并通过案例来解释这些设计模式的实际作用。
设计模式-单例模式
qq_40840571的博客
09-06 1075
但是这种方式仔细想想的话，不管instance有没有被初始化，每次有一个instance来的时候都需要获取一次锁，这样对性能很不友好。因此，可以在此基础上加一层判断，如果instance已经被初始化了，就没必要再获取锁了。缺点也很明显，就是浪费资源，如果一个实例一直没用到，就会造成资源的浪费。如果第一次执行的时候，随机到了Deny就会导致后续一直是nil，限制太大，我们继续看看sync.mutex的实现。，需要注意的是，如果sync.Once使用的时候Do函数失败了，那么就会导致对象一直为nil。
设计模式 20 状态模式
小小程序猿
09-09 1183
状态模式的核心思想是将与状态相关的行为封装在独立的状态对象中，并通过状态对象来管理对象的状态转换。这样，原始对象在其状态发生变化时，会自动切换到对应的状态对象，从而表现出不同的行为。状态模式通过将状态相关的行为封装在独立的状态对象中，简化了对象的状态管理逻辑。它消除了大量的条件分支语句，使代码更加清晰和易于扩展。尽管状态模式可能会增加类的数量，但它为管理复杂的状态转换逻辑提供了一种灵活且有效的解决方案。
JS设计模式之代理模式：对象的“虚拟与现实”
最新发布
前端梦工厂
09-12 587
概述：代理模式是一种结构型设计模式，它通过引入一个代理对象来控制对另一个对象的访问或操作。代理对象和真实对象具有相同的接口，客户端代码通常无需关注代理对象和真实对象之间的差异。在代理模式中，客户端不直接与真实对象进行交互，而是通过代理对象来完成访问或操作。代理对象可以对客户端的请求进行过滤、验证、处理，以及添加额外的功能，然后再将请求传递给真实对象去执行。代理模式主要包括两个角色：真实对象）：真实对象是代理模式中要被访问或操作的对象，它具有具体的业务逻辑和功能。代理对象和真实对象通常都实现同一个接口。
Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
lzhlizihang的博客
09-10 527
Java基础：多线程和设计模式总结
C++设计模式——Memento备忘录模式
CoderZZ_2024的博客
09-11 1034
备忘录模式是一种行为型设计模式，它允许将对象的状态保存在外部，并在需要时恢复。备忘录模式允许在不破坏封装性的前提下，捕获并存储一个对象的内部状态，并在需要时将其恢复到之前的状态。在某些开发场景，备忘录模式可以用于缓存函数的结果，避免重复计算，以提高性能。在软件开发中，备忘录模式常应用于某些计算密集型、IO密集型的操作场景，例如数据分析、图形处理等。文本编辑器：当我们在文本编辑器中进行编辑操作时，可以使用撤销功能恢复到之前的状态。游戏存档：我们可以在游戏中存档，以便下次打开时恢复到之前的游戏进度。
大话设计模式python简单工厂模式
08-14
简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它通过一个工厂类来创建不同类型的对象，而无需暴露对象创建的逻辑给客户端。在Python中，简单工厂模式可以通过一个工厂类来创建不同的产品对象。下面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值