编译原理实验——不同进制间四则运算计算器

已于 2022-03-22 16:52:48 修改
阅读量3.2k 收藏 64
点赞数 11
文章标签： java
于 2020-12-20 23:56:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45827876/article/details/111465094
版权

一、实验目的

1、实现一个词法分析程序，将输入字符串流分解成单词流供语法分析使用。（注意：如果单词输入错误，必须有提示）
2、在词法分析的基础上实现一个语法分析程序，对词法分析的结果进行语法分析。
3、在语法分析的基础上实现一个语义分析程序，求出输入算式的最后结果。

二、文法

算术运算文法如下：
（1） E->E+E
（2） E->E-E
（3） E->EE
（4） E->E/E
（5） E->(E)
（6） E->i
（7） i->十进制整数|十进制小数|八进制整数|十进制小数|十六进制整数|十六进制小数
（8） 十进制小数->(0|(1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)).(0|1|2|3|4
|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)
（9）八进制小数->0(0|1|2|3|4|5|6|7)(0|1|2|3|4|5|6|7).(0|1|2|3|4|5|6|7)(0
|1|2|3|4|5|6|7)
（10） 十六进制小数 ->0x(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)(0|1|2|3|4|5|6|7|8
|9|a|b|c|d|e|f).(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)
（11） 十进制整数->0|(1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)*
（12） 八进制整数-> 0(0|1|2|3|4|5|6|7)(0|1|2|3|4|5|6|7)*
（13） 十六进制整数->0x(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)(0|1|2|3|4|5|6|7|8
|9|a|b|c|d|e|f)**

单词分类
运算符：+ - * / （ ）
常数：十进制小数、十进制整数、十六进制小数、十六进制整数、八进制小数、八进制整数

三、识别不同进制单词的DFA自动机

在这里插入图片描述

四、代码

1、State类

public class State {

    char name;
    double value;
    int decimal;
    String type;

    public State(char name, double value, int decimal, String type) {
        this.name = name;
        this.value = value;
        this.decimal = decimal;
        this.type = type;
    }

    public char getName() {
        return name;
    }

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

    public double getValue() {
        return value;
    }

    public void setValue(double value) {
        this.value = value;
    }

    public int getDecimal() {
        return decimal;
    }

    public void setDecimal(int decimal) {
        this.decimal = decimal;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

}

2、IsOperator类

public final class IsOperator {
    public static final char[] TOKEN=new char[]{'+','-','*','/','(',')'};
    
    /*判断是否是运算符*/
    public static boolean isPulsSign(char token){
        if((token=='+')||(token=='-')||(token=='*')||(token=='/')||(token=='(')||(token==')')){
            return true;
        }else return false;
    }
    
}

3、Attribute类

public class Attribute {
    char ch;
    double val;

    public Attribute(char ch, double val) {
        this.ch = ch;
        this.val = val;
    }

    public Attribute() {
    }

   
    public char getCh() {
        return ch;
    }

    public void setCh(char ch) {
        this.ch = ch;
    }

    public double getVal() {
        return val;
    }

    public void setVal(double val) {
        this.val = val;
    }

    
}

4、NumberDfa类

public final class NumberDfa {

    public static final char[] STATE = new char[]{'X', 'Y', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W'};//自动机的状态
    public static final char[] TOKEN = new char[]{'.', 'x', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F'};//输入的字符
    public static final char S_START = 'X';//开始状态
    public static final char[] S_END = new char[]{'M', 'Y', 'P', 'Q', 'U', 'V', 'W'};//终结状态

    /*根据DFA状态转换图，进行各状态的转换*/
    public static State tranState(State state, char token) {
        if (state.name == 'X') {
            if (token == '0') {
                return new State('Y', state.value * 10 + (token - 48), 0, "十进制整数");
            } else if (token >= '1' && token <= '9') {
                return new State('M', state.value * 10 + (token - 48), 0, "十进制整数");
            } else {
                return null;
            }
        } else if (state.name == 'M') {
            if (token >= '0' && token <= '9') {
                return new State('M', state.value * 10 + (token - 48), 0, "十进制整数");
            } else if (token == '.') {
                return new State('R', state.value, 0, null);
            } else {
                return null;
            }
        } else if (state.name == 'R') {
            if (token >= '0' && token <= '9') {
                return new State('U', state.value + (token - 48) / pow(10, state.decimal + 1), state.decimal + 1, "十进制小数");
            } else {
                return null;
            }
        } else if (state.name == 'U') {
            if (token >= '0' && token <= '9') {
                return new State('U', state.value + (token - 48) / pow(10, state.decimal + 1), state.decimal + 1, "十进制小数");
            } else {
                return null;
            }
        } else if (state.name == 'Y') {
            if (token == '.') {
                return new State('R', state.value, 0, null);
            } else if (token >= '0' && token <= '7') {
                return new State('P', state.value * 8 + (token - 48), 0, "八进制整数");
            } else if (token == 'x' || token == 'X') {
                return new State('N', state.value, 0, null);
            } else {
                return null;
            }
        } else if (state.name == 'P') {
            if (token >= '0' && token <= '7') {
                return new State('P', state.value * 8 + (token - 48), 0, "八进制整数");
            } else if (token == '.') {
                return new State('S', state.value, 0, null);
            } else {
                return null;
            }
        } else if (state.name == 'S') {
            if (token >= '0' && token <= '7') {
                return new State('V', state.value + (token - 48) / pow(8, state.decimal + 1), state.decimal + 1, "八进制小数");
            } else {
                return null;
            }
        } else if (state.name == 'V') {
            if (token >= '0' && token <= '7') {
                return new State('V', state.value + (token - 48) / pow(8, state.decimal + 1), state.decimal + 1, "八进制小数");
            } else {
                return null;
            }
        } else if (state.name == 'N') {
            if ((token >= '0' && token <= '9') || (token >= 'a' && token <= 'f') || (token >= 'A' && token <= 'F')) {
                return new State('Q', (token >= '0' && token <= '9') ? state.value * 16 + (token - 48) : ((token >= 'a' && token <= 'f') ? state.value * 16 + (token - 87) : state.value * 16 + (token - 55)), 0, "十六进制整数");
            } else {
                return null;
            }
        } else if (state.name == 'Q') {
            if ((token >= '0' && token <= '9') || (token >= 'a' && token <= 'f') || (token >= 'A' && token <= 'F')) {
                return new State('Q', (token >= '0' && token <= '9') ? state.value * 16 + (token - 48) : ((token >= 'a' && token <= 'f') ? state.value * 16 + (token - 87) : state.value * 16 + (token - 55)), 0, "十六进制整数");
            } else if (token == '.') {
                return new State('T', state.value, 0, null);
            } else {
                return null;
            }
        } else if (state.name == 'T') {
            if ((token >= '0' && token <= '9') || (token >= 'a' && token <= 'f') || (token >= 'A' && token <= 'F')) {
                return new State('W', (token >= '0' && token <= '9') ? state.value + (token - 48) / pow(16, state.decimal + 1) : ((token >= 'a' && token <= 'f') ? state.value + (token - 87) / pow(16, state.decimal + 1) : state.value + (token - 55) / pow(16, state.decimal + 1)), state.decimal + 1, "十六进制小数");
            } else {
                return null;
            }
        } else if (state.name == 'W') {
            if ((token >= '0' && token <= '9') || (token >= 'a' && token <= 'f') || (token >= 'A' && token <= 'F')) {
                return new State('W', (token >= '0' && token <= '9') ? state.value + (token - 48) / pow(16, state.decimal + 1) : ((token >= 'a' && token <= 'f') ? state.value + (token - 87) / pow(16, state.decimal + 1) : state.value + (token - 55) / pow(16, state.decimal + 1)), state.decimal + 1, "十六进制小数");
            } else {
                return null;
            }
        }
        return null;
    }

    /*用于输出词法分析的结果*/
    public static boolean estimation(char[] token) {
        System.out.println("词法分析的结果为：");
        boolean flag=true;
        if (token != null && token.length != 0) {
            State state = new State(S_START, 0.0, 0, null);
            ArrayList<Character> ss = new ArrayList<>();
            for (int i = 0; i < token.length; i++) {
                if (!IsOperator.isPulsSign(token[i])) {
                    state = tranState(state, token[i]);
                    ss.add(token[i]);
                } else {
                    if (state.type != null) {
                        for (Character s : ss) {
                            System.out.print(s);
                        }
                        ss.clear();
                        System.out.println( " " +state.type);
                    }
                    System.out.println(token[i] + "  运算符");
                    state = new State(S_START, 0.0, 0, null);
                }
                if (state == null) {
                    for (Character s : ss) {
                        System.out.print(s);
                    }
                    ss.clear();
                    System.out.println("  错误数据");
                    flag=false;
                    state = new State(S_START, 0.0, 0, null);
                }
            }
            for (Character s : ss) {
                System.out.print(s);
            }
            ss.clear();
            System.out.println( " "+state.type);
        }
        return flag;
    }
    
    /*用于将输入的算数表达式转换成相应的句子，并存入相应的属性值（即转换完成后的十进制数），为后面的语法分析和语义分析做准备*/
    public static List<Attribute> getAttribute(char token[]){
        ArrayList<Attribute> att=new ArrayList<>();
        if (token != null && token.length != 0) {
            State state = new State(S_START, 0.0, 0, null);
            for (int i = 0; i < token.length; i++) {
                if (!IsOperator.isPulsSign(token[i])) {
                    state = tranState(state, token[i]);
                } else {
                    if (state.type != null) {
                        att.add(new Attribute('i',state.value));
                    }
                    att.add(new Attribute(token[i],0));
                    state = new State(S_START, 0.0, 0, null);
                }
                if (state == null) {
                    state = new State(S_START, 0.0, 0, null);
                }
            }
            att.add(new Attribute('i',state.value));
        }
        return att;
    }
}

5、OperatorPrecedence类，采用算符优先分析法

public class OperatorPrecedence {

    //算符优先关系表
    public static final char[][] priorityTable = {
        {'>', '>', '<', '<', '<', '>', '<', '>'},
        {'>', '>', '<', '<', '<', '>', '<', '>'},
        {'>', '>', '>', '>', '<', '>', '<', '>'},
        {'>', '>', '>', '>', '<', '>', '<', '>'},
        {'<', '<', '<', '<', '<', '=', '<', ' '},
        {'>', '>', '>', '>', ' ', '>', ' ', '>'},
        {'>', '>', '>', '>', ' ', '>', ' ', '>'},
        {'<', '<', '<', '<', '<', ' ', '<', '='}};
    public static final String[] G = {"E->E+E", "E->E-E", "E->E*E", "E->E/E", "E->(E)", "E->i"}; //文法
    public static final char[] endSign = {'+', '-', '*', '/', '(', ')', 'i', '#'};//终结符
    public static final char NotendSign = 'E';//非终结符

    //判断是否是终结符
    private static boolean isEnd(char ch) {
        for (int i = 0; i < endSign.length; i++) {
            if (endSign[i] == ch) {
                return true;
            }
        }
        return false;
    }

    private static int endPosition(char ch) {
        for (int i = 0; i < endSign.length; i++) {
            if (endSign[i] == ch) {
                return i;
            }
        }
        return -1;
    }

    //根据产生式返回右部分的左边部分
    public static char retLeft(String str) {
        for (int i = 0; i < G.length; i++) {
            StringBuffer a = new StringBuffer();
            for (int j = 3; j < G[i].length(); j++) {
                a.append(G[i].charAt(j));
            }
            if (str.equals(a.toString())) {
                return G[i].charAt(0);
            }
        }
        return 0;
    }

    public void Analysis(List<Attribute> att) {
        int status = 0;//0是移进1是规约
        int count = 0;//步骤数
        int k = 0;//栈的深度
        int j = 0;
        int step = 0;
        String gyStr = null;//规约字符串
        System.out.println("语法分析结果为：");
        att.add(new Attribute('#', 0));
        String sentence = "";
        for (Attribute a : att) {
            sentence = sentence + a.ch;
        }
        ArrayList<Attribute> Stack = new ArrayList<>();//栈
        System.out.printf("%-7s%-13s%-7s%-9s%-8s\n", "步骤", "栈", "a读入", "剩余串", "操作");
        Stack.add(new Attribute('#', 0));//栈的初始为#
        Attribute a = att.get(step++);//获取当前输入的字符
        while (Stack.size() != 2 || a.ch != '#') {

            if (status == 0) {
                if (count != 0) {
                    String str = "";
                    for (int i = 0; i < Stack.size(); i++) {
                        str = str + Stack.get(i).ch;
                    }
                    System.out.printf("  %-8s\n %-8d%-15s%-8c%-10s", "移进", count, str, a.ch, sentence.substring(step));
                } else {
                    String str = "";
                    for (int i = 0; i < Stack.size(); i++) {
                        str = str + Stack.get(i).ch;
                    }
                    System.out.printf(" %-8d%-15s%-8c%-10s", count, str, a.ch, sentence.substring(step));
                }
            }
            //System.out.println(k);
            char ch = Stack.get(k).ch;
            if (isEnd(ch)) {
                j = k;
            } else if (j >= 1) {
                j = k - 1;
            }
            //归约
            char temp = 0;
            if (priorityTable[endPosition(Stack.get(j).ch)][endPosition(a.ch)] == '>') {
                ArrayList<Attribute> judge = new ArrayList<>();
                temp = Stack.get(j).ch;
                if (isEnd(Stack.get(j - 1).ch)) {
                    j = j - 1;
                } else {
                    j = j - 2;
                }
                while (priorityTable[endPosition(Stack.get(j).ch)][endPosition(temp)] == '>' || priorityTable[endPosition(Stack.get(j).ch)][endPosition(temp)] == '=') {
                    if (isEnd(Stack.get(j - 1).ch)) {
                        j = j - 1;
                    } else {
                        j = j - 2;
                    }
                }
                for (int i = j + 1; i < Stack.size(); i++) {
                    judge.add(Stack.get(i));
                }

                int t = Stack.size();
                for (int i = j + 1; i < t; i++) {
                    Stack.remove(j + 1);
                }

                String judgeStr = "";
                for (Attribute ju : judge) {
                    judgeStr = judgeStr + ju.ch;
                }
                char res = retLeft(judgeStr);
                if (res != 0) {
                    count++;
                    k = j + 1;
                    //Stack.add(res);
                    if (judge.size() == 1) {
                        Stack.add(new Attribute(res, judge.get(0).val));
                    } else if(judge.get(0).ch=='('&&judge.get(2).ch==')'){
                        Stack.add(new Attribute(res, judge.get(1).val));
                    }else {
                        if (judge.get(1).ch == '+') {
                            Stack.add(new Attribute(res, judge.get(0).val + judge.get(2).val));
                        } else if (judge.get(1).ch == '-') {
                            Stack.add(new Attribute(res, judge.get(0).val - judge.get(2).val));
                        } else if (judge.get(1).ch == '*') {
                            Stack.add(new Attribute(res, judge.get(0).val * judge.get(2).val));
                        } else if (judge.get(1).ch == '/') {
                            Stack.add(new Attribute(res, judge.get(0).val / judge.get(2).val));
                        }
                    }
                    status = 1;
                    gyStr = "用" + res + "->" + judgeStr + "规约";
                    String str = "";
                    for (int i = 0; i < Stack.size(); i++) {
                        str = str + Stack.get(i).ch;
                    }
                    System.out.printf("  %-8s\n %-8d%-15s%-8c%-10s", gyStr, count, str, a.ch, sentence.substring(step));
                }
            }
            //移进
            if (priorityTable[endPosition(Stack.get(j).ch)][endPosition(a.ch)] == '<' || priorityTable[endPosition(Stack.get(j).ch)][endPosition(a.ch)] == '=') {
                count++;
                k++;
                status = 0;
                Stack.add(a);
            } else if (priorityTable[endPosition(Stack.get(j).ch)][endPosition(a.ch)] == ' ') {
                System.out.print("读入单词出错！");
                return;
            }

            if (status == 0 && step < sentence.length()) {
                a = att.get(step++);
            }
            if (Stack.size() == 3 && a.ch == '#') {
                break;
            }
        }
        System.out.printf("%-8s\n", "接受");
        System.out.println("最终结果："+Stack.get(1).val);
    }
}

参考代码：https://blog.csdn.net/tiandc/article/details/103372651?utm_source=app

6、

public class Test {

    public static void main(String[] args) {
        System.out.print("请输入四则运算的算数运算式：");
        Scanner input = new Scanner(System.in);
        String str = input.next();
        char ss[] = str.toCharArray();
        System.out.println();
        boolean flag = true;
        if (!estimation(ss)) {
            System.out.println("单词出现错误，不能进行语法分析！");
            flag = false;
        }
        if (flag) {
            boolean flagg = true;
            for (Attribute a : getAttribute(ss)) {
                if (flagg) {
                    System.out.println();
                    System.out.print("该算数运算式对应的句子:");
                    flagg = false;
                }
                System.out.print(a.ch);
            }
            System.out.println();
            OperatorPrecedence op = new OperatorPrecedence();
            op.Analysis(getAttribute(ss));
        }
    }
}

五、运行结果
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

忧郁小薯条_
关注
  • 11
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
红队专题-REVERSE汇编/二进制PWN/逆向/反编译
aming小老弟
10-10 1061
ROP（Return-Oriented Programming）链是一种计算机安全领域中的攻击技术，用于绕过内存执行保护措施，实现利用漏洞进行代码注入和控制流劫持。由一系列已存在于程序内存中的代码片段（称为gadget）组成的，这些片段通常是程序的合法指令序列。通过将这些gadget按照特定的顺序串联起来，攻击者可以构造出一条可执行的ROP链，用于实现特定的攻击目的。ROP链的基本原理依赖于已存在的代码片段，而不是插入自定义的恶意代码。这样可以避免执行数据区域中的恶意代码，
【数据结构】【A】十进制整数四则运算计算器.doc
07-11
十进制整数四则运算计算器 本设计报告的主要目的是设计一个十进制整数四则运算计算器，通过输入的四则运算表达式字符串，动态生成算术表达式对应的二叉树，然后通过表达式二叉树自动求值并输出。该计算器应能够处理...
011集——16进制内存地址——计算机内存地址为什么用16进制？
yongshiqq的博客
02-10 1909
计算机内存之所以用十六进制，是因为16是2的4次方，二进制到十六进制之间比较容易转换，电路比较简单，焊起来容易，如果内存用十进制的话，不仅效率不会提升，还会徒增复杂度和成本。既然内存地址也是个整数，那么如果有个小盒子（变量）存放这个内存地址，那我们就可以随时通过这个小盒子里的地址找到相应的内存块，取得里面的数据或是改变里面的数据了。3、一些常用值的定义，比如：我们经常用到的html中color表达，就是用的16进制方式，4个16进制位可以表达好几百万的颜色信息。谈到内存地址，不可避免引出指针的概念。
（小实验）理解编译原理：一个四则运算的解释器
qq_37756660的博客
05-29 554
1 + 2 * 3首先我们来定义词法，四则运算里面只有数字和运算符，所以定义很简单，但是我们还要注意空格和换行符，所以词法定义大概是下面这样的。TokenNumber: 1 2 3 4 5 6 7 8 9 0 的组合Operator: + 、-、 *、 / 之一这里我们对空白和换行符没有任何的处理，所以词法分析阶段会直接丢弃。接下来我们来定义语法，语法定义多数采用 BNF，但是其实大家写起来都是乱写的，比如 JavaScript 标准里面就是一种跟 BNF 类似的自创语法。
编译原理协作笔记
k17041114的博客
06-17 1768
这学期我们开设了编译原理这门课程，我原本想通过自身的力量整理出一份学习笔记，但是奈何时间有限，诸事缠身，未能如愿。但是在最后期末复习的过程中，我协同一些朋友一同整理出一份编译原理学习笔记，是跟随者编译原理-华保健这门课程整理出的，这份笔记是大家协同的成果，在此鸣谢所有为这份笔记贡献的朋友们！如果有的学弟学妹们有缘看到这份笔记，并能从中得到一些帮助我会很高兴的，也欢迎有问题和我联系！ 资料...
shell脚本基础——Shell运行原理+变量、数组定义
爱敲代码的三毛的博客
07-28 1487
程序在执行之前需要一个专门的编译过程，把程序编译成机器语言也就是二进制文件，运行时不需要重新翻译，直接使用编译的二进制文件运行就好了。程序执行效率较高，依赖编译器。比如Java语言，一次编译到处运行的说法，把编译出来的二进制字节码文件可以运行在不同平台的JVM上。当前用户自定义的变量，当前进程中有效，其它进程及当前进程的子进程无效。0000bash0000ps100#可以理解为7291的bash就是7272的子进程0000bash0000bash0000ps重复出现。......
人工智能内部原理（二）
龙哥盟
05-19 1613
一个好的 AI 模型应该处理多样化和大规模的数据来源，并且通过特征工程进行增强。项目团队应该考虑将多种技术结合起来，包括（好的）无监督学习。AI 解决方案应该是简单易用的模块，非专家也能轻松集成的。公司在使用 AI 模型时应该应用适当的质量保证，以确保它们能按预期工作，具有韧性，并且能够有效扩展。AI 模型应该易于部署和安全，并且应该解决隐私问题。人类应该能够理解它们的运作方式。为了达到一定程度的智能，未来的 AI 系统应该理解类比、推理、上下文等当前缺失的许多概念。
【计算机组成原理】详谈计算机发展历程
蒙奇D索大的博客
06-04 1069
【计算机组成原理】第一章——计算机系统概述 详细介绍计算机的发展历程……
收藏：通俗讲解计算机工作原理
朱小厮的博客
10-31 2734
点击上方“朱小厮的博客”，选择“设为星标”后台回复"书"，获取后台回复“k8s”，可领取k8s资料为解决各种问题，人们发明了不计其数的机器。计算机种类繁多，从嵌入火星漫游机器人的计算机到为...
C++学习笔记——核心篇
f5976823000的博客
07-04 605
黑马C++核心编程篇，主要针对C++面向对象编程技术。
Yacc和lex的部分翻译
⊙-→棒棒糖ing .____`
07-21 1805
&lt;&lt;编译原理&gt;&gt; 词法分析Lexical analysis或Scanning：根据代码文本区分单词类型 保留字(while if else ...)，数据类型(整型，字符，浮点..)，操作符(+ - * | &amp; ...) ，若有对应单词类型继续语法分析，否 则 词法异常 语法分析Syntax analysis或Parsin：根据给定的语法，在词法分析器给的...
安卓c++输出62进制四则运算运算计算器程序代码.txt
07-11
安卓c++输出62进制四则运算运算计算器程序代码
编译原理实验——利用算符优先分析方法设计一个计算器
09-23
实验中要求计算器： （1）可以输入+ - * / () (2) 输入时不立即计算，等到下一个算符出现时才确定是否进行计算，例如：输入3+5*4，在输入*后，发现+的优先级低于*，因此+不计算，表达式输入结束后先计算*，后计算+...
【数据结构】【a】十进制整数四则运算计算器正文终稿.doc
07-11
数据结构课程设计报告 - 十进制整数四则运算计算器 本文阐述了数据结构课程设计报告的主要内容，涉及到十进制整数四则运算计算器的设计和实现。该计算器可以对输入的四则运算表达式字符串进行解析，生成对应的...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 277
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1084
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 123
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 587
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
数据结构课程设计：十进制整数四则运算计算器
"该文档是东北大学信息科学与工程学院数据结构课程设计报告，主题是构建一个十进制整数四则运算计算器。学生需要根据输入的四则运算表达式字符串，生成相应的二叉树，并通过后序遍历计算出结果。设计要求包括使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值