GOF23设计模式之工厂模式-Factory

最新推荐文章于 2024-05-03 16:12:22 发布
最新推荐文章于 2024-05-03 16:12:22 发布
阅读量70 收藏
点赞数
分类专栏： 设计模式 文章标签： java uml 开发语言 设计模式 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengyong14350/article/details/122029635
版权

三种工厂模式的优缺点

本文将分别实现简单工厂模式–>工厂方法模式–>抽象工厂模式，并比较其优缺点。

简单工厂模式

定义：由一个工厂对象决定创建出哪一种产品实例

  • 不属于GOF23种设计模式中

类型：创建型设计模式

适用场景：

  1. 工厂类负责创建的对象比较少
  2. 客户端（应用层）只知道传入工厂类的参数，对于如何创建对象逻辑并不关心

Coding

public class SimpleFactoryMain {

    /**
     * Car接口
     */
    interface Car {
        /**
         * 行驶
         */
        void run();
    }

    /**
     * 奥迪车
     */
    static class AudiCar implements Car {

        @Override
        public void run() {
            System.out.println("奥迪车行驶速度150km/h");
        }
    }

    /**
     * 保时捷
     */
    static class PorscheCar implements Car {

        @Override
        public void run() {
            System.out.println("保时捷行驶速度200km/h");
        }
    }

    /**
     * 工厂接口
     */
    interface CarFactory {
        Car create(String name);
 
    }

    /**
     * 工厂类实现
     */
    static class DefaultCarFactory implements CarFactory {
        /**
         * 优点:
         * 对外屏蔽具体的实现细节，外界不需要关心里面的实现逻辑，使用者只需要放心的使用
         * 将生产者和消费者进行责任分割
         *
         * 缺点:
         * 无法灵活地应对产品的增加，比如后面需要增加其他的Car，无法避免修改代码的情况下实现功能，
         * 而且会造成整个实现方法越来越复杂，直至无法维护
         * @param name
         * @return
         */
        @Override
        public Car create(String name) {
            if (Objects.equals(name, "Audi")) {
                return new AudiCar();
            } else if (Objects.equals(name, "Porsche")) {
                return new PorscheCar();
            }
            return null;
        }

    }


    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        CarFactory carFactory = new DefaultCarFactory();
        Car car = carFactory.create("Audi");
        car.run();

        car = carFactory.create("Porsche");
        car.run();
    }

UML

在这里插入图片描述

优点:

  • 对外屏蔽具体的实现细节，外界不需要关心里面的实现逻辑，使用者只需要放心的使用
  • 将生产者和消费者进行责任分割

缺点:

  • 无法灵活地应对产品的增加，比如后面需要增加其他的Car，无法避免修改代码的情况下实现功能，
  • 而且会造成整个实现方法越来越复杂，直至无法维护

框架中的简单工厂模式

  • JDk中：
    • Calendar.createCalendar()
      在这里插入图片描述
  • JDBC中
    • DriverManager.getConnection()
  • logback中
    • LoggerContext.getLogger()

拓展知识：基于反射升级简单工厂模式

  • coding

public class SimpleFactoryMain {

    /**
     * Car接口
     */
    interface Car {
        /**
         * 行驶
         */
        void run();
    }

    /**
     * 奥迪车
     */
    static class AudiCar implements Car {

        @Override
        public void run() {
            System.out.println("奥迪车行驶速度150km/h");
        }
    }

    /**
     * 保时捷
     */
    static class PorscheCar implements Car {

        @Override
        public void run() {
            System.out.println("保时捷行驶速度200km/h");
        }
    }

    /**
     * 工厂接口
     */
    interface CarFactory {
        Car create(String name);
        // 基于反射升级简单工厂模式
        Car create(Class clazz);
    }

    /**
     * 工厂类实现
     */
    static class DefaultCarFactory implements CarFactory {
        /**
         * 优点:
         * 对外屏蔽具体的实现细节，外界不需要关心里面的实现逻辑，使用者只需要放心的使用
         * 将生产者和消费者进行责任分割
         *
         * 缺点:
         * 无法灵活地应对产品的增加，比如后面需要增加其他的Car，无法避免修改代码的情况下实现功能，
         * 而且会造成整个实现方法越来越复杂，直至无法维护
         * @param name
         * @return
         */
        @Override
        public Car create(String name) {
            if (Objects.equals(name, "Audi")) {
                return new AudiCar();
            } else if (Objects.equals(name, "Porsche")) {
                return new PorscheCar();
            }
            return null;
        }

        /**
         *  基于反射升级简单工厂模式
         *  优点：在上面基础上升级，当增加其他的Car时，系统无需扩展工厂的代码，只需要实现Car，
         *  因此符合开闭原则。
         **/
        @Override
        public Car create(Class clazz) {
            try {
                return (Car) clazz.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
        }

    }


    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        CarFactory carFactory = new DefaultCarFactory();
        Car car = carFactory.create("Audi");
        car.run();

        car = carFactory.create("Porsche");
        car.run();


        car = carFactory.create(AudiCar.class);
        car.run();

        car = carFactory.create(PorscheCar.class);
        car.run();
    }
  • 优点：在上面基础上升级，当增加其他的Car时，系统无需扩展工厂的代码，只需要实现Car，因此符合开闭原则。

工厂方法模式

描述：

正是因为简单工厂的缺点，使用一个工厂类无法应对多样的产品变化，导致代码的维护越来越困难，脱离了设计模式的初衷。所以针对后期可能出现的多样产品，我们尝试使用一下工厂方法解决问题。

定义：

  • 一个用于创建对象的接口，让子类决定将哪一个类实例化。使一个类的实例化延迟到其子类

适用场景

  • 创建代码需要大量重复的代码
  • 客户端（应用层）不依赖产品实例如何被创建、实现等细节
  • 一个类通过其子类来指定创建哪个对象

coding

public class FactoryMethodMain {

    /**
     * Car接口
     */
    interface Car {
        /**
         * 行驶
         */
        void run();
    }

    /**
     * 奥迪车
     */
    static class AudiCar implements Car {

        @Override
        public void run() {
            System.out.println("奥迪车行驶速度150km/h");
        }
    }

    /**
     * 保时捷
     */
    static class PorscheCar implements Car {

        @Override
        public void run() {
            System.out.println("保时捷行驶速度200km/h");
        }
    }

    /**
     * 工厂接口
     */
    interface CarFactory {
        /**
         * 生产车
         *
         * @return
         */
        Car create();
    }

    /**
     * 奥迪工厂类实现
     */
    static class AudiCarFactory implements CarFactory {
        /**
         * @return
         */
        @Override
        public Car create() {
            return new AudiCar();
        }
    }

    /**
     * 保时捷工厂类实现
     */
    static class PorscheCarFactory implements CarFactory {
        /**
         * @return
         */
        @Override
        public Car create() {
            return new PorscheCar();
        }
    }


    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        //奥迪车工厂
        CarFactory carFactory1 = new AudiCarFactory();
        Car car = carFactory1.create();
        car.run();


        /**
         * 保时捷工厂
         */
        CarFactory carFactory2 = new PorscheCarFactory();
        car = carFactory2.create();
        car.run();
    }
}

UML

在这里插入图片描述
基于工厂方法的设计思想，即使有再多的产品需要加入进来，也是可以通过不断地创建对应的工厂类进行生产，完全不需要担心修改或维护非常复杂的创建逻辑

优点

  • 用户只需关系所需产品对应的工厂，无需关心创建细节
  • 加入新产品符合开闭原则，提高可扩展性

缺点

  • 类的个数容易过多，增加复杂度
  • 增加了系统的抽象性， 理解难度

框架中的工厂方法模式：

  • Jdk 中
//  所有实现Collection接口的实现类都需要实现iterator()方法
//  不同的子类需要创建不同的Iterator子类
public interface Collection<E> extends Iterable<E> {

       Iterator<E> iterator();
}

抽象工厂模式

描述：

工厂方法和抽象工厂最大的区别在于，工厂方法针对于一个产品等级结构，而抽象工厂针对于多个产品等级结构。

概述

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

适用场景

客户端（应用层）不依赖产品实例如何被创建、实现等细节
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复代码
提供一个产品类的库，所有的产品以同样的接口出现，从而客户端不依赖与具体实现

Coding

public class AbstractFactoryMain {

    /**
     * Car接口
     */
    interface Car {
        /**
         * 行驶
         */
        void run();
    }

    /**
     * 奥迪车
     */
    static class AudiCar implements Car {

        @Override
        public void run() {
            System.out.println("奥迪车行驶速度150km/h");
        }
    }

    /**
     * 保时捷
     */
    static class PorscheCar implements Car {

        @Override
        public void run() {
            System.out.println("保时捷行驶速度200km/h");
        }
    }


    /**
     * 发动机
     */
    interface Engine {

        void run();
    }

    /**
     * 奥迪发动机
     */
    static class AudiEngine implements Engine {

        @Override
        public void run() {
            System.out.println("奥迪发动机在运行");
        }
    }

    /**
     * 保时捷发动机
     */
    static class PorscheEngine implements Engine {

        @Override
        public void run() {
            System.out.println("保时捷发动机在运行");
        }
    }


    /**
     * 工厂接口
     */
    interface CarFactory {
        /**
         * 生产车
         *
         * @return
         */
        Car createCar();

        /**
         * 生产发动机
         *
         * @return
         */
        Engine createEngine();
    }

    /**
     * 奥迪工厂类实现
     */
    static class AudiCarFactory implements CarFactory {
        /**
         * @return
         */
        @Override
        public Car createCar() {
            return new AudiCar();
        }

        @Override
        public Engine createEngine() {
            return new AudiEngine();
        }
    }

    /**
     * 保时捷工厂类实现
     */
    static class PorscheCarFactory implements CarFactory {
        /**
         * @return
         */
        @Override
        public Car createCar() {
            return new PorscheCar();
        }

        @Override
        public Engine createEngine() {
            return new PorscheEngine();
        }
    }


    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        //奥迪车工厂
        CarFactory carFactory1 = new AudiCarFactory();
        Car car = carFactory1.createCar();
        car.run();

        Engine engine1 = carFactory1.createEngine();
        engine1.run();


        /**
         * 保时捷工厂
         */
        CarFactory carFactory2 = new PorscheCarFactory();
        car = carFactory2.createCar();
        car.run();

        Engine engine2 = carFactory2.createEngine();
        engine2.run();
    }

优点

具体产品在应用层代码隔离，无需关心创建细节
讲一个系列的产品族放在一起

缺点

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
增加了系统的抽象性和理解难度

GOF23种设计模式面试之三种工厂模式

zhengyong14350
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式精解－GoF 23 种设计模式解析附 C++实现源码.pdf
05-23
设计模式精解－ GoF 23 种设计模式解析附 C++实现源码 目 录 0 引言 ...........................................................................................................................................
GOF23种设计模式之工厂模式
qq_44066201的博客
09-03 271
工厂模式 工厂模式： 实现了创建者和调用者的分离。 详细分类： 简单工厂模式 工厂方法模式 抽象工厂模式 面向对象设计的基本原则： 单一职责原则 ：应该有且只有一个原因引起类的变化 里氏替换原则 ：只要父类能出现的地方，其子类就应该能出现。也就是用子类替换父类后，保证程序照样运行 DIP 依赖倒转原则 DependenceInversionPrinciple：要针对接口编程，不要针对实现编程...
Gof23设计模式之简单工厂/静态工厂模式
m0_55993923的博客
06-19 1317
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。简单工厂模式/静态工厂模式其实不是一种设计模式，而算是一种编程思想。以下讲解使用咖啡厅点咖啡来说明。
GOF 23种常用设计模式
gqg_guan的博客
10-27 819
GOF 23种常用设计模式
GoF23种设计模式
雪崩时没有一片雪花是无辜的！
01-16 654
23种设计模式 设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 OOP...
GOF23种设计模式之抽象工厂模式
qq_44066201的博客
09-07 232
抽象工厂模式 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力； 支持增加产品族） 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务 分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。 示例代码： 高低端发动机： package com.xyj.factory.abstractFactory; /** * 发动机接口 */ public interface...
设计模式精解－GoF 23 种设计模式解析附 C++实现源码.rar
04-20
设计模式精解－GoF 23 种设计模式解析附 C++实现源码 目 录 0 引言 ............................................................................................................................................
GoF 的 23 种设计模式
12-13
GoF 的 23 种设计模式的分类，现在对各个模式的功能进行介绍。 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。 原型（Prototype）模式：将一...
研磨设计模式之工厂方法模式
02-27
先写写设计模式方面的内容吧，就是GoF的23个模式，先从大家最熟悉的工厂方法模式开始，这个最简单，明白的人多，看看是否能写出点跟别人不一样的东西，欢迎大家来热烈讨论，提出建议或意见，并进行批评指正，一概...
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1109
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
yajunjiao的专栏
04-30 481
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1070
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 378
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 891
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 468
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
Nacos 配置中心实例分析实践
最新发布
m0_73557631的博客
05-03 468
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1039
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
Java 解决pdfbox转图片显示中文乱码 No glyph for 165 (CID 5752) in font STSong-Light
qq_38650613的博客
04-28 401
在开发PDF转JPG图片后，图片显示中文乱码，以下为具体示例：截图可以看到￥符号无法转换为乱码代码已经提示我们STSong-Light字体中165符文不存在，而165正好对应着￥字符。（如果你们出现不存在某个字体的报错，接下来也可以跟我一样操作）
java return方法返回数组性
m0_73177400的博客
04-30 191
我们已经学过 返回的声明 和不返回的声明。如果我们需要返回多个数怎么办，那么这个时候就用数组了，我们知道数据类型int string long short .那么返回对象为数组时就相当于能把这些类型都包进去了。
设计模式精解-gof 23 种设计模式解析附 c++实现源码
07-01
其中，创建型设计模式包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。这些模式都提供了一种方式来创建对象，使得程序在实例化对象时更加灵活和可扩展。 结构型设计模式包括适配器模式、装饰器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值