对简单工厂模式、工厂方法模式的思考

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量807 收藏 10
点赞数 4
分类专栏： java后端技术栈 设计模式 文章标签： 简单工厂模式 工厂方法模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37477009/article/details/136430741
版权

目录

1 背景

题目源自：【设计模式专题之工厂方法模式】2.积木工厂

1.1 题目描述

小明家有两个工厂，一个用于生产圆形积木，一个用于生产方形积木，请你帮他设计一个积木工厂系统，记录积木生产的信息。

1.2 输入描述

输入的第一行是一个整数 N（1 ≤ N ≤ 100），表示生产的次数。
接下来的 N 行，每行输入一个字符串和一个整数，字符串表示积木的类型。积木类型分为 “Circle” 和 “Square” 两种。整数表示该积木生产的数量

1.3 输出描述

对于每个积木，输出一行字符串表示该积木的信息。

1.4 输入示例

3
Circle 1
Square 2
Circle 1

1.5 输出示例

Circle Block
Square Block
Square Block
Circle Block

2 简单工厂模式

  • 一个工厂生产多个对象。
    • （1）抽象对象【通过接口进行抽象】
    • （2）具体对象【通过类实现接口】
    • （3）具体工厂
  • 代码示例：
public class Main {
    public static void main(String[] args) {
        ShapeFactorySystem shapeFactorySystem = new ShapeFactorySystem(new SimpleShapeFactory());

        Scanner scanner = new Scanner(System.in);
        int count = Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < count; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            String type = parts[0];
            shapeFactorySystem.produce(type, Integer.parseInt(parts[1]));
        }
    }
}

interface Shape {
    void draw(int n);
}

class Circle implements Shape {
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("Circle Block");
        }
    }
}

class Square implements Shape {

    @Override
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("Square Block");
        }
    }
}

class SimpleShapeFactory {
    public Shape createShape(String type) {
        if ("Circle".equals(type)) {
            return new Circle();
        } else if ("Square".equals(type)) {
            return new Square();
        } else {
            throw new RuntimeException("Unknown type");
        }
    }
}

class ShapeFactorySystem {
    private SimpleShapeFactory simpleShapeFactory;

    public ShapeFactorySystem(SimpleShapeFactory simpleShapeFactory) {
        this.simpleShapeFactory = simpleShapeFactory;
    }

    public void produce(String type, int n) {
        Shape shape = simpleShapeFactory.createShape(type);
        shape.draw(n);
    }
}

3 工厂方法模式

  • 和简单工厂不同的是，不同对象的生产工厂也不同。
  • 代码示例：
public class Main {
    public static void main(String[] args) {
        ShapeFactorySystem shapeFactorySystem = new ShapeFactorySystem(new CircleFactory(), new SquareFactory());

        Scanner scanner = new Scanner(System.in);
        int count = Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < count; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            String type = parts[0];
            shapeFactorySystem.produce(type, Integer.parseInt(parts[1]));
        }
    }
}

interface Shape {
    void draw(int n);
}

class Circle implements Shape {
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("Circle Block");
        }
    }
}

class Square implements Shape {

    @Override
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("Square Block");
        }
    }
}

interface ShapeFactory {
    Shape createShape(String type);
}

class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape(String type) {
        return new Circle();
    }
}

class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape(String type) {
        return new Square();
    }
}

class ShapeFactorySystem {
    private ShapeFactory circleFactory;
    private ShapeFactory squareFactory;

    public ShapeFactorySystem(ShapeFactory circleFactory, ShapeFactory squareFactory) {
        this.circleFactory = circleFactory;
        this.squareFactory = squareFactory;
    }

    public void produce(String type, int n) {
        Shape shape;
        if ("Circle".equals(type)) {
            shape = circleFactory.createShape(type);
        } else if ("Square".equals(type)) {
            shape = squareFactory.createShape(type);
        } else {
            throw new RuntimeException("Unknown type");
        }
        shape.draw(n);
    }
}

4 思考

  • 从这个例子中，看不出工厂方法模式比简单工厂模式好在哪里。
  • 假设需求变化了，需要增加一种类型，那么，对于简单工厂模式，只要修改：
// 新增类
class xxx implements Shape {
    @Override
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("xxx Block");
        }
    }
}

// 修改方法
class SimpleShapeFactory {
    public Shape createShape(String type) {
        if ("Circle".equals(type)) {
            return new Circle();
        } else if ("Square".equals(type)) {
            return new Square();
        } else if (xxx.equals(type)) {
        	...
		} else {
            throw new RuntimeException("Unknown type");
        }
    }
}
  • 但是对应用层代码（main方法）不需要做任何改动。这反而更好。
  • 对于简单工厂模式，要修改：
// 修改应用层代码
public static void main(String[] args) {
    ShapeFactorySystem shapeFactorySystem = new ShapeFactorySystem(new CircleFactory(), new SquareFactory(), xxx);

    Scanner scanner = new Scanner(System.in);
    int count = Integer.parseInt(scanner.nextLine());
    for (int i = 0; i < count; i++) {
        String line = scanner.nextLine();
        String[] parts = line.split(" ");
        String type = parts[0];
        shapeFactorySystem.produce(type, Integer.parseInt(parts[1]));
    }
}

// 新增类
class xxx implements Shape {
    @Override
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("xxx Block");
        }
    }
}

// 新增类
class xxxFactory implements ShapeFactory {
	...
}

class ShapeFactorySystem {
    private ShapeFactory circleFactory;
    private ShapeFactory squareFactory;
    private xxxFactory ...;

    public ShapeFactorySystem(ShapeFactory circleFactory, ShapeFactory squareFactory, xxxFactory ...) {
        this.circleFactory = circleFactory;
        this.squareFactory = squareFactory;
        ...
    }

    public void produce(String type, int n) {
        Shape shape;
        if ("Circle".equals(type)) {
            shape = circleFactory.createShape(type);
        } else if ("Square".equals(type)) {
            shape = squareFactory.createShape(type);
        } else if (xxx) {
        	...
        } else {
            throw new RuntimeException("Unknown type");
        }
        shape.draw(n);
    }
}
  • 真麻烦啊。

4.1 改进工厂方法模式

  • 代码示例：
public class Main {
    public static void main(String[] args) {
        ShapeFactorySystem shapeFactorySystem = ShapeFactorySystem.getSingleton();

        Scanner scanner = new Scanner(System.in);
        int count = Integer.parseInt(scanner.nextLine());
        for (int i = 0; i < count; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            String type = parts[0];
            shapeFactorySystem.produce(type, Integer.parseInt(parts[1]));
        }
    }
}

interface Shape {
    void draw(int n);
}

class Circle implements Shape {
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("Circle Block");
        }
    }
}

class Square implements Shape {

    @Override
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("Square Block");
        }
    }
}

interface ShapeFactory {
    Shape createShape();
}

class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

class ShapeFactorySystem {
    private static final Map<ShapeType, ShapeFactory> shapeFactoryMap = new HashMap<>();

    private static ShapeFactorySystem shapeFactorySystem;

    private ShapeFactorySystem() {
        shapeFactoryMap.put(ShapeType.CIRCLE, new CircleFactory());
        shapeFactoryMap.put(ShapeType.SQUARE, new SquareFactory());
    }

    public static ShapeFactorySystem getSingleton() {
        if (shapeFactorySystem == null) {
            synchronized (ShapeFactorySystem.class) {
                if (shapeFactorySystem == null) {
                    shapeFactorySystem = new ShapeFactorySystem();
                }
            }
        }

        return shapeFactorySystem;
    }

    private ShapeFactory acquireShapeFactory(ShapeType type) {
        return shapeFactoryMap.get(type);
    }

    public void produce(String type, int n) {
        ShapeFactory shapeFactory = acquireShapeFactory(ShapeType.of(type));
        Shape shape = shapeFactory.createShape();
        shape.draw(n);
    }
}

enum ShapeType {
    CIRCLE("Circle"), SQUARE("Square");

    private String value;

    private ShapeType(String value) {
        this.value = value;
    }

    private String getValue() {
        return value;
    }

    public static ShapeType of(String value) {
        for (ShapeType shapeType : ShapeType.values()) {
            if (shapeType.getValue().equals(value)) {
                return shapeType;
            }
        }
        // 如果没有找到匹配的枚举对象，可以抛出一个异常或返回null
        throw new IllegalArgumentException("Unknown ShapeType: " + value);
    }
}

多线程场景下，不能用HashMap。

  • 如果新增一种类型：
// 新增类
class xxx implements Shape {

    @Override
    public void draw(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("xxx Block");
        }
    }
}

// 新增类
class xxxFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new xxx();
    }
}

// 修改方法（不修改之前代码，新增语句）
private ShapeFactorySystem() {
   shapeFactoryMap.put(ShapeType.CIRCLE, new CircleFactory());
   shapeFactoryMap.put(ShapeType.SQUARE, new SquareFactory());
}

// 不修改之前的代码，加一个枚举对象
enum ShapeType {
    CIRCLE("Circle"), SQUARE("Square"), xxx;
    ...
}
  • 当然了，通过map + enum这种改进也可以应用到简单工厂模式中。
  • 不过，当创建对象变得复杂时，简单工厂模式就难以应用对了：
class SimpleShapeFactory {
    public Shape createShape(String type) {
        if ("Circle".equals(type)) {
            return new Circle(); // 简单对象
        } else if ("Square".equals(type)) {
            return new Square(); // 简单对象
        } else {
            throw new RuntimeException("Unknown type");
        }
    }
}
南七行者
关注
专栏目录
【设计模式】（二）工厂方法模式详解
qq_41526047的博客
07-29 1047
针对工厂方法模式进行详细讲解
简单工厂模式VS工厂方法模式的个人思考
smallUmbralla的博客
09-28 100
前言 学习《大话设计模式》，想把自己的想法记在这里，如有错误（必有疏漏），还请路过的朋友们指教，感谢！ 正文 工厂模式（概念性知识） 作用 实现了类创建者和调用者的分离。 分类 简单工厂模式 用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码），一个工厂 对比工厂方法 代码简单 编程简单 管理简单 结构简单 根据...
设计模式 -- 工厂方法模式以及抽象工厂模式
w5_Silence的博客
04-17 280
工厂方法模式是一种常用的类创建型设计模式,次模式的核心精神是封装类中变化的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦,复用和方便后期维护拓展的目的工厂方法模式的应用也十分广泛,包括java的spring框架中的BeanFactory就是一个工厂方法的实现,因此我们在学习的过程中不仅要知道原理,还要思考原理如何应用到实际中.
Java 设计模式-简单工厂模式
精神小牛马
07-26 1148
java设计模式简单工厂模式
简单工厂模式-实现简易计算器
qq_44256373的博客
02-07 2355
场景 今天遇到一个面试题，题目为“C++、Java、或VB.NET任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果”。 问题分析 通常面对这样的问题，会心有成竹、下笔有神，心想写一个简易的计算机控制程序还不简单吗？不就是输入数字，在输入符号，最后得出结果。但是这个题目真的只是考验这个逻辑吗？所有的编程初学者都会有这样的问题，就是碰到问题就直觉地用计算机能够理解的逻辑来描述和表达待解决的问题及具体的求解过程。这其实是用计算机的方式去思考，比如计算器这个程序，先要求输入两个数和符
设计模式：从工厂方法模式到 IOC/DI思想
糖拌西红柿
06-13 1065
设计模式、工厂模式、IOC、DI，控制反转、依赖注入
简单工厂-工厂方法-抽象工厂模式
Alexon Xu的博客
03-09 457
工厂模式的本质就是对获取对象过程的抽象 工厂模式主要可以分为三大类： 简单工厂模式 工厂方法模式 抽象工程模式 简单工厂模式 工厂模式主要是用于对实现逻辑的封装，并且通过对公共的接口提供对象的实列画的服务，在我添加新的类时不需大动干戈，只要修改一点点就好。 举个例子我之前所在的电商业务怎么创建创建商品的： 在这个简单工厂里面，如果要创建活动商品1 以及活动商品2，我们要创建商品的时候只要调用简单工厂里面的创建商品方法，根据类型创建出不同的商品然后实列化返回就可以了。 简单工厂几种实现方式： ...
HIT软件构造——有关工厂方法模式的一些思考
zhr_never_giveup的博客
05-27 963
工厂方法是一种创建型设计模式，它定义了一个用于创建对象的接口，但将实际的实例化推迟到子类中。这样，子类可以决定要实例化的具体类。工厂方法模式允许一个类在运行时动态创建对象，而不需要直接指定它们的具体类。这种模式有助于降低代码的耦合度，使得代码更易于扩展和维护。
设计模式——简单工厂、工厂方法和抽象工厂的区别与联系
weixin_42785235的博客
06-02 1699
创建型模式中，常用的有工厂方法模式和抽象工厂模式，平时实践还包括简单工厂模式，虽然简单工厂模式不在23种设计模式中。 为了区分以上几种设计模式的差别，通过以下几个例子介绍这几种模式的使用场景以及优缺点。当然，由于本人接触设计模式时间还不长，难免有疏漏之处，欢迎各位提出意见。考虑如今有一个产品，比如椅子，该椅子可以有多种风格，比如中式的，或者美式的。如果我们不想通过设计模式，想要什么类型的椅子，就可以直接实例化某个实体类获得。“ChineseChair.java”——实体类 “Client.java”——用户
工厂模式及模板方法模式深度思考
04-14
工厂模式通常有三种实现方式：简单工厂、工厂方法和抽象工厂。在简单工厂中，一个工厂类负责创建所有类型的对象；工厂方法则将对象的创建过程交给子类决定；抽象工厂则用于创建相关或依赖对象的家族，确保这些对象都...
Java设计模式之简单工厂模式
m0_54850952的博客
10-28 1376
所以，干脆在模块内部新建一个类，在这个类里面来创建接口，然后把创建的接口返回给具体调用者，这样，外部应用就只需根据这个类来获取相应的接口对象，然后就可以操作接口定义的方法了。虽然说简单工厂的方法大多是用来创建接口的，但是仔细分析你会发现，真正能实现功能的是具体的实现类，这些实现类是已经做好的，并不是真的要靠简单工厂来创建出来的，简单工程的方法无外乎就是：实现了选择一个合适的实现类来使用。私有化简单工厂的构造方法，使用静态方法来创建接口，也就不能通过写简单工厂类的子类来改变创建接口的方法行为了。
设计模式学习之“工厂模式“
5akura's Blog
08-30 494
工厂模式 作用： 实现创建者与调用者分离 核心本质: 实例化对象不使用new，而是用工厂方法代替 将选择实现类，创建对象统一管理和控制。从而将调用者和实现类解耦。 三种模式： 简单工厂模式 用来生成同一等级结构中的任意产品（对于增加新的产品，需要覆盖已有代码） 工厂方法模式： 用来生产同一等级结构中的固定产品（支持添加任意产品） 抽象工厂模式： 围绕一个超级工厂创建其他工厂，这个超级工厂又可以被视为生产其他工厂的工厂 小结： 静态工厂模式 虽然某种程
1、简单工厂、工厂方法、抽象工厂、单例模式
qqshuai9822的博客
11-22 457
常用设计模式精讲 一、设计模式总览 软件设计原理： 软件设计原理不详细讲解，网上有很多文章可供学习，设计模式可以说是对软件设计原理的应用，所以还是需要了解一下软件设计原理，下面对软件设计原则进行一下总结，供大家参考 1.开闭原则：对扩展开放，对修改关闭 2.单一职责原则：一个类、接口、方法只做一件事 3.依赖倒置原则：通过抽象使个各类，模块相互之间不影响，实现松耦合，尽量面向抽象，接口编程 4.接口隔离原则： 面向抽象基础上，一个接口只做某一类事情，客户端不应该依赖不同的端口 5.迪米特法则：最少知道原
简单工厂模式
SunnyRivers
09-25 694
简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern），简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。简单工厂模式不在GoF 23种设计模式之列。对于产品种类相对较少的情况，考虑使用简单工厂模式可以很方便地创建所需产品。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑。
工厂方法模式
SunnyRivers
09-25 950
工厂方法模式（Factory Method Pattern）又叫作多态性工厂模式，指定义一个创建对象的接口，但由实现这个接口的类来决定实例化哪个类，工厂方法把类的实例化推迟到子类中进行。工厂方法模式主要适用于以下应用场景。（1）创建对象需要大量重复的代码。（2）客户端（应用层）不依赖产品类实例如何被创建、实现等细节。（3）一个类通过其子类来指定创建哪个对象。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 595
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 240
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 558
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
探索工厂方法模式：JAVA实现与UML类图详解
通过这个实验，学生不仅加深了对工厂方法模式的理解，还提高了抽象思考和面向对象编程的能力。最后，评估这部分工作的好坏将基于是否成功地实现了设计模式原则，代码的清晰度，以及类图和代码的可读性和一致性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值