精华内容
下载资源
问答
  • 但是在实际过程中还有一种工厂模式经常被使用,那就是 简单工厂模式(Simple Factory)。有一种常见的分类的方法:根据产品是由具体产品还是具体工厂可以分为 工厂方法模式 和 简单工厂模式;根据工厂的抽象程度可以...
  • 简单工厂模式uml类图

    2018-03-07 10:09:52
    java设计模式 简单工厂模式uml类图,一张图就让你秒懂简单工厂模式
  • 简单工厂模式.zip

    2020-04-09 14:47:26
    本资源是设计模式>第2版,刘伟,简单工厂模式课后习题4、5的自己写的demo,如果有问题,请留言一起讨论
  • 这是设计模式中简单工厂设计模式的源代码,工程中以一个计算器的示例来体现简单工厂模式的精髓。简单工厂模式主要解决创建对象的问题。
  • 本文实例讲述了JavaScript设计模式–简单工厂模式定义与应用。分享给大家供大家参考,具体如下: 一,介绍 工厂模式创建对象(视为工厂里的产品)时无需指定创建对象的具体类。 工厂模式定义一个用于创建对象的接口...
  • 请用Java面向对象语言,利用简单工厂模式,实现简易计算器程序(加减乘除功能)。 在注释中回答以下问题: 1、 软件设计目标分别是什么? 2、 在相应的代码处解释设计目标实现的方式。
  • 简单工厂模式的例子

    2019-03-27 01:05:56
    NULL 博文链接:https://306963591.iteye.com/blog/1133631
  • 简单工厂模式又叫静态工厂方法模式,工厂模式家族中最简单的一种模式。这个模式的基本工作方式: 通过一个工厂来决定创建哪种具体的产品实例。 下面是一个简单的工厂实例: def create_animal(name): if name == '...
  • 自己写的一个简单工厂模式的案例
  • 设计模式之简单工厂模式案例
  • JAVA简单工厂模式四则运算计算器
  • 简单工厂模式

    千次阅读 2020-12-14 21:51:16
    在日常开发中,凡是需要生成复杂对象的地方,都可以尝试考虑使用工厂模式来代替。 复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况,因为类的构造过于复杂,如果直接在其他业务类内使用,则两者的耦合...

    在日常开发中,凡是需要生成复杂对象的地方,都可以尝试考虑使用工厂模式来代替。

    复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况,因为类的构造过于复杂,如果直接在其他业务类内使用,则两者的耦合过重,后续业务更改,就需要在任何引用该类的源代码内进行更改,光是查找所有依赖就很消耗时间了,更别说要一个一个修改了。

    工厂模式的定义:

    是指定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

    按实际业务场景划分,工厂模式有 3 种不同的实现方式,分别是

    • 简单工厂模式
    • 工厂方法模式
    • 抽象工厂模式

    一、简单工厂模式

    1、简单工厂模式的定义

    简单工厂模式(Simple Factory Pattern) ,又叫作静态工厂方法模式(Static Factory Method Pattern)。

    我们把被创建的对象称为“产品”,把创建产品的对象称为“工厂”。如果要创建的产品不多,只要一个工厂类就可以完成,这种模式叫“简单工厂模式”。

    简单来说,简单工厂模式有一个具体的工厂类,可以生成多个不同的产品,属于创建型设计模式。
    简单工厂模式不在 GoF 23 种设计模式之列。

    2、简单工厂模式的结构

    (1)简单工厂模式主要 3个角色

    • 简单工厂(SimpleFactory):
      是简单工厂模式的核心,负责实现创建所有实例的内部逻辑。工厂类的-建产品类的方法可以被外界直接调用,创建所需的产品对象。
    • 抽象产品(Product):
      是简单工厂创建的所有对象的父类,负责描述所有实例共有的公共接口。
    • 具体产品(ConcreteProduct):
      -是简单工厂模式的创建目标。

    (2)结构图如下:(图来自网络)
    在这里插入图片描述

    3、优缺点

    主要优点:

    • 结构简单,调用方便。工厂和产品的职责区分明确。
    • 客户端无需知道所创建具体产品的类名,只需知道参数即可。

    主要缺点:

    • 简单工厂模式的工厂类单一,负责所有产品的创建,职责过重,一旦异常,整个系统将受影响。且工厂类代码会非常臃肿,违背高聚合原则。

    4、使用场景

    对于产品种类相对较少的情况,考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数,不需要关心如何创建对象的逻辑,可以很方便地创建所需产品。

    5、在框架源码中使用也很广泛

    • JDK源码中的 Calendar.getInstance()方法
    • Logback源码中多个重载的 getLogger()方法

    二、模式的通用实现

    代码如下:

    public class SimpleFactoryPattern {
        public static void main(String[] args) {
            Product product = SimpleFactory.makeProduct(2);
            product.show();
        }
        //抽象产品
        public interface Product {
            void show();
        }
        //具体产品:ProductA
        static class ConcreteProduct1 implements Product {
            @Override
            public void show() {
                System.out.println("具体产品1显示...");
            }
        }
        //具体产品:ProductB
        static class ConcreteProduct2 implements Product {
            @Override
            public void show() {
                System.out.println("具体产品2显示...");
            }
        }
        //具体产品:ProductC
        static class ConcreteProduct3 implements Product {
            @Override
            public void show() {
                System.out.println("具体产品3显示...");
            }
        }
        final class Const {
            static final int PRODUCT_A = 0;
            static final int PRODUCT_B = 1;
            static final int PRODUCT_C = 2;
        }
        static class SimpleFactory {
            public static Product makeProduct(int kind) {
                switch (kind) {
                    case Const.PRODUCT_A:
                        return new ConcreteProduct1();
                    case Const.PRODUCT_B:
                        return new ConcreteProduct2();
                    case Const.PRODUCT_C:
                        return new ConcreteProduct3();
                }
                return null;
            }
        }
    }
    

    三、模式的应用实例

    简易计算器为例,需求:输入两个数和运算符,得到结果。

    1、抽象产品

    public abstract class Operation {
        protected abstract double compute (double number1, double number2) throws Exception;
    }
    

    2、具体产品

    • 加法
    public class OperationAdd extends Operation{
        @Override
        protected double compute(double number1, double number2) {
            return number1 + number2;
        }
    }
    
    • 减法
    public class OperationSub extends Operation{
        @Override
        protected double compute(double number1, double number2) {
            return number1 - number2;
        }
    }
    
    • 乘法
    public class OperationMul extends Operation{
        @Override
        protected double compute(double number1, double number2) {
            return number1 * number2;
        }
    }
    
    • 除法
    public class OperationDiv extends Operation{
        @Override
        protected double compute(double number1, double number2) throws Exception {
            if(number2 == 0){
                throw new Exception("除数不能为0!");
            }
            return number1 / number2;
        }
    }
    

    3、简单工厂

    这里对简单工厂创建产品进行了优化。可以通过缓存、配置文件、反射和泛型等技术了优化。
    如果运算业务需要扩展,需要创建具体运算类即可,不需要再修改简单工厂类了。

    public class OperationFactory {
    
        private static final Map<String, Operation> cachedParsers = new HashMap<>();
    
        static {
            cachedParsers.put("+", new OperationAdd());
            cachedParsers.put("-", new OperationSub());
            cachedParsers.put("*", new OperationMul());
            cachedParsers.put("/", new OperationDiv());
        }
    
        public static Operation createOperate0(String operate) {
            if (operate == null || operate.isEmpty()) {
                return null;//返回null还是IllegalArgumentException全凭你自己说了算
            }
            return cachedParsers.get(operate);
        }
    
        /**
         *  createOperate0运用缓存技术,节省内存和对象创建的时间
         *  createOperate0 和 createOperate1 同理
         */
        public static Operation createOperate1(String operate){
            Operation operation = null;
            switch (operate){
                case "+":
                    operation = new OperationAdd(); break;
                case "-":
                    operation = new OperationSub(); break;
                case "*":
                    operation = new OperationMul(); break;
                case "/":
                    operation = new OperationDiv(); break;
            }
            return operation;
        }
    
         /**
          * createOperate1方法不符合开闭原则
          *      如果运算业务继续扩展,需要创建具体运算类,也需要修改简单工厂的 createOperate1方法。
          * 采用反射技术进行优化,即createOperate2方法
         */
        public static Operation createOperate2(String className){
            Operation operation = null;
            try {
                if(!(null == className || "".equals(className))){
                    operation = (Operation) Class.forName(className).newInstance();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return operation;
        }
    
        /**
         * createOperate2方法中类型强制转型,参数为字符串,可控性不高
         * 采用反射和泛型技术进行优化,即createOperate3方法
         */
        public static Operation createOperate3(Class<? extends Operation> clazz){
            try {
                if(null != clazz){
                    return clazz.newInstance();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }
    

    4、测试

    public class Test {
        public static void main(String[] args) throws Exception {
            double num1 = 10;
            double num2 = 2;
            System.out.println(OperationFactory.createOperate0("*").compute(num1, num2));
            System.out.println(OperationFactory.createOperate1("*").compute(num1, num2));
    
            Operation operate2 = OperationFactory.createOperate2("cn.jq.learn.simplefactorypattern.OperationDiv");
            System.out.println(operate2.compute(num1, num2));
    
            Operation operate3 = OperationFactory.createOperate3(OperationAdd.class);
            System.out.println(operate3.compute(num1, num2));
        }
    }
    

    在这里插入图片描述

    参考文章:

    —— Stay Hungry. Stay Foolish. 求知若饥,虚心若愚。

    展开全文
  • 介绍的是工厂模式 包括简单工厂模式、工厂方法模式、抽象工厂模式 包括PPT和代码
  • python版简单工厂模式

    2020-09-21 03:23:29
    主要为大家详细介绍了python版简单工厂模式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 一共四个包,从名字可以看出来,pre1是最差的写法,pre2是继承的写法,然后是简单工厂模式的写法和工厂模式的写法。
  • 主要介绍了Java简单工厂模式定义与用法,结合实例形式分析了java简单工厂模式的相关定义与使用技巧,并给出了原理类图进行总结,需要的朋友可以参考下
  • 简单工厂模式小应用

    2015-07-22 12:32:17
    简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。 结合简单工厂模式 完成的小应用
  • JAVA设计模式(01):创建型-工厂模式【简单工厂模式】(Simple Factory)
  • 本文实例讲述了Python设计模式之简单工厂模式。分享给大家供大家参考,具体如下: 简单工厂模式(Simple Factory Pattern):是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类. 下面使用...
  • Java简单工厂模式和传统模式实现对比,通过简单实例比对两种方式差异,体现传统模式的弊端及工厂模式优势。利于初学者后续接触spring
  • 基于简单工厂模式的实例在安卓平台下。项目是AndroidStudio下的
  • 本文实例讲述了js简单工厂模式用法。分享给大家供大家参考。具体实现方法如下: <!DOCTYPE html> <html> <head> <title>简单工厂模式</title> </head> <body> [removed] /...
  • 简单工厂模式和工厂方法模式的区别 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了于具体产品的依赖。而工厂方法模式定义了一个用于...
  • 运用两个典型案例,实现软件设计模式的简单工厂模式,从该案例中,可以体会简单工厂模式的特点
  • 6. 简单工厂模式 部分源码实例: // 奔驰工厂 class BenzFactory : public AFactory { public: ICar* CreateCar() { return new BenzCar(); } }; // 宝马工厂 class BmwFactory : public AFactory { public: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 228,878
精华内容 91,551
关键字:

简单工厂模式