万字解析设计模式之模板方法与解释器模式

news2024/11/23 7:42:50

一、模板方法模式

1.1概述

定义一个操作中算法的框架,而将一些步骤延迟到子类中,模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

例如,去银行办理业务一般要经过以下4个流程:取号、排队、办理具体业务、对银行工作人员进行评分等,其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的,可以在父类中实现,但是办理具体业务却因人而异,它可能是存款、取款或者转账等,可以延迟到子类中实现。 

1.2结构

模板方法(Template Method)模式包含以下主要角色:

  • 抽象类(Abstract Class):负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成,可以是抽象方法和具体方法。

    • 模板方法:定义了算法的骨架,按某种顺序调用其包含的基本方法。

    • 基本方法:是实现算法各个步骤的方法,是模板方法的组成部分。基本方法又可以分为三种:

      • 抽象方法(Abstract Method) :一个抽象方法由抽象类声明、由其具体子类实现。

      • 具体方法(Concrete Method) :一个具体方法由一个抽象类或具体类声明并实现,其子类可以进行覆盖也可以直接继承。

      • 钩子方法(Hook Method) :在抽象类中已经实现,包括用于判断的逻辑方法和需要子类重写的空方法两种。抽象类中的可选步骤,子类可以选择是否实现

        一般钩子方法是用于判断的逻辑方法,这类方法名一般为isXxx,返回值类型为boolean类型。

  • 具体子类(Concrete Class):实现抽象类中所定义的抽象方法和钩子方法,它们是一个顶级逻辑的组成步骤。

1.3实现

【例】炒菜

炒菜的步骤是固定的,分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。类图如下:

 抽象类(Abstract Class)

package com.yanyu.Template;

public abstract class AbstractClass {

    // 模板方法,定义了烹饪的步骤
    public final void cookProcess() {
        //第一步:倒油
        this.pourOil();
        //第二步:热油
        this.heatOil();
        //第三步:倒蔬菜
        this.pourVegetable();
        //第四步:倒调味料
        this.pourSauce();
        //第五步:翻炒
        this.fry();
    }

    public void pourOil() {
        System.out.println("倒油");
    }

    // 抽象方法,由子类实现,倒蔬菜的步骤
    public abstract void pourVegetable();

    // 抽象方法,由子类实现,倒调味料的步骤
    public abstract void pourSauce();

    // 具体方法,热油的步骤是一样的,直接实现
    public void heatOil() {
        System.out.println("热油");
    }

    // 具体方法,翻炒的步骤是一样的,直接实现
    public void fry(){
        System.out.println("炒啊炒啊炒到熟啊");
    }
}

具体子类(Concrete Class)

package com.yanyu.Template;

public class ConcreteClass_BaoCai extends AbstractClass {

    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是包菜");
    }
    @Override
    public void pourSauce() {
        System.out.println("下锅的酱料是辣椒");
    }
}
package com.yanyu.Template;

public class ConcreteClass_CaiXin extends AbstractClass {
    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是菜心");
    }

    @Override
    public void pourSauce() {
        System.out.println("下锅的酱料是蒜蓉");
    }
}

客户端类

package com.yanyu.Template;

public class Client {
    public static void main(String[] args) {
        //炒手撕包菜
        ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
        baoCai.cookProcess();

        //炒蒜蓉菜心
        ConcreteClass_CaiXin caiXin = new ConcreteClass_CaiXin();
        caiXin.cookProcess();
    }
}

注意:为防止恶意操作,一般模板方法都加上 final 关键词。

1.4优缺点

优点:

  • 提高代码复用性

    将相同部分的代码放在抽象的父类中,而将不同的代码放入不同的子类中。

  • 实现了反向控制

    通过一个父类调用其子类的操作,通过对子类的具体实现扩展不同的行为,实现了反向控制 ,并符合“开闭原则”。

缺点:

  • 对每个不同的实现都需要定义一个子类,这会导致类的个数增加,系统更加庞大,设计也更加抽象。
  • 父类中的抽象方法由子类实现,子类执行的结果会影响父类的结果,这导致一种反向的控制结构,它提高了代码阅读的难度。

1.5应用场景

  • 当你只希望客户端扩展某个特定算法步骤,而不是整个算法或其结构时,可使用模板方法模式;

  • 模板方法将整个算法转换为一系列独立的步骤,以便子类能对其进行扩展,同时还可让超类中所定义的结构保持完整;

  • 当多个类的算法除一些细微不同之外几乎完全一样时,你可使用该模式。但其后果就是, 只要算法发生变化,你就可能需要修改所有的类;

  • 在将算法转换为模板方法时,你可将相似的实现步骤提取到超类中以去除重复代码。子类间各不同的代码可继续保留在子类中。

  • 需要通过子类来决定父类算法中某个步骤是否执行,实现子类对父类的反向控制。

1.6源码解析

InputStream类就使用了模板方法模式。在InputStream类中定义了多个 read() 方法,如下:


public abstract class InputStream implements Closeable {
    //抽象方法,要求子类必须重写
    public abstract int read() throws IOException;
​
    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }
​
    public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }
​
        int c = read(); //调用了无参的read方法,该方法是每次读取一个字节数据
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;
​
        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }
}

从上面代码可以看到,无参的 read() 方法是抽象方法,要求子类必须实现。而 read(byte b[]) 方法调用了 read(byte b[], int off, int len) 方法,所以在此处重点看的方法是带三个参数的方法。

在该方法中第18行、27行,可以看到调用了无参的抽象的 read() 方法。

总结如下: 在InputStream父类中已经定义好了读取一个字节数组数据的方法是每次读取一个字节,并将其存储到数组的第一个索引位置,读取len个字节数据。具体如何读取一个字节数据呢?由子类实现。

二、解释器模式

2.1概述

解释器模式是一种行为型设计模式,它定义了一个语言的语法,并用一个解释器来解释该语言中的句子。通常,解释器模式用于将一个复杂的语言拆分成一些简单的语言元素,使它们易于理解和操作。

2.2结构 

  • 抽象表达式(Abstract Expression)角色:定义解释器的接口,约定解释器的解释操作,主要包含解释方法 interpret()。定义了一个抽象的解释操作,所有具体的表达式都需要实现这个接口。

  • 终结符表达式(Terminal Expression)角色:是抽象表达式的子类,用来实现文法中与终结符相关的操作,文法中的每一个终结符都有一个具体终结表达式与之相对应。它实现了抽象表达式的解释方法。

  • 非终结符表达式(Nonterminal Expression)角色:也是抽象表达式的子类,用来实现文法中与非终结符相关的操作,文法中的每条规则都对应于一个非终结符表达式。它们通过递归的方式来解释语言。

  • 环境(Context)角色:通常包含各个解释器需要的数据或是公共的功能,一般用来传递被所有解释器共享的数据,后面的解释器可以从这里获取这些值。环境保存了要解释的语言,它提供了一个接口给表达式来获取和设置环境的状态。

2.3实现

【例】设计实现加减法的软件

抽象表达式

package com.yanyu.Expressioner;

//抽象角色AbstractExpression
public abstract class AbstractExpression {
    //定义了一个解释器方法,接收一个上下文对象,返回解释结果
    public abstract int interpret(Context context);
}

终结符表达式(Terminal Expression)角色

package com.yanyu.Expressioner;

// 终结符表达式角色 变量表达式
// 变量表达式是解释器模式中的一种角色,用于表示语言中的变量。在这里,Variable类表示一个变量,它继承自抽象表达式角色AbstractExpression。
public class Variable extends AbstractExpression {
    private String name;

    // 构造函数,用于初始化变量名
    public Variable(String name) {
        this.name = name;
    }

    // interpret方法用于解释上下文中的表达式,这里是返回变量对应的值
    @Override
    public int interpret(Context ctx) {
        return ctx.getValue(this);
    }

    // 重写toString方法,返回变量名的字符串表示
    @Override
    public String toString() {
        return name;
    }
}
package com.yanyu.Expressioner;

// 终结符表达式角色
// 终结符表达式是解释器模式中的一种角色,用于表示语言中的基本元素。在这里,Value类表示一个具体的值,它继承自抽象表达式角色AbstractExpression。
public class Value extends AbstractExpression {
    private int value;

    // 构造函数,用于初始化值
    public Value(int value) {
        this.value = value;
    }

    // interpret方法用于解释上下文中的表达式,这里是返回值本身
    @Override
    public int interpret(Context context) {
        return value;
    }

    // 重写toString方法,返回值的字符串表示
    @Override
    public String toString() {
        return Integer.valueOf(value).toString();
    }
}

非终结符表达式(Nonterminal Expression)角色

package com.yanyu.Expressioner;

// 非终结符表达式角色  加法表达式
// 加法表达式是解释器模式中的一种非终结符表达式角色,用于表示语言中的加法操作。在这里,Plus类表示加法表达式,它继承自抽象表达式角色AbstractExpression。

public class Plus extends AbstractExpression {
    private AbstractExpression left;  // 左操作数
    private AbstractExpression right;  // 右操作数

    // 构造函数,用于初始化左右操作数
    public Plus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    // interpret方法用于解释上下文中的表达式,这里是返回左右操作数的解释结果相加的值
    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }

    // 重写toString方法,返回加法表达式的字符串表示,形式为 (左操作数 + 右操作数)
    @Override
    public String toString() {
        return "(" + left.toString() + " + " + right.toString() + ")";
    }
}
package com.yanyu.Expressioner;

///非终结符表达式角色 减法表达式
public class Minus extends AbstractExpression {
    private AbstractExpression left;
    private AbstractExpression right;
    public Minus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) - right.interpret(context);
    }
    @Override
    public String toString() {
        return "(" + left.toString() + " - " + right.toString() + ")";
    }
}

环境(Context)角色

package com.yanyu.Expressioner;

import java.util.HashMap;
import java.util.Map;

// 环境类
// 环境类用于存储变量和它们的值,在解释器模式中起到承上启下的作用,为解释器提供解释所需的上下文信息。
public class Context {
    private Map<Variable, Integer> map = new HashMap<Variable, Integer>();

    // 将变量和对应的值存入map中
    public void assign(Variable var, Integer value) {
        map.put(var, value);
    }

    // 获取变量对应的值
    public int getValue(Variable var) {
        Integer value = map.get(var);
        return value;
    }
}

客户端类

package com.yanyu.Expressioner;

// 测试类
// 客户端类Client用于测试解释器模式的功能。在这里,我们创建了一个上下文对象context,以及五个变量a、b、c、d、e,并为这些变量赋值。
// 然后,我们构造了一个复杂的表达式,包括加法和减法操作,并通过interpret方法解释这个表达式,输出其计算结果。

public class Client {
    public static void main(String[] args) {
        Context context = new Context();  // 创建上下文对象

        Variable a = new Variable("a");  // 创建变量a
        Variable b = new Variable("b");  // 创建变量b
        Variable c = new Variable("c");  // 创建变量c
        Variable d = new Variable("d");  // 创建变量d
        Variable e = new Variable("e");  // 创建变量e

        context.assign(a, 1);  // 为变量a赋值
        context.assign(b, 2);  // 为变量b赋值
        context.assign(c, 3);  // 为变量c赋值
        context.assign(d, 4);  // 为变量d赋值
        context.assign(e, 5);  // 为变量e赋值

        // 构造复杂的表达式,包括加法和减法操作
        AbstractExpression expression = new Minus(new Plus(new Plus(new Plus(a, b), c), d), e);

        // 解释并输出表达式的计算结果
        System.out.println(expression + "= " + expression.interpret(context));
    }
}

2.4 优缺点

1,优点:

  • 易于改变和扩展文法。

    由于在解释器模式中使用类来表示语言的文法规则,因此可以通过继承等机制来改变或扩展文法。每一条文法规则都可以表示为一个类,因此可以方便地实现一个简单的语言。

  • 实现文法较为容易。

    在抽象语法树中每一个表达式节点类的实现方式都是相似的,这些类的代码编写都不会特别复杂。

  • 增加新的解释表达式较为方便。

    如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类,原有表达式类代码无须修改,符合 "开闭原则"。

2,缺点:

  • 对于复杂文法难以维护。

    在解释器模式中,每一条规则至少需要定义一个类,因此如果一个语言包含太多文法规则,类的个数将会急剧增加,导致系统难以管理和维护。

  • 执行效率较低。

    由于在解释器模式中使用了大量的循环和递归调用,因此在解释较为复杂的句子时其速度很慢,而且代码的调试过程也比较麻烦

2.5应用场景

  • 当语言的文法较为简单,且执行效率不是关键问题时。
  • 当问题重复出现,且可以用一种简单的语言来进行表达时。
  • 当一个语言需要解释执行,并且语言中的句子可以表示为一个抽象语法树的时候。

三、模板方法模式实验

任务描述

高校网上办事系统中的需要对场地预约、设备维修、教职工请假、车辆登记等申请单进行审核,因此需要与众多子系统进行对接。子系统会将用户填写好的申请单推送到网上办事系统中,处理完后将单号返回给子系统。对接的申请单种类有多个,每种申请单的处理流程是一样的(数据校验-申请单解析-申请单入库-提交审核-自动备份),最大的区别在于不同的申请单,解析方法不同。

本关任务:以场地预约申请单(VenueApplication)和教职工请假申请单(LeaveApplication)为例,模拟实现申请单处理流程。

实现方式

  1. 分析目标算法, 确定能否将其分解为多个步骤。 从所有子类的角度出发, 考虑哪些步骤能够通用, 哪些步骤各不相同;

  2. 创建抽象基类并声明一个模板方法和代表算法步骤的一系列抽象方法。 在模板方法中根据算法结构依次调用相应步骤。 可用 final 最终修饰模板方法以防止子类对其进行重写;

  3. 虽然可将所有步骤全都设为抽象类型, 但默认实现可能会给部分步骤带来好处, 因为子类无需实现那些方法;

  4. 可考虑在算法的关键步骤之间添加钩子;

  5. 为每个算法变体新建一个具体子类, 它必须实现所有的抽象步骤, 也可以重写部分可选步骤。

编程要求

根据提示,补充右侧编辑器文件Client.javaBegin-End 内的代码,完成实验。其它文件的代码不需要修改。

测试说明

平台会对你编写的代码进行测试:

测试输入: 张三 LeaveApplication 预期输出: 张三数据校验 教职工请假申请单数据解析 张三申请单入库 张三提交审核 张三自动存档

测试输入: 报告厅 VenueApplication 预期输出: 报告厅数据校验 场地预约申请单数据解析 报告厅申请单入库 报告厅提交审核 报告厅自动存档

抽象类

public abstract class ApplicationTemplate {
    public boolean execute(String data){
        this.checker(data);
        this.dataAnalysis(data);
        this.proposalSave(data);
        this.submit(data);
        this.autoSave(data);
        return true;
    }

    /**
     * 数据校验
     */
    public void checker(String data){
        System.out.println(data+"数据校验");
    }
    /**
     * 数据解析
     */
    public abstract void dataAnalysis(String data);

    /**
     * 数据入库
     */
    public void proposalSave(String data){
        System.out.println(data+"申请单入库");
    }

    /**
     * 提交审核
     */
    public void submit(String data){
        System.out.println(data+"提交审核");
    }

    /**
     * 自动存档
     */
    public void autoSave(String data){
        System.out.println(data+"自动存档");
    }

}

 具体类

public class LeaveApplication extends ApplicationTemplate{
    @Override
    public void dataAnalysis(String data) {
        System.out.println("教职工请假申请单数据解析");
    }
}
public class VenueApplication extends ApplicationTemplate{
    @Override
    public void dataAnalysis(String data) {
        System.out.println("场地预约申请单数据解析");
    }
}

客户端类

import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        /********** Begin *********/
        Scanner scanner = new Scanner(System.in);
        String applicant = scanner.nextLine();
        String applicationType = scanner.nextLine();

        if (applicationType.equals("LeaveApplication")) {
            LeaveApplication leaveApplication = new LeaveApplication();
            leaveApplication.execute(applicant);
        } else if (applicationType.equals("VenueApplication")) {
            VenueApplication venueApplication = new VenueApplication();
            venueApplication.execute(applicant);
        } else {
            System.out.println("Invalid application type");
        }

        


        /********** End *********/
    }
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1249664.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

分布式数据恢复-hbase+hive分布式存储误删除如何恢复数据?

hbasehive分布式存储数据恢复环境&#xff1a; 16台某品牌R730XD服务器节点&#xff0c;每台物理服务器节点上有数台虚拟机&#xff0c;虚拟机上配置的分布式&#xff0c;上层部署hbase数据库hive数据仓库。 hbasehive分布式存储故障&初检&#xff1a; 数据库文件被误删除…

RPCS3(PlayStation 3游戏模拟器)汉化教程

RPCS3 RPCS3 是一款PlayStation 3 模拟器&#xff0c;可让 Windows、Linux 或 BSD 系统的用户运行索尼 PlayStation 3 游戏。 安装教程 包含 Windows/Linux版本 详细安装汉化教程请查看文章 RPCS3&#xff08;PS3模拟器&#xff09;安装及汉化教程 1.首先下载最新版 RPCS3模…

智能汽车的山海之盾

最近一段时间&#xff0c;关于汽车数字化、智能化进程中的安全问题引发了一系列行业讨论。这个话题也得到了行业更广泛的认识与关注。 汽车智能化是大势所趋&#xff0c;而智能化带来了复杂的系统架构与多样化的功能模块&#xff0c;势必会加大安全隐患&#xff0c;但汽车本身又…

npm WARN npm npm does not support Node.js v13.9.0

Microsoft Windows [版本 10.0.19045.2965] (c) Microsoft Corporation。保留所有权利。C:\Users\Administrator>node -v v13.9.0C:\Users\Administrator>npm -v npm WARN npm npm does not support Node.js v13.9.0 npm WARN npm You should probably upgrade to a newe…

LeetCode Hot100 101.对称二叉树

题目&#xff1a; 给你一个二叉树的根节点 root &#xff0c; 检查它是否轴对称。 代码&#xff1a; class Solution {public boolean isSymmetric(TreeNode root) {if(rootnull || (root.leftnull && root.rightnull)) {return true;}//用队列保存节点LinkedList<…

ArcGis如何用点连线?

这里指的是根据已有坐标点手动连线&#xff0c;类似于mapgis中的“用点连线”&#xff0c;线的每个拐点是可以自动捕捉到坐标点的&#xff0c;比直接画精确。 我也相信这么强大的软件一定可以实现类似于比我的软件上坐标时自动生成的线&#xff0c;但是目前我还没接触到那里&a…

Spring Boot + hutool 创建海报图片

Spring Boot hutool 创建海报图片 /*** 分享,生成图片* param id* return*/GetMapping("/getShareImg")public void getShareImg(String id,HttpServletResponse response) throws IOException {CouponConsignSaleClassify byId couponConsignSaleClassifyService…

DevEco Studio安装

HUAWEI DevEco Studio For OpenHarmony&#xff08;以下简称DevEco Studio&#xff09;是基于IntelliJ IDEA Community开源版本打造&#xff0c;面向OpenHarmony全场景多设备的一站式集成开发环境&#xff08;IDE&#xff09;&#xff0c;为开发者提供工程模板创建、开发、编译…

医保线上购药系统:引领医疗新潮流

在科技的驱动下&#xff0c;医疗健康服务正经历一场数字化的革新。医保线上购药系统&#xff0c;不仅是一种医疗服务的新选择&#xff0c;更是技术代码为我们的健康管理带来的全新可能。本文将通过一些简单的技术代码示例&#xff0c;深入解析医保线上购药系统的工作原理和优势…

Vue框架学习笔记-Object.defineproperty函数

文章目录 前文提要Object.defineProperty作用Object.defineProperty参数使用例图getter&#xff0c;也就是get函数setter&#xff0c;也就是set函数 前文提要 本人仅做个人学习记录&#xff0c;如有错误&#xff0c;请多包涵 Object.defineProperty作用 当在js中声明了一个变…

python cv2.imread()和Image.open()的区别和联系

文章目录 1. cv2.imread()1.1 cv2.imread参数说明1.2 注意事项 2. Image.open()3. cv2.imread()与Image.open()相互转化3.1 cv2.imread()转成Image.open()&#xff1a;Image.fromarray()3.2 Image.open()转成cv2.imread()&#xff1a;np.array() 1. cv2.imread() cv2.imread()…

相机设置参数:黑电平(Black Level)详解和示例

本文通过原理和示例对相机设置参数“黑电平”进行讲解&#xff0c;以帮助大家理解和使用。 原理 相机中黑电平原理是将电平增大&#xff0c;可以显示更多暗区细节&#xff0c;可能会损失一些亮区&#xff0c;但图像更多的关注暗区&#xff0c;获取完图像信息再减掉。只是为了…

【机器学习】平滑滤波

平滑滤波技术 平滑滤波&#xff0c;顾名思义就是对信号进行处理使之整体显得更加平滑&#xff0c;降低噪声影响&#xff0c;提高信号质量&#xff0c;它常见于数字信号处理和图像处理&#xff0c;一般意义上的数字信号多体现于一维数据&#xff0c;图像信号多体现于二维数据。…

JVM 内存分析工具 MAT及实践

线程分析工具 MAT 官网下载地址&#xff1a;http://www.eclipse.org/mat/downloads.php mat百度网盘链接&#xff1a;&#xff08;速度更快&#xff09; 链接&#xff1a;https://pan.baidu.com/s/1tMp8MQIXuPtg9zBgruO0Ug?pwdjqtv 提取码&#xff1a;jqtv jdk17 百度网盘链接…

日本服务器访问速度和带宽有没有直接关系?

​  对于许多网站和应用程序来说&#xff0c;服务器的访问速度是至关重要的。用户希望能够快速加载页面、上传和下载文件&#xff0c;而这些都与服务器的带宽有关。那么&#xff0c;日本服务器的访问速度和带宽之间是否存在直接关系呢? 我们需要了解什么是带宽。带宽是指网络…

uniapp H5、小程序、APP端自定义不同运行环境(开发、测试、生产)、自定义条件编译平台、以及动态修改manifest.json值讲解

文章目录 前言一、自定义条件编译平台是什么&#xff1f;二、新增自定义条件编译平台三、动态设置服务器请求地址四、动态修改manifest.json1.根目录新增文件 modifyManifest.js2.vue.config.js引入modifyManifest.js 总结示例代码 前言 企业项目开发流程上一般都要配置多个运…

Windows Server 2012R2 修复CVE-2016-2183(SSL/TLS)漏洞的办法

一、漏洞说明 Windows server 2012R2远程桌面服务SSL加密默认是开启的,且有默认的CA证书。由于SSL/ TLS自身存在漏洞缺陷,当开启远程桌面服务,使用漏洞扫描工具扫描,发现存在SSL/TSL漏洞。远程主机支持的SSL加密算法提供了中等强度的加密算法,目前,使用密钥长度大于等于5…

SQLite 和 SQLiteDatabase 的使用

实验七&#xff1a;SQLite 和 SQLiteDatabase 的使用 7.1 实验目的 本次实验的目的是让大家熟悉 Android 中对数据库进行操作的相关的接口、类等。SQLiteDatabase 这个是在 android 中数据库操作使用最频繁的一个类。通过它可以实现数据库的创建或打开、创建表、插入数据、删…

Joint Cross-Modal and Unimodal Features for RGB-D Salient Object Detection

提出的模型 the outputs H i m _i^m im​ from the unimodal RGB or depth branch in MFFM FFM means ‘Feature Fusion Module’ 作者未提供代码

【Vue】图片切换

上一篇&#xff1a; vue的指令 https://blog.csdn.net/m0_67930426/article/details/134599378?spm1001.2014.3001.5502 本篇所需要的指令有&#xff1a; v-on v-bind v-show <!DOCTYPE html> <html lang"en"> <head><meta charset"…