2. 设计模式之工厂模式

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量80 收藏 1
点赞数 1
分类专栏： 23种设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478625/article/details/120105322
版权

工厂模式

1.1 简单工厂模式

1.1.1 需求

一个披萨的项目: 要便于披萨种类的扩展，要便于维护

  1. 披萨的种类很多(比如 GreekPizza、CheesePizza等)
  2. 披萨的制作有 prepare, bake, cut, box
  3. 完成披萨店订购功能

1.1.2 使用传统的方式来完成

  1. 思路分析(类图)
    在这里插入图片描述

代码

Pizza.java

public abstract class Pizza {
    protected String name;

    public abstract void prepare();

    public void bake(){
        System.out.println(name + " baking;");
    }

    public void cut(){
        System.out.println(name + " cutting;");
    }

    public void box(){
        System.out.println(name + " boxing;");

    }

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

GreekPizza.java

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println(" 给希腊披萨 准备原材料");
    }
}

CheesePizza.java

public class CheesePizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println(" 给奶酪Pizza 准备原材料");
    }
}

OrderPizza.java

public class OrderPizza {

    /**
     * 购买Pizza
     */
    public OrderPizza() {
        Pizza pizza = null;
        String type = null;
        do {
            type = getType();
            if ("greek".equals(type)) {
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            } else if ("cheese".equals(type)) {
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else {
                break;
            }

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

    }

    /**
     * 让用户输入需要购买Pizza的类型
     * @return
     */
    private String getType() {
        try {
            BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input Pizza 种类: ");
            String type = bf.readLine();
            return type;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

PizzaStore.java

public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}

在这里插入图片描述

1.1.3 传统方式的优缺点

  1. 优点是比较好理解，简单易操作
  2. 缺点是违反了设计模式的ocp原则，接对扩展开放，对修改关闭。即当我们给来类型增加新功能的时候，尽量不要修改代码，或者尽可能少修改代码。
  3. 比如我们这时要增加一个Pizza的种类(Pepper披萨),我们需要做如下修改。
    如果我们增加一个Pizza类，只要是订购Pizza的代码都要修改。
    在这里插入图片描述
  4. 简单地思路分析
    分析: 修改代码可以接受，但是如果我们在其他的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处。
    思路: 把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有创建到PIzza对象的代码就不需要修改了 - > 简单工厂模式

1.1.4 基本介绍

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

1.1.5 使用简单工厂模式

  1. 简单工厂模式的设计方案: 定义一个可以实例化 Pizza 对象的类，封装创建对象的代码。
    在这里插入图片描述
  2. 代码
    SimpleFactory.java
public class SimpleFactory {


    /**
     * 根据orderType 返回对应的Pizza对象
     * @param orderType
     * @return
     */
    public Pizza createPizza(String orderType){
        System.out.println("使用简单工厂模式");
        Pizza pizza = null;
        if("greek".equals(orderType)){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        } else if ("cheese".equals(orderType)) {
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        } else if ("pepper".equals(orderType)) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }

        return pizza;
    }

    /**
     * 根据orderType 返回对应的Pizza对象
     * @param orderType
     * @return
     */
    public static Pizza createPizza2(String orderType){
        System.out.println("使用简单工厂模式");
        Pizza pizza = null;
        if("greek".equals(orderType)){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        } else if ("cheese".equals(orderType)) {
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        } else if ("pepper".equals(orderType)) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }

        return pizza;
    }
}

OrderPizza.java

package com.hmx.factory.simplefactory.order;

import com.hmx.factory.simplefactory.pizzastore.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @program: DesignPattern
 * @description:
 * @author: hmx
 * @create: 2021-06-17 11:29
 **/
public class OrderPizza {

    /**
     * @Field SimpleFactory simpleFactory 定义一个简单工厂对象
     */
    SimpleFactory simpleFactory;



    /**
     * @Field Pizza pizza 披萨对象
     */
    Pizza pizza = null;

    public OrderPizza(SimpleFactory simpleFactory){
        setFactory(simpleFactory);
    }

    public void setFactory(SimpleFactory simpleFactory){
        String orderType = "";
        this.simpleFactory = simpleFactory;
        //用户输入的
        // 设置简单工厂对象
        do {
            orderType = getType();
            pizza = simpleFactory.createPizza(orderType);
            //输出pizza
            if(pizza != null){
                //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购pizza失败");
                break;
            }
        }while(true);
    }

    /**
     * 写一个方法，可以获取客户希望订购的披萨种类
     * @return
     */
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

OrderPizza2.java

public class OrderPizza2 {

    /**
     * @Field Pizza pizza 披萨对象
     */
    Pizza pizza = null;

    public OrderPizza2() {
        setFactory();
    }

    public void setFactory() {
        String orderType = "";
        do{
            orderType = getType();
            pizza = SimpleFactory.createPizza2(orderType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("Pizza订购失败");
                break;
            }
        } while(true);

    }

    public String getType() {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("input Pizza 种类");
        try {
            String orderType = bf.readLine();
            return orderType;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

PizzaStore.java

public class PizzaStore {
    public static void main(String[] args) {
        //new OrderPizza();

        //使用简单工厂模式
        //new OrderPizza(new SimpleFactory());
        //System.out.println("~~退出程序~~");
        new OrderPizza2();
    }
}

1.2 工厂方法模式

1.2.1 一个新的需求

披萨项目新的需求: 客户在点披萨时，可以点不同口味的披萨，比如，北京的奶酪pizza，北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza

1.2.2 思路1

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory,LDPizzaSimpleFactory 等等从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性，可扩展性并不是特别好

1.2.3 思路2

使用工厂方法模式

1.2.4 工厂方法模式介绍

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

1.2.5 工厂方法模式应用案例

  1. 思路分析图解
    在这里插入图片描述

  2. 代码
    OrderPizza.java

public abstract class OrderPizza {

    Pizza pizza = null;

    String orderType = null;

    public OrderPizza() {
        do {
            orderType = getType();
            pizza = createPizza(orderType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购Pizza失败");
                break;
            }
        } while(true);
    }

    abstract Pizza createPizza(String orderType);

    String getType() {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("input Pizza 种类");
        try {
            String type = bf.readLine();
            return type;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

LDOrderPizza.java

public class LDOrderPizza extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
        } else if("pepper".equals(orderType)){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

BJOrderPizza.java

public class BJOrderPizza extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        com.hmx.factory.factorymethod.pizzastore.Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
        } else if("pepper".equals(orderType)){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

在这里插入图片描述

1.3 抽象工厂模式

1.3.1 基本介绍

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

1.3.2 抽象工厂模式应用实例

AbsFactory.java

**//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来具体实现
    Pizza createPizza(String orderType);
}**

BJFactory.java

public class BJFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
        } else if("pepper".equals(orderType)){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

LDFactory.java

public class LDFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");

        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
        } else if("pepper".equals(orderType)){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

OrderPizza.java

public class OrderPizza {

    AbsFactory factory;

    public OrderPizza(AbsFactory factory) {

        setFactory(factory);
    }

    private void setFactory(AbsFactory factory){
        Pizza pizza = null;
        String orderType = "";
        this.factory = factory;

        do{
            orderType = getType();
            pizza = factory.createPizza(orderType);
            if(pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

    //写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

PizzaStore.java

public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
    }
}

在这里插入图片描述

1.4 工厂模式在JDK-Calendar 应用的源码分析

  1. JDK 中的 Calendar 类中， 就使用了简单工厂模式
  2. 源码分析 + Debug 源码 + 说明

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

1.5 工厂模式小结

  1. 工厂模式的意义
    将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
  3. 设计模式的依赖抽象原则
  • 创建对象实例时，不要直接 new 类，而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
  • 不要让类继承具体类，而是继承抽象类或是实现interface(接口)
  • 不要覆盖基类中已经实现的方法。
古月日月衣羊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3.设计模式-工厂模式
weixin_43388789的博客
09-06 196
文章目录前言一、简单工厂模式二、一般工厂模式三、抽象工厂模式 前言 这两天看了不少关于工厂模式的文章，但是对于理解该模式深度并没有什么突破，可能个人能力原因吧。所以还是依照网上一些比较常规的方式整理一下。 问题：为什么需要用工厂模式？ 1.为了解耦 把对象的创建和使用过程分开，因为有的对象创建可能并不一定只是一个简单的new 就完了，还涉及到其它处理。但是使用者是不需要关心的，所以采用工厂设计模式能达到这样的一个效果。就像你只关心吃饭，而不需要关心这个饭菜怎么做出来的，那你就不需要自己做饭，直接去外面餐馆吃
设计模式（二）工厂模式
qq_59415584的博客
04-22 292
工厂模式 黑马程序员：https://www.bilibili.com/video/BV1Np4y1z7BU?p=34 简介 在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new对象，就会对该对象耦合严重。 如果我们使用工厂来创建对象，我们就只有和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说工厂模式的最大特点是解耦。 概述 需求：设计一个咖啡店点餐系统 设计一个咖啡类，并且有两个子类，（美式咖啡和拿铁咖啡）；再设计一
@工厂模式详解及在项目中的使用
weixin_49329785的博客
10-09 1017
它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式策略模式定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的的客户。这个策略模式的定义是不是有点抽象呢？通俗易懂的比喻：假设你跟不同性格类型的小姐姐约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去逛街买买买最合适。
抽象工厂模式之项目案例.rar
10-19
用C#抽象工厂编写的完整项目案例，项目虽小，但绝对正确无误，正常运行。内含数据库文件。适合帮助初学者了解抽象工厂项目的编程思想和项目架构
模式二十三式之:（工厂模式）
weixin_46300935的博客
07-13 123
目录 工厂模式 简单工厂模式 看一个具体的需求 使用传统的方式来完成 传统的方式的优缺点 基本介绍 使用简单工厂模式 工厂方法模式 看一个新的需求 思路 1 思路 2 工厂方法模式介绍 工厂方法模式应用案例 抽象工厂模式 基本介绍 抽象工厂模式应用实例 工厂模式在 JDK-Calendar 应用的源码分析 工厂模式小结 工厂模式 简单工厂模式 看一个具体的需求 看一个披萨的项目：要便于披萨种类的扩展，要便于维护 1) 披萨的种类很多(比如 GreekPi...
设计模式-简单工厂模式
一条游向寒江的鱼
11-30 288
工厂模式的定义定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。 优点： 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。 客户端无需知道所创建具体产品的类名，只需知道参数即可。 也可以引入配置文件，在不修改客户端代码的情况下更换
工厂模式 — 在项目中的用法
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
04-26 737
很多工程都是有pc端和mobile端的，并且这里的mobile端并不是指移动端适应的效果，而是专门为mobile端编写的。 所以这样一个页面就会用到两套页面代码(pc端和mobile端) 1. ...
2.设计模式-工厂模式1
08-03
工厂模式是软件设计模式中的核心模式之一，它在软件开发中扮演着重要的角色，特别是在需要创建一系列相关或相互依赖的对象时。工厂模式的主要目的是将对象的创建过程封装起来，使得客户端在使用对象时，无需关心对象...
3.设计模式-抽象工厂模式1
08-03
抽象工厂模式是一种设计模式，属于创建型模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定...在实际开发中，尤其是在需要支持多种类似产品或服务的场景下，抽象工厂模式是非常重要的设计模式之一。
Java设计模式之抽象工厂模式.docx
10-25
抽象工厂模式是设计模式中的一种，属于创建型模式，它为创建一组相关或相互依赖的对象提供了一个统一的接口，使得客户端无需关注这些对象的具体实现细节，仅需与抽象工厂交互即可。这种模式遵循开放封闭原则（OCP）...
设计模式之工厂模式总结
12-21
编辑Java笔记");}}增加Python笔记public ...设计模式是软件开发中的宝贵经验总结，工厂模式作为其中的一员，可以帮助我们编写更加灵活、可维护的代码。理解并熟练运用工厂模式，能够提升软件设计的质量和可扩展性。
设计模式-工厂模式.pdf
04-11
设计模式 -工厂模式.pdf
设计模式：工厂模式
weixin_43967582的博客
01-13 270
工厂模式 看一个具体的需求 看一个披萨的项目：要便于披萨种类的扩展，要便于维护 披萨的种类很多(比如 GreekPizz、CheesePizz 等) 披萨的制作有 prepare，bake, cut, box 完成披萨店订购功能。 1.使用传统的方式来完成 Pizza抽象类 //将Pizza 类做成抽象 public abstract class Pizza { protected String name; //名字 //准备原材料, 不同的披萨不一样，因此，我们做成抽象方法 public a
项目实践中用到的工厂模式
qq_42794038的博客
06-19 271
项目中发短信可能是多渠道的，比如漫道短信、阿里云短信、华为云短信等，不同的客户可能走的不同的渠道，此处可以应用工厂模式。 1.定义发短信的统一接口
简单工厂模式（实现与总结）
lkkk的博客
05-13 2965
简单工厂模式  简单工厂模式的思想就是用一个单独的类来管理实例化不同子类的过程，这个类就是工厂类。下面我们用一个简单的计算器程序来介绍，计算器只包含加减乘除功能。 下面是UML图 图中可以看到，运算类是四种操作类的父类,而简单工厂类则依赖于运算类 下面是实现代码 操作类 Operation public class Operation { private double num1; priva...
设计模式项目实战（工厂模式和抽象工厂模式）
weixin_34341229的博客
04-27 157
#工厂模式（经常使用） 工厂模式是常见的设计模式之一，这种模式的设计模式属于创建型模式，它提供了一种创建对象的方式。 何时使用：我们明确地计划不同条件下创建不同实例时（笔者认为3种类型为一个临界点） 优点： 一个调用者想创建一个对象，知道名称就可以了 扩展性高，如果想增加一个产品，增加一个工厂类就可以了 屏蔽了产品实现的细节 缺点： 每增加一个产品，都要增加一个产品类，使得工程中类的个数成倍增...
简单工厂、工厂方法、抽象工厂、策略模式、策略与工厂的区别
lianghe861223的专栏
11-27 2104
结合简单示例和UML图，讲解工厂模式简单原理。   一、引子 话说十年前，有一个爆发户，他家有三辆汽车（Benz（奔驰）、Bmw（宝马）、Audi（奥迪）），还雇了司机为他开车。不过，爆发户坐车时总是这样：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上 Audi后他说“开奥迪车！”。 你一定说：这人有病！直接说开车不就行了？！而当把这个爆发户的行为放到我们程序语...
SpringBoot 实际项目开发中工厂模式的巧妙使用
热门推荐
weixin_40841731的博客
11-08 1万+
简单工厂模式：          简单工厂模式是创建型模式，创建型模式顾名思义，也就是说在创建对象的时候，遇到了瓶颈才会选择的设计模式。那么该什么情况使用呢。    简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建并且返回哪一个产品类（这些产品类继承自一个父类或接口）的实例。  那么也就是说：    1、有已知的产品类    2、你无法准确的知道编译哪个产品类  ...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1463
Java开发环境配置
JAVA设计模式之3种工厂模式.doc
09-19
"JAVA设计模式之3种工厂模式" 本文将详细介绍Java设计模式中的三种工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式，这些模式都是面向对象设计中常用的创建型设计模式，主要用于解决类实例化的复杂性。 一、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值