设计模式--工厂模式

最新推荐文章于 2024-06-27 17:55:39 发布
最新推荐文章于 2024-06-27 17:55:39 发布
阅读量66 收藏
点赞数
分类专栏： 设计模式 文章标签： java 后端 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46621774/article/details/120892742
版权

工厂设计模式

介绍

  1. 意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 工厂设计模式有三种：简单工厂模式，工厂方法模式，抽象工厂模式。
  3. 设计模式的依赖抽象原则。

不使用设计模式

/**
* 以下有一个具体的需求。披萨订购，需要便于披萨种类的扩展，便于维护。
* 1. 目前有多种类披萨（CheesePizza，GreekPizza）等
* 2. 披萨的制作过程有prepare，bake，cut，box
* 3. 披萨有门店供客人进行选购。
*/

pizza抽象类

public abstract class Pizza {

    private String name;

    public abstract void prepare();

    public void bake() {
        System.out.println(name + " 正在烘焙");
    }

    public void cut() {
        System.out.println(name + " 正在切割");
    }

    public void box() {
        System.out.println(name + " 正在装箱");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

各种其他种类披萨

public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println(getName() + " 正在准备，还需要greek");
    }

}

public class CheesePizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println(getName() + " 正在准备，需要准备cheese");
    }

}

public class BeefPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println(getName() + " 需要准备牛肉制作");
    }
}

使用传统的方式去订购披萨

public class OrderPizza {

    private Pizza pizza;

    /**
    * 订阅披萨的方法
    */
    public void order() {

        do {

            String pizzaName = getPizzaName();

            if (pizzaName == null || pizzaName == "") {
                break;
            } else if (pizzaName.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            } else if (pizzaName.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName("芝士披萨");
            } else {
                break;
            }

            // 披萨的出厂步骤
            this.pizza.prepare();
            this.pizza.bake();
            this.pizza.cut();
            this.pizza.box();
        } while (true);
    }

    /**
     * 获取输入的pizza名称
     *
     * @return 输入的pizza名称
     */
    private String getPizzaName() {

        BufferedReader reader = null;

        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza name:");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

优缺点：

  1. 优点是比较好理解，简单易操作。
  2. 缺点是违反了设计模式原则的ocp原则，即对扩展开放，对修改关闭，当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。
  3. 这里如果添加一个新的披萨种类（BeefPizza），在添加类的基础上，还需要修改OrderPizza类中的order（）方法，添加逻辑代码，那么违反了ocp原则。

简单工厂模式

分析：根据传统模式的情况，修改代码可以接受，但是如果我们在其他的地方也有创建Pizza的代码，就意味着，也需要修改，而创建pizza的代码，往往有很多。

改进思路：把创建pizza对象封装到一个类（工厂类）中，这样我们有了新的pizza种类的时候，只需要修改该类即可，其他有创建到pizza对象的代码就不要修改了。（简单工厂模式）

简单工厂模式

  1. 简单工厂模式是属于创建性模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单使用的模式。
  2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为或代码。
  3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

简单工厂类:createPizza方法是最简单的简单工厂模式中的静态工厂，更加方便。createPizza1方法是常规的简单工厂模式方法。

uml类图
在这里插入图片描述

public class SimpleFactory {

    /**
     * 创建披萨
     *
     * @return 返回pisa对象
     */
    public static Pizza createPizza(String pizzaName) {

        Pizza pizza = null;

        if (pizzaName.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        } else if (pizzaName.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName("芝士披萨");
        } else if (pizzaName.equals("beef")) {
            pizza = new BeefPizza();
            pizza.setName("牛肉披萨");
        }

        return pizza;
    }

    /**
     * 创建披萨
     *
     * @return 返回pisa对象
     */
    public Pizza createPizza1(String pizzaName) {

        Pizza pizza = null;

        if (pizzaName.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        } else if (pizzaName.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName("芝士披萨");
        } else if (pizzaName.equals("beef")) {
            pizza = new BeefPizza();
            pizza.setName("牛肉披萨");
        }

        return pizza;
    }
}

订阅披萨类OrderPizza中order()方法修改

public void order() {

    do {

        String pizzaName = getPizzaName();

        // 使用简单工厂（静态工厂）模式
        pizza = SimpleFactory.createPizza(pizzaName);

        if (pizza == null) {
            break;
        }

        // 披萨的出厂步骤
        this.pizza.prepare();
        this.pizza.bake();
        this.pizza.cut();
        this.pizza.box();
    } while (true);
}

public class OrderPizza2 {

    private Pizza pizza;

    private SimpleFactory simpleFactory;

    /**
     * 订阅披萨
     *
     * @param simpleFactory 传入的简单工厂实例对象
     */
    public void order(SimpleFactory simpleFactory) {
        setSimpleFactory(simpleFactory);
    }

    /**
     * 设置简单工厂
     *
     * @param simpleFactory 传入的简单工厂对象参数
     */
    public void setSimpleFactory(SimpleFactory simpleFactory) {
        do {
            String pizzaName = getPizzaName();

            // 使用简单工厂（静态工厂）模式
            this.simpleFactory = simpleFactory;
            pizza = this.simpleFactory.createPizza1(pizzaName);

            if (pizza == null) {
                break;
            }

            // 披萨的出厂步骤
            this.pizza.prepare();
            this.pizza.bake();
            this.pizza.cut();
            this.pizza.box();
        } while (true);
    }

    /**
     * 获取输入的pizza名称
     *
     * @return 输入的pizza名称
     */
    private String getPizzaName() {

        BufferedReader reader = null;

        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza name:");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

工厂方法模式

在简单工厂模式的需求上添加一个新的需求，除了有披萨的种类，再添加一个披萨生产的地区。例如广州的牛肉披萨GZBeefPizza，深圳的牛肉披萨SZBeefPizza。

思路：

  • 使用简单工厂模式，创建不同的简单工厂类，也是可以实现，例如添加一个GZPizzaSimpleFactory等的简单工厂进行创建。
  • 不过考虑到项目的规模以及软件的可维护性和可扩展性，这样实现出来的效果不是那么好。
  • 所以这里使用工厂方法进行创建。

工厂方法使用设计

  1. 将披萨项目的实例化功能抽象成抽象的方法，在不同的口味点餐子类中具体实现。
  2. 定义一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

uml类图
在这里插入图片描述

代码实现：

创建需要的披萨子类对象

/**
 * 广州的牛肉披萨
 */
public class GZBeefPizza extends Pizza {

    @Override
    public void prepare() {
        setName("广州的牛肉披萨");
        System.out.println(" 正在广州准备的牛肉披萨制作");
    }

}

/**
 * 广州的芝士披萨
 */
public class GZCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("广州的芝士披萨");
        System.out.println(" 正在广州准备的芝士披萨制作");
    }

}


/**
 * 深圳的牛肉披萨
 */
public class SZBeefPizza extends Pizza {

    @Override
    public void prepare() {
        setName("深圳的牛肉披萨");
        System.out.println(" 正在深圳准备的牛肉披萨制作");
    }

}

/**
 * 深圳的芝士披萨
 */
public class SZCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("深圳的芝士披萨");
        System.out.println(" 正在深圳准备的芝士披萨制作");
    }

}

创建订阅的抽象类，让各个地区的披萨创建者进行继承后实例化具体的披萨。

public abstract class OrderPizza {

    abstract Pizza createPizza(String typeName);

    Pizza pizza = null;

    void order() {

        String typeName;

        do {

            typeName = getTypeName();
            pizza = createPizza(typeName);
            if (pizza == null) break;
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }

    private String getTypeName() {

        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("输入你需要的披萨类型：");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

}

创建各个地区披萨的创建类

public class GZOrderPizza extends OrderPizza {

    @Override
    Pizza createPizza(String typeName) {

        Pizza pizza = null;
        if (typeName == null || typeName.equals("")) {
            return null;
        } else if (typeName.equals("cheese")) {
            pizza = new GZCheesePizza();
        } else if (typeName.equals("beef")) {
            pizza = new GZBeefPizza();
        }
        return pizza;
    }
}


public class SZOrderPizza extends OrderPizza {

    @Override
    Pizza createPizza(String typeName) {

        Pizza pizza = null;
        if (typeName == null || typeName.equals("")) {
            return null;
        } else if (typeName.equals("cheese")) {
            pizza = new SZCheesePizza();
        } else if (typeName.equals("beef")) {
            pizza = new SZBeefPizza();
        }
        return pizza;
    }
}

抽象工厂

  1. 抽象工厂模式：定义了一个interface与创建相关的或有依赖关系的对象簇，而无需指明具体的类。
  2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
  3. 从设计角度来说，抽象工厂就是对简单工厂模式进一步的抽象改进（或者成为进一步的抽象）。
  4. 将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂变成了工厂簇，更利于代码的维护和扩展。

披萨类同工厂方法模式代码举例一致

uml类图
在这里插入图片描述

添加一个抽象工厂接口：

/**
 * 制作披萨的抽象工厂
 */
public interface AbsFactory {

    public Pizza createPizza(String typeName);

}

添加各个地区的工厂并实现抽象工厂

/**
 * 制作广州披萨的工厂子类
 */
public class GZFactory implements AbsFactory {

    private Pizza pizza;

    @Override
    public Pizza createPizza(String typeName) {

        if (typeName.equalsIgnoreCase("cheese")) {
            pizza = new GZCheesePizza();
        } else if (typeName.equalsIgnoreCase("beef")) {
            pizza = new GZBeefPizza();
        } else {
            return null;
        }
        return pizza;
    }
}


/**
 * 制作深圳披萨的工厂子类
 */
public class SZFactory implements AbsFactory {

    private Pizza pizza;

    @Override
    public Pizza createPizza(String typeName) {

        if (typeName.equalsIgnoreCase("cheese")) {
            pizza = new SZCheesePizza();
        } else if (typeName.equalsIgnoreCase("beef")) {
            pizza = new SZBeefPizza();
        } else {
            return null;
        }
        return pizza;
    }
}

订阅披萨类：

public class OrderPizza {

    /**
     * 订阅披萨
     *
     * @param absFactory 传入的工厂类
     */
    public void order(AbsFactory absFactory) {
        setFactory(absFactory);
    }

    /**
     * 设置需要获取的工厂
     *
     * @param absFactory 传入的工厂类
     */
    private void setFactory(AbsFactory absFactory) {

        Pizza pizza = null;

        do {
            String typeName = getPizzaName();
            pizza = absFactory.createPizza(typeName);

            if (pizza == null) break;
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }

    /**
     * 获取键盘输入的披萨种类字符串
     *
     * @return 披萨的种类字符串
     */
    private String getPizzaName() {

        BufferedReader reader = null;

        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入你想要的披萨种类");
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

}

执行方法创建对应披萨并订阅

/**
 * 订单商店
 */
public class OrderStore {

    public static void main(String[] args) {

        OrderPizza orderPizza = new OrderPizza();
        orderPizza.order(new SZFactory());
        orderPizza.order(new GZFactory());
    }
}

注意事项

  1. 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
  2. 不要让类继承具体类，而是继承抽象类或者是实现interface（接口）
  3. 不要覆盖基类中已经实现的方法。
猿哞人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-工厂方法模式
06-04
c++设计模式-创建型模式-工厂方法模式-最简单的源码-qt工程
设计模式-工厂模式.pdf
04-11
设计模式 -工厂模式.pdf
设计模式-简单工厂模式-例题
03-13
设计模式第四章简单工厂模式一个小例题，类图+简单代码
Python设计模式-工厂模式
01-20
工厂模式有三种模式： 简单工厂模式：定义一个创建对象接口，通过参数来决定创建哪个类的实例 工厂方法模式：定义一个创建对象接口，让子类来决定创建哪个类的实例，工厂方法使一个类的实例化延迟到到其子类中 抽象...
c++设计模式-抽象工厂方法
06-04
c++设计模式-创建型-抽象工厂方法-最简单源码-qt工程
Lombok的hashCode方法
LiZhen314的博客
06-27 340
在继承关系中，父类的hashCode针对父类的所有属性进行运算，而子类的hashCode却只是针对子类才有的属性进行运算，立此贴提醒自己。callSuper = false，根据子类自身的字段值 来生成hashcode， 当两个子类对象比较时，只有子类对象的本身的字段值相同，父类字段值可以不同，callSuper = true，根据子类自身的字段值和从父类继承的字段值 来生成hashcode，当两个子。比较时，只有子类对象的本身的字段值和继承父类的字段值都相同，equals方法的返回值是true。
日常工作记录目录
与海
06-21 694
EasyExcel实现二维码下载与展示
Homebrew使用
gghh2015的博客
06-21 503
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Rust高性能日志库tklog0.0.8—支持mod设置参数
donnie4w技术专栏
06-21 939
tklog是rust高性能结构化日志库，支持同步日志，异步日志，支持自定义日志的输出格式，支持按时间，按文件大小分割日志文件，支持日志文件压缩备份，支持官方日志库标准API，支持mod独立参数设置
Android10 SystemUI系列 需求定制（二）隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等
fighting_2017的博客
06-25 55
SystemUI 所包含的界面和模块比较多，这一节主要分享一下状态栏通知图标和通知栏的定制需求：隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等来熟悉一下Systemui。
multiprocessing.Queue 多个进程生产和多个进程消费怎么处理
qh0526wy的博客
06-24 209
在主进程中，我们创建了多个消费者和生产者进程，并将它们启动。生产者进程将数据放入队列，消费者进程从队列中取出数据并处理。生产者进程完成后，我们向队列发送。进行多个生产者和多个消费者的场景时，队列可以很好地协调这些进程。这个模式允许多个生产者并发地向队列中放入数据，同时多个消费者并发地从队列中取出并处理数据，直到所有生产者完成生产，消费者接收到结束信号。函数，分别用于从队列中获取数据和向队列中放入数据。来确保队列可以在多个进程之间共享。方法等待队列中的所有任务完成时很有用。在这个示例中，我们创建了一个队列。
计算机等级考试-Java考试大纲
最新发布
weixin_54454406的博客
06-27 67
二级Java语言程序设计考试大纲。
JVM 相关知识整理
杨杨杨~~的博客
06-20 830
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
SpringCloud微服务框架的原理及应用详解（一）
凛鼕将至的博客
06-21 1060
Spring Cloud是一个基于Spring Boot实现的服务治理工具包，在微服务架构中用于管理和协调服务。它提供了一系列框架和组件，如服务发现、配置管理、熔断器、智能路由等，用于简化分布式系统的开发。Spring Cloud通过提供一系列开箱即用的组件和工具，帮助开发者快速构建和部署微服务架构的系统。
mapstruct实现各个实体间的类型转换（DTO转BO、BO转Entity）的实践
m0_73376570的博客
06-26 872
***/@Data@Data@Mapper//将DTO转换为BO//将List<BO>转换为List<DTO>//将BO转换为DTO。
Javase.认识异常
Joseit的博客
06-21 1535
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
面试-java多线程与并发
TOMORROW6COME的博客
06-23 265
进程是资源分配的最小单位，线程是CPU调度的最小单位。进程让操作系统的并发性成为可能，线程让进程的内部并发成为可能。Thread.start()创建子线程，再在子线程中调用Thread中实现好的run方法去执行相应的业务逻辑。源码中start使用start0()方法调用JVM_StartThread()方法。这里其实就是Thread.start()方法会创建出子线程！进程是抢占处理机的调度单位，线程属于某个进程，共享其资源。Runnable是个接口(只有个抽象的run方法)。start方法会创建新的线程。
Mybatis
qq_62366797的博客
06-24 330
开启二级缓存之后，每个SQLSession进行查询动作时会先去二级缓存中看是否有，如果有就直接命中，如果没有则去看一级缓存中有没有，如果还没有就只能去数据库中查。首先Mybatis是提供了两级缓存的机制去提高数据的检索效率，避免每一次都去数据库中查数据。默认情况下是开启一级缓存(SqlSession级别的缓存，也称为本地缓存)，在一级缓存下，每个SQLSession都会把从数据库查询到的数据保存在自己的一级缓存中，当该SQLSession下次进行相同的查询时就可以直接走缓存而不用去数据库中查。
Java中如何处理ArrayIndexOutOfBoundsException异常？
weixin_44626980的博客
06-24 456
大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在Java编程中，ArrayIndexOutOfBoundsException异常是一个经常出现的问题，特别是在处理数组时。本文将详细探讨ArrayIndexOutOfBoundsException异常的产生原因、如何预防以及如何通过正确的异常处理机制来处理这个异常。
深入浅出设计模式(非常详细通俗易懂).docx
09-28
"深入浅出设计模式的文档详细介绍了设计模式中的工厂模式，包括静态工厂模式、工厂方法模式和抽象工厂模式。文档通过一个生动的故事引入，讲述了如何在程序设计中避免类似故事中暴发户的怪异行为，即通过工厂模式来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值