设计模式之工厂类模式总结对比、简单工厂模式、工厂方法模式、抽象工厂模式、带反射的工厂模式、例子代码分析、最详细

最新推荐文章于 2022-10-13 18:46:08 发布
最新推荐文章于 2022-10-13 18:46:08 发布
阅读量217 收藏
点赞数 1
分类专栏： 设计模式详谈 文章标签： 设计模式 简单工厂模式 工厂方法模式 抽象工厂模式 开闭原则
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_50233101/article/details/119357984
版权
本文详细介绍了工厂模式的几种形式，包括简单工厂模式、工厂方法模式、抽象工厂模式，以及如何通过反射技术进一步优化工厂模式。通过一系列的例子，展示了如何在数据库操作中应用这些模式，以实现对不同数据库如SqlServer、MySql的Users和Departments表的灵活切换。文章最后提供了所有源码的GitHub链接。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 题目

假设某公司同时用SqlServer、MySql数据库，即会切换两数据库（不同数据库的sql语句有些许差异），同时，两数据库里均有对Users、Departments表的操作（sql代码不一样），用工厂类的方法来编写程序

因为设计模式有差异，所以不同工厂模式的题目会有些不同，总体一样，细节有些不同

需要知道的是，我们把需求当做产品类，也就是User表和Department表

2. 简单工厂模式

题目：
现有两个数据库，一个SqlServer，一个MySql，并且两个数据库都有一张Users的表，现通过简单工厂模式来让用户选择使用哪个数据库的Users表

  1. 定义抽象数据库类
//定义抽象数据库类
    abstract class DatabaseUser
    {
        public abstract void Use();
        public abstract void Insert();
    }
  1. 实现抽象数据库类
 class SqlServerUser : DatabaseUser
    {
        public override void Insert()
        {
            Console.WriteLine("SqlServer为Users表插入数据");
        }

        public override void Use()
        {
            Console.WriteLine("SqlServer使用Users表");
        }
    }
    class MySqlUser : DatabaseUser
    {
        public override void Insert()
        {
            Console.WriteLine("MySql为Users表插入数据");
        }

        public override void Use()
        {
            Console.WriteLine("MySql使用Users表");
        }
    }
  1. 定义简单工厂类
class Factory
    {
        public DatabaseUser GetDatabase(string databaseName)
        {
            DatabaseUser database = null;
            switch (databaseName)
            {
                case "SqlServer":
                    database = new SqlServerUser();
                    break;
                case "MySql":
                    database = new MySqlUser();
                    break;
            }
            return database;
        }
    }
  1. 客户端
 class Program
    {
        //简单工厂模式的好处是方便，但是其违反了开放封闭原则，每次要加数据库就需要更改工厂类的分支语句
        static void Main(string[] args)
        {
            Factory factory = new Factory();
            var db1 = factory.GetDatabase("SqlServer");
            db1.Insert();
            db1.Use();

            var db2 = factory.GetDatabase("MySql");
            db2.Insert();
            db2.Use();

            Console.Read();
        }
    }

总结：
简单工厂模式的好处是很方便的利用工厂进行对象的创建，但是其违反了开放封闭原则，原因是每次要加数据库（比如公司又要使用Oracle数据库）就需要更改工厂类的分支语句

我们发现，为了把工厂类中的分支去掉，其实可以把一个一个分支都拿出来，单独拿不同的工厂创建，这个思路其实就是工厂方法模式

3. 工厂方法模式

题目：
现有两个数据库，一个SqlServer，一个MySql，并且两个数据库都有一张Users的表，现通过工厂方法模式来让用户选择使用哪个数据库的Users表

结构图（结构是这样，里面函数名称可能不一致）：
在这里插入图片描述

代码：

  1. 建立数据库表类的接口
interface IUsers
    {
        public void Insert();
        public void Use();
    }
  1. 继承其接口的具体类
class SqlServerUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Users表");
        }
    }
    class MySqlUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Users表");
        }
    }
  1. 建立工厂接口
interface IFactory
    {
        public IUsers GetUsers();
    }
  1. 继承工厂接口的具体工厂，生产具体的工厂
 class SqlServerUserFactory : IFactory
    {
        public IUsers GetUsers()
        {
            return new SqlServerUser();
        }
    }
    class MySqlUserFactory : IFactory
    {
        public IUsers GetUsers()
        {
            return new MySqlUser();
        }
    }
  1. 客户端调用
 class Program
    {
        //工厂方法模式是简单工厂模式的升级版，它实现了开放封闭原则，每次需要添加具体时候，比如添加Oracle数据库，先增加一个具体的OracleUsers产品类，然后增加一个生产该类的具体工厂
        static void Main(string[] args)
        {
            //SqlServer的User表的使用
            IFactory factory = new SqlServerUserFactory();
            var db1 = factory.GetUsers();
            db1.Insert();
            db1.Use();

            //MySql的User表的使用
            IFactory factory1 = new MySqlUserFactory();
            var db2 = factory1.GetUsers();
            db2.Insert();
            db2.Use();

            Console.Read();
        }
    }

总结：
工厂方法模式是简单工厂模式的升级版，它实现了开放封闭原则，每次需要添加具体产品类的时候，比如添加Oracle数据库，先增加一个具体的OracleUsers产品类，然后增加一个生产该类的具体工厂

这是单一产品，即Users的表，如果还需要Departments的表，那我们就要有两个不同的产品接口了，此时，就是抽象工厂模式，抽象工厂模式和工厂方法模式不同的是前者是两个或者多个产品接口，而后者只有一个产品接口类

4. 抽象工厂模式

题目：
现有两个数据库，一个SqlServer，一个MySql，并且两个数据库都有一张Users以及一张Departments的表，现通过抽象工厂模式来让用户选择使用哪个数据库的Users表或者Departments表

结构图（结构是这样，里面函数名称可能不一致）：
在这里插入图片描述
代码：

  1. 建立Users数据库表类的接口
interface IUsers
    {
        public void Insert();
        public void Use();
    }
  1. 建立Departments数据库表类的接口
interface IDepartments
    {
        public void Insert();
        public void Use();
    }
  1. 继承其接口的具体类
class SqlServerUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Users表");
        }
    }
    class MySqlUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Users表");
        }
    }

    class SqlServerDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Departments表");
        }
    }
    class MySqlDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Departments表");
        }
    }
  1. 建立工厂接口
interface IFactory
    {
        public IUsers GetUsers();
        public IDepartments GetDepartments();
    }
  1. 继承工厂接口的具体工厂，生产具体的工厂
class SqlServerFactory : IFactory
    {
        public IUsers GetUsers()
        {
            return new SqlServerUser();
        }
        public IDepartments GetDepartments()
        {
            return new SqlServerDepartment();
        }
    }
    class MySqlFactory : IFactory
    {
        public IUsers GetUsers()
        {
            return new MySqlUser();
        }
        public IDepartments GetDepartments()
        {
            return new MySqlDepartment();
        }
    }
  1. 客户端
class Program
    {
        //抽象工厂模式其实就是工厂方法模式的升级版，工厂方法模式只有某个单独的产品类，一个产品接口；而抽象工厂模式包含了多个产品接口，有多个产品类，一定程度上符合了开放封闭原则；但是要添加会显得麻烦，比方添加一个新的产品类，要增加其产品接口以及继承者，还要修改工厂接口以及具体的工厂，太过于麻烦
        static void Main(string[] args)
        {
            IFactory factory = new SqlServerFactory();
            var db1 = factory.GetDepartments();
            db1.Insert();
            db1.Use();

            var db2 = factory.GetUsers();
            db2.Insert();
            db2.Use();

            IFactory factory1 = new MySqlFactory();
            var db3 = factory1.GetDepartments();
            db3.Insert();
            db3.Use();

            var db4 = factory1.GetUsers();
            db4.Insert();
            db4.Use();

            Console.Read();
        }
    }

总结：
抽象工厂模式其实就是工厂方法模式的升级版，工厂方法模式只有某个单独的产品类，一个产品接口；而抽象工厂模式包含了多个产品接口，有多个产品类，一定程度上符合了开放封闭原则；但是要添加会显得麻烦，比方添加一个新的产品类，要增加其产品接口以及继承者，还要修改工厂接口以及具体的工厂，太过于麻烦，我们发现简单工厂模式比较简单，我们用简单工厂模式来改造下抽象工厂模式

5. 简单工厂模式来改造抽象工厂模式

题目：
现有两个数据库，一个SqlServer，一个MySql，并且两个数据库都有一张Users以及一张Departments的表，现通过简单工厂模式来改造抽象工厂模式让用户选择使用哪个数据库的Users表或者Departments表

结构图（结构是这样，里面函数名称可能不一致）：
在这里插入图片描述
代码：

  1. 建立Users数据库表类的接口
interface IUsers
    {
        public void Insert();
        public void Use();
    }
  1. 建立Departments数据库表类的接口
interface IDepartments
    {
        public void Insert();
        public void Use();
    }
  1. 继承其接口的具体类
class SqlServerUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Users表");
        }
    }
    class MySqlUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Users表");
        }
    }

    class SqlServerDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Departments表");
        }
    }
    class MySqlDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Departments表");
        }
    }
  1. 定义简单工厂类
class Factory
    {
        public IUsers GetUsers(string db)
        {
            IUsers users = null;
            switch (db)
            {
                case "SqlServer":
                    users = new SqlServerUser();
                    break;
                case "MySql":
                    users = new MySqlUser();
                    break;
            }
            return users;
        }

        public IDepartments GetDepartments(string db)
        {
            IDepartments departments = null;
            switch (db)
            {
                case "SqlServer":
                    departments = new SqlServerDepartment();
                    break;
                case "MySql":
                    departments = new MySqlDepartment();
                    break;
            }
            return departments;
        }
    }
  1. 客户端
class Program
    {
        //这个用简单工厂模式改造抽象工厂模式的好处是，增加起来不用那么麻烦，但是仍然违反了开放封闭原则，我们应该想办法让简单工厂类里的分支语句消失，只要增加类，工厂也能检测到，那么就是靠反射来实现了
        static void Main(string[] args)
        {
            Factory factory = new Factory();
            var t = factory.GetDepartments("SqlServer");
            t.Insert();
            t.Use();

            Console.Read();
        }
    }

总结：
这个用简单工厂模式改造抽象工厂模式的好处是，增加起来不用那么麻烦，但是仍然违反了开放封闭原则，我们应该想办法让简单工厂类里的分支语句消失，只要增加类，工厂也能检测到，那么就是靠反射来实现了

6. 通过反射继续改善工厂模式

题目：
现有两个数据库，一个SqlServer，一个MySql，并且两个数据库都有一张Users以及一张Departments的表，现通过运用反射技术来改造工厂模式让用户选择使用哪个数据库的Users表或者Departments表

结构图（结构是这样，里面函数名称可能不一致）：
在这里插入图片描述
代码：

  1. 建立Users数据库表类的接口
interface IUsers
    {
        public void Insert();
        public void Use();
    }
  1. 建立Departments数据库表类的接口
interface IDepartments
    {
        public void Insert();
        public void Use();
    }
  1. 继承其接口的具体类
class SqlServerUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Users表");
        }
    }
    class MySqlUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Users表");
        }
    }

    class SqlServerDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Departments表");
        }
    }
    class MySqlDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Departments表");
        }
    }
  1. 简单工厂类里运用反射技术
 class Factory
    {
        public string table;
        public IUsers GetUsers()
        {
            var t =(IUsers) Assembly.Load("通过反射继续改善工厂模式").CreateInstance("通过反射继续改善工厂模式." + table);
            return t;
        }

        public IDepartments GetDepartments()
        {
            var t = (IDepartments)Assembly.Load("通过反射继续改善工厂模式").CreateInstance("通过反射继续改善工厂模式." + table);
            return t;
        }
    }
  1. 客户端
class Program
    {
        //通过反射改造的工厂，获取实例时候已经取消了分支判断语句，而是以反射的形式动态的根据需要创建实例，但是目前有个缺陷是，需要在客户端指定类名，当我们添加了新的产品类时候，还是需要更改客户端，我们可以更完美些；考虑写在配置文件里，不在客户端内传值
        static void Main(string[] args)
        {
            Factory factory = new Factory();
            factory.table = "SqlServerUser";
            var db=factory.GetUsers();
            db.Insert();
            db.Use();

            factory.table = "MySqlDepartment";
            var db1 = factory.GetDepartments();
            db1.Insert();
            db1.Use();

            Console.Read();
        }
    }

总结：
通过反射改造的工厂，获取实例时候已经取消了分支判断语句，而是以反射的形式动态的根据需要创建实例，但是目前有个缺陷是，需要在客户端指定类名，当我们添加了新的产品类时候，还是需要更改客户端，我们可以更完美些；考虑写在配置文件里，不在客户端内传值

7. 通过反射改善工厂模式最终版

题目：
现有两个数据库，一个SqlServer，一个MySql，并且两个数据库都有一张Users以及一张Departments的表，现通过运用反射技术来改造工厂模式让用户选择使用哪个数据库的Users表或者Departments表

代码：

  1. 建立Users数据库表类的接口
interface IUsers
    {
        public void Insert();
        public void Use();
    }
  1. 建立Departments数据库表类的接口
interface IDepartments
    {
        public void Insert();
        public void Use();
    }
  1. 继承其接口的具体类
class SqlServerUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Users表");
        }
    }
    class MySqlUser : IUsers
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Users表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Users表");
        }
    }

    class SqlServerDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("SqlServer为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("SqlServer使用Departments表");
        }
    }
    class MySqlDepartment : IDepartments
    {
        public void Insert()
        {
            Console.WriteLine("MySql为Departments表插入数据");
        }

        public void Use()
        {
            Console.WriteLine("MySql使用Departments表");
        }
    }
  1. 简单工厂类里运用反射技术
 class Factory
    {
        private string table = ConfigurationManager.AppSettings["db"];

        public IUsers GetUsers()
        {
            string t = table + "User";
            var w = (IUsers)Assembly.Load("通过反射改善工厂模式最终版").CreateInstance("通过反射改善工厂模式最终版." + t);
            return w;
        }

        public IDepartments GetDepartments()
        {
            string t = table + "Department";
            var w = (IDepartments)Assembly.Load("通过反射改善工厂模式最终版").CreateInstance("通过反射改善工厂模式最终版." + t);
            return w;
        }
    }
  1. 客户端
class Program
    {
        //通过反射改造的工厂，获取实例时候已经取消了分支判断语句，而是以反射的形式动态的根据需要创建实例，将选择实例化的字段写在配置文件里，不在客户端内传值，最终完美版
        //此时如果需要切换数据库只需要更改配置文件中的键值对<key-value>的value即可
        static void Main(string[] args)
        {
            Factory factory = new Factory();
            var db = factory.GetUsers();
            db.Insert();
            db.Use();


            var db1 = factory.GetDepartments();
            db1.Insert();
            db1.Use();

            Console.Read();
        }
    }
  1. 配置文件
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
	<appSettings>
		<add key="Db" value="SqlServer"/>
	</appSettings>
</configuration>

总结：
通过反射改造的工厂，获取实例时候已经取消了分支判断语句，而是以反射的形式动态的根据需要创建实例，将选择实例化的字段写在配置文件里，不在客户端内传值，最终完美版

此时如果需要切换数据库只需要更改配置文件中的键值对 key-value的value即可

8. 例子用的所有源码

https://github.com/516886731/-

Java-设计模式之工厂模式（静态工厂模式、工厂方法模式、抽象工厂模式）
clearlxj的博客
11-16 878
工厂模式(静态工厂模式、工厂方法模式、抽象工厂模式) 引子 话说十年前,有一个暴发户,他家有三辆汽车——Benz 奔驰、Bmw 宝马、Audi 奥迪,还雇了司机为他开车。不过,暴发户坐车时总是怪怪的:上 Benz 车后跟司机说“开奔驰车! ”,坐上 Bmw 后他说“开宝马车!”,坐上 Audi 说“开奥迪车!”。你一定说:这人有病!直接说开车不就行了?! 而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象。幸运的是,这种有病的现象在 OO(面向对象)语言中可以避免了。下面就以 Jav
（11）设计模式之抽象工厂模式+使用简单工厂改进（反射+XML）
m0_55759099的博客
06-12 469
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 本质：选择产品，族的实现。为了方便理解，我们先来举个例子，在之前讲设计模式的六大原则的依赖倒转原则的时候提到了类似的情况。例如，在我们做项目的时候，对不同数据库的相同操作，如对Access数据库和Sqlserver数据库都进行查询或插入的操作，虽然操作一样，但是对于不同的数据库的操作，代码就不一样。可以从依赖倒转原则知道， 高层模块不应该依赖底层模块。两个都应该依赖对象。 抽象不应该依赖细节。细节应该依赖抽象。 说白了就是要
设计模式之3种工厂模式对比和简单介绍
Nicky's blog
04-24 3386
定义 简单工厂模式又称静态工厂模式。可以根据参数的不同返回不同类的实例。定义一个类来创建其它类的实例。 角色 简单工厂模式包含如下角色 Factory：工厂角色 Product：抽象产品角色 ConcreteProduct：具体产品角色 简单实例 public abstract class Produce{ public abstract void m1()''...
软件构造：设计模式对比
djj810625的博客
05-07 263
static factory 和 abstract factory 同：简化了创建的过程。主要解决接口选择的问题。 不同： static Factory让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加。需要一辆汽车，可以直接从工厂...
抽象工厂模式(Abstract Factory)及代码实现
rgc_520_zyl的博客
10-26 966
什么是抽象工厂? 抽象工厂模式 是在 工厂模式的基础上 对工厂进行抽象一层 ;属于 创建型模式; 抽象工厂设计模式是抽象方法的一种泛化。概括来说，一个抽象工厂是（逻辑上的）一组工 厂方法，其中的每个工厂方法负责产生不同种类的对象; 现实生活中的例子: 汽车制造业应用了抽象工厂的思想。冲压不同汽车模型的部件（可以认为 是 车门工厂、车轮工厂、车篷工厂、挡泥工厂等）所使用的机件是相同的。机件装配起来的模型随时可配置，且易于改变。从下图 我们能看到汽车制造业抽象工厂的一个例子 ...
设计模式(四)———工厂设计模式的比较
社会你鑫哥的博客
03-24 250
简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力） 工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品） 抽象工厂：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族） 1.简单工厂和工厂方法的区别：简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，...
Android编程设计模式之工厂方法模式实例详解
01-20
总结，工厂方法模式是Android开发中常用的设计模式之一，它提供了一种灵活的创建对象的方式，有助于代码的解耦和扩展。通过理解并熟练运用工厂方法模式，可以提升Android应用程序的质量和可维护性。
java设计模式之简单工厂模式简述
09-01
简单工厂模式是软件设计模式中的一种基础模式，它在Java编程中被广泛使用。这个模式的主要目的是通过一个公共的...如果产品种类繁多或者经常变动，可能需要考虑使用更复杂的工厂模式，如工厂方法模式或抽象工厂模式。
java三大工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）
QyangR1123的博客
10-13 944
工厂模式主要是通过把创建对象的代码包装起来，做到创建对象的代码与具体的业务逻辑代码相隔离的目的。工厂模式可以细分为：简单工厂模式，工厂方法模式，抽象工厂模式。通过我们上面的各种例子，我们可以发现不管我们怎么修改设计方式，都不能够同时满足灵活性高和不违反开闭原则。如果要同时满足的话，就需要引入反射的思想，通过反射+抽象工厂的方式实现。
工厂类
海恩的博客
04-30 1837
作用 将new和init对象的工作从构造器中分离开。 我们以类Sample为例， 如果我们要创建Sample的实例对象: Sample sample=new Sample(); 可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。 首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成: Sample samp...
初探Java设计模式1：创建型模式（工厂，单例等）
mhHao的博客
09-04 178
一直想写一篇介绍设计模式的文章，让读者可以很快看完，而且一看就懂，看懂就会用，同时不会将各个模式搞混。自认为本文还是写得不错的????????????，花了不少心思来写这文章和做图，力求让读者真的能看着简单同时有所收获。 设计模式是对大家实际工作中写的各种代码进行高层次抽象的总结，其中最出名的当属 Gang of Four (GoF) 的分类了，他们将设计模式分类为 23 种经典的模式，根据用途我们又可以分为三大类...
什么是工厂类
weixin_37871174的博客
06-26 3650
当定义多个类，且他们之间相互有关系时候，比如一个Base A 类，派生了很多子类B,C,D，当每个子类进行对象实例化时候，我们一般的做法就是通过new B,new C,new D这样的方式产生对应的对象。这样当然是可以的，但是我们在C++中希望的是通过一个工厂类，去产生我们想要的对象。而工厂类就做到了一个提供接口(设计模式的目的，提供接口而不提供代码)的目的。同时这个工厂类的create接口实现也可以对我们理解代码有很大的帮助。其实简单一点理解就是工厂类有点类似一个函数接口，铜鼓传入不同的参数在工厂类内部区
简单工厂（静态工厂）
吴渣渣的博客
09-07 9328
简单工厂（静态工厂） 示例 使用典范 简单工厂（静态工厂） 定义：由一个工厂对象决定创建出哪一种产品类的实例 类型：创建型，不属于GOF23种设计模式 适用场景： 工厂类负责创建的对象比较少 客户端（应用层）只知道传入工厂类的参数，对于如何创建对象（逻辑）并不关心 优点：只需要传入一个正确的参数，就可以获取你所需要的对象而不需要知道其创建的细节 缺点：工厂类的职责...
简单工厂(可配置的工厂类)和工厂方法模式以及抽象工厂
continue my dream
10-10 602
首先，把简单工厂、工厂方法以及抽象工厂放在一起来学习主要是为了让我们更加清晰的了解、掌握它们的区别以及使用的场合。工厂方法的出现是解决简单工厂出现的问题（违背了设计原则的开闭原则OCP），而抽象工厂是解决工厂方法出现的问题(不能创建不同系列的产品)。顺便啰嗦几句：无论你在学习什么东西，它应该是有价值（我个人认为的价值就是能帮我们解决某一类或某一个问题）的，否则这个东西就没有学习的必要。如果你在学习
java自定义工厂类_【java设计模式】之 工厂（Factory）模式
weixin_34379710的博客
02-27 1123
1.工厂模式的定义工厂模式使用的频率很高。我们在开发中总能见到它们的身影。其定义为：Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasse...
工厂模式（简单工厂、工厂方法、抽象工厂的迭代）
jiatai_的博客
03-12 255
工厂对象定义： 定义一个创建产品对象的工厂接口，将产品的实际创建工作推迟到具体的子工厂类中。满足了创建型模式中“创建与使用分离”。凡是需要生产复杂对象的地方可以考虑使用工厂模式代替。复杂对象一般是指构造函数过多等对类的构造有影响的情况，因为类的构造过于复杂，在业务类中直接使用，则两者的耦合过重，假如后续业务变更，需要构建的类对象构造参数发生改变时，则需要在任何引用该类的业务代码内更改。 按实际业务场景划分：简单工厂、工厂方法、抽象工厂。 被创建的对象称为：”产品“、创建产品的对象称为：”工厂“ 简单工厂模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值