OO期末&第四单元总结

OO第四单元博客

提纲

  • 总结本单元作业的架构设计
  • 总结自己在四个单元中架构设计思维及OO方法理解的演进
  • 总结自己在四个单元中测试理解与实践的演进
  • 总结自己的课程收获
  • 立足于自己的体会给课程提三个具体的改进建议

架构设计

类的设计

主要为一个操作接口类,及数个有关类图、状态图、顺序图的类,后者根据UmlElement的层次结构进行适当拆分。

  • Main

  • MyImplemetation 操作接口

    • FindClassResult 对操作接口中需要寻找类的返回内容进行封装
  • MyClass 类图

    • MyOperation 类图中的操作
  • MyStateMachine 状态图

  • MyInteration 顺序图

    • MyLifeLine

内容的存储

关于类中内容的存储,主要有两个问题:

第一大问题是要实现ID, Name, Element三者之间的寻找,有时还要检测Name的重复性;其中ID和Element两两无重复,Name会有重复。本次作业主要通过两个HashMap实现,第一个HashMap关联的Key为ID,Value为Element;第二个HashMap的Key为Name,Value为ID。Name重复性检测在存储数据时完成,若当时第二个HashMap已有相应name的Key,则name重复。

第二个人问题是存储多种类型UmlElement时容器的设计问题。如果将所有类都单独设计两个HashMap则会过于繁琐,也无法实现需要查找跨不同类UmlElement的操作。对这个问题,我主要关注具体的需求,有需求的则单独构建两个HashMap,同时设立一个存储一切UmlElement的“顶层”HashMap。

四个单元架构设计的思维

第一单元

对表达式的解析、展开和化简,突出层次性。实现数据层次的抽象。

从Pre到第一单元,主要实现了从“别人设计类”到“自己设计类”的转变,对类的理解也从简单的”不同物体“深化到了程序设计时的抽象层次上。

但由于表达式中“递归下降”本身有一些面向过程的色彩,刚开始理解时出现了一些疑惑,写出了面向过程的代码。

第二单元

这个单元的架构设计上主要考虑三个方面:一是对电梯本身和电梯控制的区分,二是对需求的接收-处理时用到的生产者-消费者模式思想,三是对request进行适当封装。

难点在多线程的理解、及线程保护的处理上。认识多线程。我发现我在Sychronized-notify的设计上虽然实现了线程安全,但设计得比较杂碎,不利于别人在读代码时的理解。

第三单元

加入了Exception的处理和接口的实现。在类的设计上,实现已有的要求兼具适当封装。学习JML。

第四单元

理解UML。在实现已有的要求的基础上结合对内容层次结构的考虑。内容层次结构需要自己通过理解UML的存储存储结构去理解。与此同时,也学习了UML的数据存储结构。

阅读大量别人写的代码(官方包),接触package的应用。

测试理解与实践的演进

第一阶段-朴素认知:主要依靠课程网站上的评测机,及自己构造的简单样例,以之前的惯性思维“完成测试”,对测试并无深入理解;

第二阶段-依靠评测机的随机样例生成:发现以上方法不能保证完备性,经常会出现没有检测到的问题

第三阶段-评测机与主动构造样例相结合:理解老师讲的“在写程序之前提前想好测试样例”——主要针对边界条件等;同时使用评测机;接触单元测试。

课程收获

  1. 面向对象、架构设计的理解
  2. Java语法:得益于教材的精心设计,学习非常快,效率很高
  3. 提升编程能力:既是大代码量的训练,也涉及了之前学过的数据结构的知识
  4. git的使用:从0到熟悉
  5. 对测试的理解
  6. 时间安排上:课程的难点不仅在作业本身,更在时间安排上,如果错过了时间,即使有能力完成,也会失去分数

三个改进建议

  • 第一单元的引导:表达式中“递归下降”本身有一些面向过程的色彩,刚开始理解时出现了一些疑惑,看到其他同学的博客也提到了这个问题,不知道课程组是否可以给予一些引导,减少同学学习过程中的弯路
  • 增加应用讲解:学习UML、JML、Junit时并不非常清楚的了解以上技术在现今的工业界具体有哪些应用,有时网上的资料也非常少,建议可以增加这部分的讲解
  • 统计作业完成用时:现在大家对OO用时的理解主要在一个字“长”上,但似乎并无准确认识。建议在收集作业时一并收集作业完成用时,并对同学展示,一方面有利于同学对自己能力的定位,另一方面也可以增强课程组对学生的了解、以及对每次作业情况的了解

OO第一单元博客(补交):初识面向对象

1 程序分析

  • 主要特点:

    • 按照题目形式化表述中的主要思路进行类和因子的构建:分为多项式因子三大类,因子作为父类,被不同细分子类因子继承;
    • 针对自定义函数,采用“字符串替换”的思路处理;
    • 未使用HashCode、HashMap等;
  • 重构历程:

    • 在第二次作业进行重构,主要是进行不同类因子的拆分 和 针对重复使用字符串处理方法的封装(方便复用);
  • 最终架构:(清晰及方便考虑,已省略set、get等方法)

  • 分Class行数分析及每版的主要改动:

  • 横向比较得出的不足:

    • 架构设计的差距
    • 方法实现的美观性
    • 重复造轮子(主要是对已有的轮子不熟)
    • 代码风格,主要是注释的清晰程度

2-3 Bug分析

2.1 公测和互测出现的Bug

第二次作业:公测得分67.9868分,3个点错误(以下三个问题)。

  1. 使用Long解析BigInteger的创建,实际无法处理BigInteger
  2. 优化时将sin(0)直接输出为0,没有考虑sin(0)**0=1
  3. 幂函数替换未外加括号;

第三次作业:公测得分61.1536分,4个点错误(3个点因问题1,1个点因问题2)。

  1. sum函数无法处理BigInteger的情况;
  2. 使用字符串替换函数时的逻辑小问题;
  3. 编写cos代码时直接复制粘贴了sin的代码(toString)函数,导致cos(0)输出0(疏于检查,因此问题扣分多于其他Bug之和)。

本次作业中,互测被发现的Bug是强测的子集(可能与所在B/C房有关)。

2.2 出现Bug代码的特征分析

  1. 使用MatrixReloaded工具进行分析结果(如图)。从统计规律来看,复杂度较高的程序片段更容易出现Bug,减小方法复杂度、优化架构有利于减小Bug的出现可能;

  2. 自己写代码时,思路不够清晰的地方容易出Bug;

  3. 易出Bug的地方有以下特征(也是我互测中Hack他人的主要数据构造策略):

    1. 特殊值:特殊性主要在于程序中对其作出了特殊处理(尤其是优化时作出的处理,像sin(x-x)这种),一旦特殊处理就容易出Bug;
    2. 设计要求的“边界”:核心部分相对不容易有问题,一旦有问题也很容易发现;往往不容易被发现的是使用较少的边界部分。可以进一步地分为两类:
      • 数据边界:如sum函数处理超出long必须使用BigInteger的情况;
      • 操作边界:触发次数的特点是比较少在编写程序时容易对其理解模糊,需要特别关注才能搞清楚。如i**+2等。

3.1 发现Bug策略及启示

  1. Hack他人:没有做评测机,构造数据的策略见2.2第3点。

  2. 启示:测试和Debug是程序设计中比较重要、又比较有难度的一个步骤。经过debug、hack他人的训(折)练(磨),老师在上课时讲解的比较科学的测试策略对我的吸引力显著增加。在总结出现Bug程序片段特征的基础上,争取在写程序时就想好对应的测试数据,多进行主动测试而非被动的改Bug。

4 架构设计体验

完成第一次作业时只是粗浅地只到对象、方法的概念,还不太理解面向的特征,在设计时思考好几种架构,也想到过一个非常简洁美观但完全面向过程的结构。最后还是根据指导书照葫芦画瓢的把程序简单分为多项式、项、因子三类,可以说让自己的程序大体具备了面向对象的特征,但在具体方法的设计、程序的细节上缺乏考虑,很多都不美观。

完成第二次作业时吸取第一次作业的经验和教训,对程序进行了完全的重写/重构。这是最费时费力的一周,虽然我的程序仍然称不上优雅,也使用了老师“并不推荐”的字符串替换方法,但仍然提供了我在第三周作业时不用进行重构的基础。

第三次作业在第二次作业的基础上添加了功能,但因为很快就通过了全部中测点,我没有进行认真地测试,最终出现了一些比较滑稽的低级错误。

总的来讲,这三次作业让我体会到了架构设计的重要性。一方面,分析自己的设计思路,在设计时只是大体的构建到了类的层面,具体方法的实现则是走一步看一步,我想这或许是出现一些错误的原因,也是之后还可以注意改进的点。另一方面,参考优秀的架构、阅读别人的程序确实受益很大,因此也要注意不能闭门造车。

5 心得体会

无论是作业还是理论课,总体感受都是挺充实的。不过希望自己能在时间节点的把控上更明智一些。

OO第三单元博客(补交)

提纲

  • 分析在本单元自测过程中如何利用JML规格来准备测试数据
  • 梳理本单元的架构设计,分析自己的图模型构建和维护策略
  • 按照作业分析代码实现出现的性能问题和修复情况
  • 请针对下页ppt内容对Network进行扩展,并给出相应的JML规格
  • 本单元学习体会

自测时自测数据的准备

  • 写评测机,构造随机性普遍数据

    # 数据生成部分
    import random
    import _thread
    import string
    
    # 0     指令及指令数
    ops = ['ap', 'ar', 'qv', 'qps', 'qci', 'qbs', 'ag', 'atg', 'dfg','qgps',
           'qgvs', 'qgav', 'am', 'sm', 'qsv', 'qrm', 'qlc',
           'arem', 'anm', 'cn', 'aem', 'sei', 'qp', 'dce', 'qm', 'sim']
    #ops = ['ap', 'ar']
    numOfInput = 30000 # 指令条数
    
    # 1     评测模式
    useOpNumLimit = False # 是否使用指令数限制(针对互测)
    
    # 2     指令参数限制
    # 2.1   person
    minId = -250
    maxId = 250 # (maxPersonId)
    maxAge = 200
    maxValue = 1000
    
    # 2.2   Group
    maxGroupId = 20
    
    # 2.3   Message
    maxMessageId = 300
    minSocialValue = -1000  #题目限制 [-1000,+1000]
    maxSocialValue = 1000
    maxMoney = 200 # 题目限制:[0,200]
    maxEmojiId = 100 # 题目限制:[0,10000]
    maxNoticeLen = 98 # 题目限制:[1,100]
    deleteColdEmojiLimit = 3
    
    # 2.4   姓名
    strSize = 10
    chars = string.ascii_letters # + string.punctuation
    myChars = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
                'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    def random_string_generator(strSize, allowed_chars):
        return ''.join(random.choice(allowed_chars) for x in range(strSize))
    
    # 一般性数据
    def create_normal(fileName):
        input = []
    
        for i in range(numOfInput):
            op = random.choice(ops)
            str = op
    
            if op == 'qbs' or op == 'qps':
                pass
            elif op == 'ap': # add person
                id = random.randint(minId, maxId)
                name = random_string_generator(1, myChars)
                age = random.randint(0, maxAge)
                str += (" %d BUAA?BUA%s. %d" % (id, name, age))
            elif op == 'ar': # add relation
                id1 = random.randint(minId, maxId)
                id2 = random.randint(minId, maxId)
                value = random.randint(0, maxValue)
                str += (" %d %d %d" % (id1, id2, value))
            elif op == 'qv' or op == 'qci':
                # queryValue, queryCirlcle
                id1 = random.randint(minId, maxId)
                id2 = random.randint(minId, maxId)
                str += (" %d %d" % (id1, id2))
            elif op == 'atg' or op == 'dfg': # AddToGroup, deleteFromGroup
                id1 = random.randint(minId, maxId)
                id2 = random.randint(0, maxGroupId)
                str += (" %d %d" % (id1, id2))
            elif op == 'ag' or op == 'qgps' or op == 'qgvs' or op == 'qgav':
                # add_goup query_group_people_sum query_group_value_sum query_group_age_var
                id = random.randint(0, maxGroupId)
                str += (" %d" % (id))
            elif op == 'am': # query_group_people_sum
                id = random.randint(0, maxMessageId)
                socialValue = random.randint(minSocialValue, maxSocialValue)
                type = random.randint(0, 1) # randint包含左右极限
                pid1 = random.randint(minId, maxId)
                pid2 = random.randint(minId, maxId)
                gid = random.randint(0, maxGroupId)
                str += (" %d %d %d %d" % (id, socialValue, type, pid1))
                if type == 0:
                    str += (" %d" % (pid2))
                else:
                    str += (" %d" % (gid))
            elif op == 'sm' or op == 'sim': # sendMessage sendIndirectMessage
                id = random.randint(0, maxMessageId)
                str += (" %d" % (id))
            elif op == 'qsv' or op == 'qrm' or op == 'qlc' or op == 'qm' or op == 'cn':
                # query_social_Value query_received_messages query_least_connection queryMoney
                id = random.randint(minId, maxId)
                str += (" %d" % (id))
            elif op == 'arem' or op == 'anm' or op == 'aem': # add red envelop message
                mid = random.randint(0, maxMessageId)
                str += " %d" % mid
                if op == 'arem':
                    str += " %d" % random.randint(0, maxMoney)
                elif op == 'anm':
                    str += " %s" % random_string_generator(random.randint(10, maxNoticeLen), chars)
                elif op == 'aem':
                    str += " %d" % random.randint(0, maxEmojiId)
                else:
                    pass
                type = random.randint(0, 1)
                str += " %d %d" % (type, random.randint(0, maxId))
                if type == 0:
                    str += " %d" % random.randint(minId, maxId)
                else:
                    str += " %d" % random.randint(0, maxGroupId)
            elif op == 'dce' or op == 'qp' or op == 'sei':
                limit = random.randint(0, deleteColdEmojiLimit)
                str += " %d" % limit
            else:
                print("DataCreateError")
            input.append(str)
        if useOpNumLimit == True:
            outputList = delete_op_outof_limit(input)
        else:
            outputList = input
        f = open("%s.txt" % (fileName), "w+", encoding='utf-8')
        for i in range(len(outputList)):
            print(outputList[i], file=f)
        f.close()
    
    # 自动评测(有些繁琐)
    # -*- coding:utf-8 -*-
    import os
    import DataCreate
    import subprocess
    import datetime
    import time
    
    #设置参数:评测次数, 是否碰到错误就停止
    timesOfJudge = 3
    stopWhenErr = False
    
    jarNames = ["lpf.jar", "lsh.jar", "gbl.jar"]
    judgeMachineDir = "D:\\OO\\code\\oo-homework\\unit3\\MachineJudge" # 评测文件夹
    #firstJudgeInput = ["test1", "1", "1new", "20220514-164734input004"]
    #firstJudgeInput = ["20220515-170425input009"]
    firstJudgeInput = []
    
    inputFileName = ""
    jarName = ""
    outputFileName = ""
    removeFileName = ""
    cmd0 = "chcp 65001"
    cmd1 = "cd " + judgeMachineDir # 进入评测文件夹
    cmd2 = "java -jar " + jarName +  " < " + inputFileName + " > " + outputFileName
    cmd3 = "rm " + removeFileName
    cmdSep = " && "
    
    def calcmd(jarName):
        global cmd1, cmd2, cmd3, cmdSep
        cmd1 = "cd " + judgeMachineDir  # 进入评测文件夹
        cmd2 = "java -jar " + jarName + " < " + inputFileName + " > " + outputFileName
        cmd3 = "rm " + removeFileName
    
    def removeFile(fileName):
        global removeFileName
        removeFileName = fileName
        calcmd("")
        #os.system(cmd1 + cmdSep + cmd3)
    
    def working(inputName, jarName):
        global inputFileName, outputFileName
        inputFileName = inputName + ".txt"
        outputFileName = inputName + "-" + jarName + ".txt"
        calcmd(jarName)
        # print(cmd1 + cmdSep + cmd2)
        nowTime = time.time()
        os.system(cmd1 + cmdSep + cmd2)
        useTime = time.time() - nowTime
        # p = subprocess.Popen(cmd1 + cmdSep + cmd2)
        # time.sleep(120 * 1000)
        # p.kill()
        print("%s运行完成, 用时 %3.3f s" % (jarName, useTime))
        return outputFileName
    
    def fileCmp(fileName1, fileName2, inputName):
        global diary
        f1 = open(fileName1, 'r', encoding = 'gbk', errors = 'ignore')
        f2 = open(fileName2, 'r', encoding = 'gbk', errors = 'ignore')
        f0 = open(inputName + ".txt", 'r', encoding = 'gbk', errors = 'ignore')
        errInfo = ""
        isEqual = True
        j = 0 # 行数
        while True:
            str0 = f0.readline()
            str1 = f1.readline()
            str2 = f2.readline()
            j += 1
            if str1 == "" and str2 == "":
                break
            elif str1 == "" or str2 == "":
                errInfo += "评测至第%d行发现行数不同(首行为第1行)" % (j)
                isEqual = False
                break
            elif str1 != str2:
                errInfo += "第%d行不同 (首行为第1行),指令为 %s, 前者输出 %s , 后者输出 %s" % (j, str0, str1, str2)
                isEqual = False
                break
            else:
                continue
        f1.close()
        f2.close()
        f0.close()
        if (errInfo == ""):
            errInfo = "完全相同"
        print("%s与%s: " % (fileName1, fileName2) + errInfo)
        print("%s与%s: " % (fileName1, fileName2) + errInfo, file = diary)
        return isEqual
    
    def judgeAll(inputName, cnt):
        global diary
        result = [[] * 0] * 0
        errorInfo = ""
        findError = False
        for i in range(len(jarNames)):
            print("第%d个程序 %s开始运行" % (i+1, jarNames[i]))
            flag = False
            outputFileName = working(inputName, jarNames[i]) # 运行
            for j in range(len(result)):
                isEqual = fileCmp(outputFileName, result[j][0], inputName)
                if isEqual == True:
                    result[j].append(outputFileName)
                    flag = True
                    break
            if flag == False:
                result.append([outputFileName])
    
        print("第%d次评测完成,共得到%d份结果" % (cnt, len(result)))
        print("第%d次评测共得到%d份结果" % (cnt, len(result)), file = diary)
        if len(result) != 1 :
            str = ""
            for i in range(len(result)):
                str = "第%d份: " % (i + 1)
                for j in range(len(result[i])):
                    str += "%s " % (result[i][j])
                print(str, file=diary)
        if len(result) != 1:
            findError = True
        if (findError == False):
            for i in range(len(result[0])):
                removeFile(result[0][i])
        return findError
    
    now = datetime.datetime.now()
    timeStr = now.strftime("%Y%m%d-%H%M%S")
    cnt = 0 # 评测次数计数
    flag = False
    diary = open(timeStr + "diary.txt", "w+")
    print("评测开始时间%s" % (timeStr))
    if len(jarNames) <= 1:
        print("需要提供多个jar对比评测,评测未成功开始")
    
    firstJudgeInputCnt = 0
    errorCnt = 0
    while cnt < timesOfJudge and len(jarNames) > 1:
        flag = False
        cnt += 1
        if firstJudgeInputCnt < len(firstJudgeInput):
            inputName = firstJudgeInput[firstJudgeInputCnt]
            firstJudgeInputCnt += 1
            print("=================第%03d次评测开始,使用给定数据 %s=================" % (cnt, inputName))
            print("=================第%03d次评测开始,使用给定数据 %s=================" % (cnt, inputName), file = diary)
        else:
            inputName = timeStr + "input%03d" % (cnt)
            DataCreate.create_normal(inputName)
            print("=================第%03d次评测开始,使用随机数据 %s=================" % (cnt, inputName))
            print("=================第%03d次评测开始,使用随机数据 %s=================" % (cnt, inputName), file = diary)
    
        flag = judgeAll(inputName, cnt)
        print("++++++++++++++++++++++第%03d次评测完成+++++++++++++++++++++++++++" % (cnt))
        print("++++++++++++++++++++++第%03d次评测完成+++++++++++++++++++++++++++" % (cnt), file = diary)
        if flag == True and stopWhenErr == True:
            break
        if flag == True:
            errorCnt += 1
    
    print("所有评测完成!错误%d/%d次" % (errorCnt, timesOfJudge))
    print("所有评测完成!错误%d/%d次" % (errorCnt, timesOfJudge), file = diary)
    diary.close()
    
  • 对于重点操作,构造强数据,检验正确性

    举例:针对qlc的数据

    ap 1 1 1
    ap 2 2 2
    .....
    ap 3000 300 3000
    ar [] [] []
    ......
    ar [] [] []
    qlc 1336
    
  • 对于重点操作,考虑卡时间限制的数据,并判断会不会超时

架构设计

  • 类图

  • 构建和维护策略

    • 初始构建
    • 针对qci与qbs,使用并查集优化
    • 针对qlc与sim,使用图中最小生成树(Kruskal)和最短路径的算法(dijkstra)
    • 动态维护,针对关键数据予以缓存,提升运行效率

性能问题和修复情况

  • 第二次作业,面对互测中的超强数据出现了qgvs超时的情况

    解决策略:单独维护socialValueSum变量

扩展

假设出现了几种不同的Person

  • Advertiser:持续向外发送产品广告
  • Producer:产品生产商,通过Advertiser来销售产品
  • Customer:消费者,会关注广告并选择和自己偏好匹配的产品来购买 -- 所谓购买,就是直接通过Advertiser给相应Producer发一个购买消息
  • Person:吃瓜群众,不发广告,不买东西,不卖东西

如此Network可以支持市场营销,并能查询某种商品的销售额和销售路径等 请讨论如何对Network扩展,给出相关接口方法,并选择3个核心业务功能的接口方法撰写JML规格(借鉴所总结的JML规格模式)

几种类型的Person都可通过实现Person接口实现。在此基础上,Advertiser需要新增属性表示发送广告的ID, Producer需要新增属性表示生产产品的Id,Customer新增属性表示自身产品偏好的id。

  • 查询销售额

       /*@ public normal_behavior 
       	 @ requires (\exist int i; 0 <= i && i < sales.size(); sales[i].getId() == objectId)
         @ ensures \result == sales[id];
         @ also
         @ public exceptional_behavior 
         @ signals (ObjectIdNotFoundException e) ((\forall int i; 0 <= i && i < sales.size(); sales[i].getId() != objectId)
        */
    int /*@ pure @*/ getSales(int objectId)throws ObjectIdNotFoundException;
    
  • 发送广告

    	/*@ public normal_behavior
          @ requires (\exists int i; 0 <= i && i < customers.length;
          @          customers[i].getId() == id1) && (\exists int i; 0 <= i && i < getAdvertiser(id1).advertisements.length;
          @           getAdvertiser(id1).advertisements[i].getId() == id2);
          @ assignable getAdvertiser(id1).advertisements
          @ ensures (\forall Advertisement i; \old(getAdvertiser(id1).hasAdvertisement(i));
          @         getAdvertiser(id1).hasAdvertisement);
          @ ensures \old(getPerson(id1).advertisements.length) == getPerson(id1).advertisements.length - 1;
          @ ensures getAdvertiser(id1).hasAdvertisement(getAdvertisement(id2));
          @ also
          @ public exceptional_behavior
          @ signals (AdvertiserIdNotFoundException e) !(\exists int i; 0 <= i && i < advertisers.length;
          @          advertisers[i].getId() == id1);
          @ signals (AdvertisementIdException e) (\exists int i; 0 <= i && i < customers.length;
          @          customers[i].getId() == id1) && !(\exists int i; 0 <= i && i < getAdvertiser(id1).advertisements.length;
          @           getAdvertiser(id1).advertisements[i].getId() == id2);
          @*/
    public void sendAdvertisement(int id1, int id2) throws AdvertiserIdNotFoundException,AdvertisementIdException;
    
  • 添加Producer

    	/*@ public normal_behavior
    	  @ require (\forall int i; 0 <= i && i < producers.size(); !producers[i].equals(advertiser))
          @ assignable persons;
          @ assignable producers;
          @ ensures producers.size() == \old(producers.size()) + 1;
          @ ensures (\exists int i; 0 <= i && i < producers.size(); producers[i].equals(producer));
          @ ensures (\exists int i; 0 <= i && i < persons.size(); persons[i].equals(producer));
          @ ensures (\forall int i; 0 <= i && i < \old(producers.size());
          @             (\exists int j;0 <= j && j < producers.size();producers[j].equal(\old(producer[i]))))
          @ ensures (\forall int i; 0 <= i && i < \old(persons.size());
          @             (\exists int j;0 <= j && j < persons.size();persons[j].equal(\old(persons[i]))))
          @ also
          @ public exceptional_behavior
          @ signals (EqualPersonIdException) (\exists int i; 0 <= i && i < producers.size(); producers[i].equals(producer))
          @*/
    void addProducer(Producer producer);
    

学习体会

  • 学习了JML契约式编程,体会到了其严谨性和低效率的两方面特点。
  • 听工业界人士报告,感受到程序严谨性在某些领域的重要地位。
  • 代码量进一步上升,涉及的细节进一步增多,出错的概率也随之增大。一方面要从完成代码时提高正确性入手,另一方面要从加强测试入手,并总结出可持续实现的方法。
posted @ 2022-06-29 11:32  镜后旅者  阅读(12)  评论(0编辑  收藏  举报