BUAA 面向对象 第一单元 总结

已于 2024-06-11 23:43:00 修改
阅读量829 收藏 19
点赞数 11
分类专栏： BUAA OO! 文章标签： java
于 2024-03-20 17:40:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72981432/article/details/136883510
版权

”望涔阳兮极浦，横大江兮扬灵。“

BUAA 面向对象 第一单元 总结

前言

​ 不要再为Unit1结束而悲伤了，马上到达的是Unit2，本次总结将从以下部分展开：

  • 程序结构分析与迭代架构

  • 程序测试方法及BUG分析

  • 优化策略

  • 反思与总结

    好，oo总结，启动！

程序结构分析与迭代架构

HW1

作业要求：

​ 读入一个包含加、减、乘、乘方以及括号（其中括号的深度至多为 1 层）的单变量表达式，输出恒等变形展开所有括号后的表达式。

基本思路：

​ 第一次作业本质上是对读入的表达式解析后运算。

​ 解析方法笔者采用课程组推荐的递归下降法，如下图，其中Factor包含常数、幂函数（底数可以是任意因子）因子，表达式因子：
在这里插入图片描述
​ 即对读入的母表达式Expression，进行语法分析（Parser）后得到若干Term的Arraylist，然后对Term逐个Parser得到Factor的Arraylist。如果最后Factor作为表达式因子出现，则进行递归解析。虽然递归下降看起来比较复杂高深，一开始可能无从下手，但实际上手写一个ParserExpr（对表达式解析，笔者这里采取了do while的循环结构），便可以写出ParserTerm，然后对Factor进行分析，如此大体框架就开发好了。

​ 运算方法在HW1中，仅仅涉及幂函数的加减乘三种运算，于是笔者采用了指数到系数的映射Hashmap<String, String> （此处为HW2的巨大重构埋下伏笔orz）。对解析后的母表达式进行解析后，运算便十分简单了，就是进行 ∑ i n T e r m [ i ] \sum_{i}^{n} Term[i] ∑in​Term[i] 进行Key的比较，Value相加减，以及 ∏ i n F a c t o r [ i ] \prod_{i}^{n} Factor[i] ∏in​Factor[i]​​ 进行Key相加，Value相乘。

UML图：

在这里插入图片描述

类名称类设计思考优缺点分析
Factor作为因子父类这一父类在HW1中冗余（未有实例）
Const常数因子，继承自Factor字符串表示数字，完全可以使用BigInteger
Pow幂函数因子，继承自Factor，此时底数是传入底数的字符串表达式底数的数据类型需要再考虑，后续迭代十分困难
Expr表达式因子，继承自Factor，内有Term的容器/
Term项，内有Factor的容器/
Lexer词法分析器，可取得当前字符以及移动位置/
Parser语法分析器，处理递归下降以及因子识别/
Calculator进行多项式乘法、加法以及减法，获取最终输出，简化表达式考虑将输入、输出、计算分开，不应过度耦合
Main主类/
复杂度分析：

方法复杂度：

Methodev(G)基本复杂度iv(G)模块设计复杂度v(G)圈复杂度
Calculator.getAddExpression(String, String)4.06.07.0
Calculator.getDivided(String)1.05.05.0
Calculator.getoutput(HashMap)6.012.013.0
Calculator.merge(String[], HashMap)1.02.02.0
Calculator.multiple(String, String)1.07.07.0
Calculator.pairMul(String[], String[])1.01.01.0
Calculator.shorten(String)1.013.013.0
Calculator.simplify(String)1.06.06.0
Const.Const(BigInteger)1.01.01.0
Const.getExpression()1.01.01.0
Expr.addTerm(Term, boolean)1.01.01.0
Expr.Expr()1.01.01.0
Expr.getExpression()1.02.02.0
Factor.getExpression()1.01.01.0
Factor.getNegative()1.01.01.0
Factor.setNegative(boolean)1.01.01.0
Lexer.backward()1.01.02.0
Lexer.forward()1.01.02.0
Lexer.getConst()3.06.07.0
Lexer.getLength()1.01.01.0
Lexer.getPeek()2.02.02.0
Lexer.getPosition()1.01.01.0
Lexer.Lexer(String)1.01.01.0
Main.main(String[])1.01.01.0
Parser.Parser(Lexer)1.01.01.0
Parser.parserExpr()1.05.05.0
Parser.parserFactor()6.09.09.0
Parser.parserTerm()1.06.06.0
Pow.getExpression()3.04.05.0
Pow.Pow(String, BigInteger)1.01.01.0
Term.addFactor(Factor, boolean)1.01.01.0
Term.getExpression()1.03.04.0
Term.setNegative(boolean)1.01.01.0
Term.Term()1.01.01.0
Total52.0107.0114.0
Average1.52941176470588223.14705882352941173.3529411764705883

​ 注意到Calculator.getoutput(HashMap)和Calculator.shorten(String)这两个方法的复杂度较高，这两个作为最后的输出和简化长度函数，需要整体遍历因子以及未处理的字符串，导致递归以及循环次数过多，这也是后续HW3、HW2导致TLE问题的关键原因。

代码规模：485行

HW2

作业要求：

​ 在HW1基础上，实现括号嵌套、exp()指数因子以及自定义函数。

基本思路：

​ 在HW2中，需要加入对自定义函数的翻译以及对指数运算的支持。

​ 对于自定义函数的翻译，笔者通过字符串解析，将变量x,y,z映射到因子，将自定义函数的表达式视作表达式因子，然后吸取递归下降的方法， 递归终点为”x“或者常数，此时只需要将x（指数因子）进行换底即可。

​ 但对指数运算的支持，由于在HW1中采用了Hashmap<String, String>这种简单粗暴的表达方式。导致在加入指数运算后，不得不重构。考虑到最终表达式为 [ a ∗ ] [ e e x p r e s s i o n ] [ ∗ x [ b ] [a*][e^{expression}][*x[^b] [a∗][eexpression][∗x[b]​​ 的形式，我最后采用了更加简单粗暴的方法:Hashmap<Factor,TrieMap<BigInteger, BigInteger>>将exp指数作为Hashmap的Key，然后将幂函数表达式作为Value，幂函数表达式同HW1一样处理。

​ 在对数据结构进行重构后，需要对乘法、加减法的运算进行重构和迭代，由于Factor实质上是指针，这导致Factor插入的时，如果不是以常数因子0（作为指数因子不存在的Key），必然作为全新的Key插入Hashmap（这导致了TLE的出现，在后续会讨论解决方法）。加减乘法就是两个Hashmap的合并问题，这个在HW1中以及实现过，即对Key进行加法即可。（在TLE了强测第2个点后，发现是在运算时候没有及时进行删“0”的操作，即TrieMap的Value为0时需要立即删除，在考虑到这个后，就不会TLE了）

UML图：

在这里插入图片描述

类名称类设计思考优缺点分析
Factor作为因子父类此时Factor作为’x’,‘y’,'z’的实例，但仍感觉可以和Pow合并
Const常数因子，继承自Factor/
Pow幂函数因子，继承自Factor，此时底数是传入底数的字符串表达式底数的类型现在只有Expr和Factor，常常因为底数是Expr使递归层数很高
EXtype指数因子，实际上可以视作另一形式的Pow与Pow一样，递归层数在计算时候很高，区别是一个为加法，一个为乘法。
Expr表达式因子，继承自Factor，内有Term的容器/
Term项，内有Factor的容器/
Lexer词法分析器，可取得当前字符以及移动位置/
Parser语法分析器，处理递归下降以及因子识别/
Calculator进行多项式乘法、加法以及减法采用的计算方法复杂度很高，影响运行时间
Input进行输入解析，输入简化Input与Output在缩短符号时候共用一个方法，或许该方法可以同时在这两个类中移除。
Output进行字符串输出，同类项合并，字符串缩短同上
Main主类/
复杂度分析：

方法复杂度：

MethodCog©ev(G)基本复杂度iv(G)模块设计复杂度
Calculator.Add(HashMap>, HashMap>)1.06.07.0
Calculator.del(HashMap>)1.04.04.0
Calculator.FactorAddFactor(Const, Const)1.01.01.0
Calculator.FactorAddFactor(Expr, Expr)1.03.03.0
Calculator.FactorAddFactor(Factor, Factor)5.09.09.0
Calculator.Mul(HashMap>, HashMap>)1.03.03.0
Calculator.TreeAddTree(HashMap, HashMap)1.04.04.0
Calculator.TreeMulTree(HashMap, HashMap)1.04.04.0
Const.add(Const, boolean)1.02.02.0
Const.Const(BigInteger)1.01.01.0
Const.getExpression()1.01.01.0
Const.getNumber()1.01.01.0
Const.getType()1.01.01.0
Expr.addTerm(Term, boolean)1.01.01.0
Expr.Expr()1.01.01.0
Expr.Expr(ArrayList)1.01.01.0
Expr.getExpression()1.02.02.0
Expr.getTerms()1.01.01.0
Expr.getType()1.01.01.0
Expr.mergeTerm()5.08.08.0
Expr.renew(HashMap)1.02.02.0
EXtype.EXtype(Pow)1.01.01.0
EXtype.getExpr()1.03.03.0
EXtype.getExpression()1.01.01.0
EXtype.getType()1.01.01.0
EXtype.isEquivalent(Factor)1.01.01.0
EXtype.renew(HashMap)1.01.01.0
Factor.add(Const, boolean)1.01.01.0
Factor.getEle()1.01.01.0
Factor.getExpression()1.02.02.0
Factor.getNegative()1.01.01.0
Factor.getType()1.01.01.0
Factor.isEquivalent(Factor)1.01.01.0
Factor.renew(HashMap)1.01.01.0
Factor.setEle(String)1.01.01.0
Factor.setNegative(boolean)1.01.01.0
Function.Function(ArrayList, ArrayList)1.02.02.0
Function.getExpr()1.01.01.0
Function.getExpression()1.01.01.0
Function.getType()1.01.01.0
Input.getExpression()1.01.01.0
Input.getFunction()1.02.02.0
Input.Input()1.01.01.0
Input.shorten(String)1.013.013.0
Lexer.backward()1.01.02.0
Lexer.forward()1.01.02.0
Lexer.getConst()3.06.07.0
Lexer.getLength()1.01.01.0
Lexer.getPeek()2.02.02.0
Lexer.getPosition()1.01.01.0
Lexer.Lexer(String)1.01.01.0
Main.main(String[])1.01.01.0
Output.Consolidate(String)1.01.01.0
Output.getExpExpression(String, String, HashMap, BigInteger)1.011.014.0
Output.getMonomial(String, HashMap, BigInteger)2.08.010.0
Output.getOutPut(HashMap>)1.07.08.0
Output.shorten(String)1.013.013.0
Parser.getConstFactor(boolean)1.01.01.0
Parser.getExpressionFactor()2.03.03.0
Parser.getEXtypeFactor()2.01.02.0
Parser.getFunctionFactor()5.06.06.0
Parser.getPowFactor(boolean)1.02.02.0
Parser.Parser(Lexer, HashMap)1.01.01.0
Parser.parserExpr()1.05.05.0
Parser.parserFactor()8.013.013.0
Parser.parserTerm()1.06.06.0
Pow.getBase()1.01.01.0
Pow.getExponent()1.01.01.0
Pow.getExpression()1.05.05.0
Pow.getType()1.01.01.0
Pow.isEquivalent(Factor)1.01.01.0
Pow.Pow(Factor, BigInteger)1.01.01.0
Pow.renew(HashMap)1.04.04.0
Term.addFactor(Factor, boolean)1.01.01.0
Term.getExpression()1.03.04.0
Term.getFactors()1.01.01.0
Term.getNegative()1.01.01.0
Term.isEquivalent(Term)5.02.05.0
Term.merge(Term)1.03.03.0
Term.renew(HashMap)1.02.02.0
Term.setNegative(boolean)1.01.01.0
Term.Term()1.01.01.0

​ 注意到在与获得输出相关的方法的复杂度较高，笔者分析，大概由于因为采用了解析表达式一致的递归下降方法，导致复杂度的急剧上升。这个也在HW3中导致TLE问题，现按下不表，会在HW3中分析解决方案。

代码规模：1008行

重构体验：

​ 这一次HW2由于HW1中采用了不太好的数据类型，主要问题是Pow的底数类型~~~（HW1中采用String，有点抽象）~~~、计算多项式的表达方式、将因子拆开采用正则的方法，导致HW1中近一半的代码均需要重构。但重构下来，对于面向对象的理解，确实有所提高。对于一些方法，感受到可以不必拘泥于小方法的细节，可以先实现大方法，形成框架，然后逐步往里面填“肉”。

HW3

作业要求：

​ 在HW2的基础上，实现求导算子，以及在自定义函数中实现定义时调用已有定义的函数。

基本思路：

​ 对于求导算子，笔者的实现类似于自定义函数的实现，同样采用相似的递归下降方法。但不同的是，对于Term的求导，产生结果可能是一堆的Term（乘法求导导致），但无伤大雅。这个的实现十分简单，五十多行就可以解决。

​ 对于实现自定义函数的迭代，这个在HW2中已经实现了，这里考虑到在一些测试样例下导致递归层数十分高，需要对表达式解析进行优化。在调试中观察到在HW2中，为了避免解析错误，笔者直接将函数中的因子，全部抽象为表达式因子，这是导致递归层数增加的最主要原因。（如下图所示）
在这里插入图片描述
所以，采用parserFactor方法进行函数解析。但这导致了HW2中未发现的Bug暴露，直接原因是原先Pow类中的底数因子不是单个的x就是一个表达式（不论是常数还是指数因子，都会被视作一个表达式因子），但此时Pow类的底数可以是任意的因子。这直接导致程序在函数因子解析的时候无法正确换底，导致bug的出现~~（被hack的时候，发现这个问题还没被完全修复）~~。UML图与HW2一致，不再贴出。

复杂度分析：

方法复杂度分析：

Calculator.Add(HashMap>, HashMap>)9.01.06.07.0
Calculator.del(HashMap>)4.01.04.04.0
Calculator.FactorAddFactor(Const, Const)0.01.01.01.0
Calculator.FactorAddFactor(Expr, Expr)2.01.03.03.0
Calculator.FactorAddFactor(Factor, Factor)9.05.09.09.0
Calculator.Mul(HashMap>, HashMap>)3.01.03.03.0
Calculator.TreeAddTree(TreeMap, TreeMap)5.01.04.04.0
Calculator.TreeMulTree(TreeMap, TreeMap)7.01.04.04.0
Const.add(Const, boolean)2.01.02.02.0
Const.Const(BigInteger)0.01.01.01.0
Const.differentiate()0.01.01.01.0
Const.getExpression()0.01.01.01.0
Const.getNumber()0.01.01.01.0
Const.getType()0.01.01.01.0
Expr.addTerm(Term, boolean)0.01.01.01.0
Expr.differentiate()5.02.04.04.0
Expr.Expr()0.01.01.01.0
Expr.Expr(ArrayList)0.01.01.01.0
Expr.getExpression()1.01.02.02.0
Expr.getTerms()0.01.01.01.0
Expr.getType()0.01.01.01.0
Expr.mergeTerm()17.05.08.08.0
Expr.renew(HashMap)1.01.02.02.0
EXtype.differentiate()2.02.02.02.0
EXtype.EXtype(Pow)0.01.01.01.0
EXtype.getExpr()3.01.03.03.0
EXtype.getExpression()0.01.01.01.0
EXtype.getIn()0.01.01.01.0
EXtype.getType()0.01.01.01.0
EXtype.isEquivalent(Factor)0.01.01.01.0
EXtype.renew(HashMap)0.01.01.01.0
EXtype.setIn(Factor)0.01.01.01.0
Factor.add(Const, boolean)0.01.01.01.0
Factor.differentiate()0.01.01.01.0
Factor.getEle()0.01.01.01.0
Factor.getExpression()2.01.02.02.0
Factor.getNegative()0.01.01.01.0
Factor.getType()0.01.01.01.0
Factor.isEquivalent(Factor)0.01.01.01.0
Factor.renew(HashMap)0.01.01.01.0
Factor.setEle(String)0.01.01.01.0
Factor.setNegative(boolean)0.01.01.01.0
Function.Function(ArrayList, ArrayList, HashMap)1.01.02.02.0
Function.get()0.01.01.01.0
Function.getExpr()0.01.01.01.0
Function.getExpression()0.01.01.01.0
Function.getType()0.01.01.01.0
Input.getExpression()0.01.01.01.0
Input.getFunction()1.01.02.02.0
Input.Input()0.01.01.01.0
Input.shorten(String)18.01.013.013.0
Lexer.backward()1.01.01.02.0
Lexer.forward()1.01.01.02.0
Lexer.getConst()8.03.06.07.0
Lexer.getPeek()2.02.02.02.0
Lexer.Lexer(String)0.01.01.01.0
Main.main(String[])0.01.01.01.0
Output.Consolidate(String)0.01.01.01.0
Output.getExpExpression(String, String, TreeMap, BigInteger)16.01.08.010.0
Output.getMonomial(String, TreeMap, BigInteger)16.02.08.010.0
Output.getOutPut(HashMap>)18.01.07.08.0
Output.getString(String)4.01.05.06.0
Output.shorten(String)18.01.013.013.0
Parser.getConstFactor(boolean)0.01.01.01.0
Parser.getDifferentiation()0.01.01.01.0
Parser.getExpressionFactor()3.02.03.03.0
Parser.getEXtypeFactor()2.02.01.02.0
Parser.getFunctionFactor()10.05.06.06.0
Parser.getPowFactor(boolean)2.01.02.02.0
Parser.Parser(Lexer, HashMap)0.01.01.01.0
Parser.parserExpr()5.01.05.05.0
Parser.parserFactor()14.09.014.014.0
Parser.parserTerm()8.01.06.06.0
Pow.differentiate()7.04.04.05.0
Pow.getBase()0.01.01.01.0
Pow.getEle()0.01.01.01.0
Pow.getExponent()0.01.01.01.0
Pow.getExpression()11.01.05.05.0
Pow.getType()0.01.01.01.0
Pow.isEquivalent(Factor)0.01.01.01.0
Pow.Pow(Factor, BigInteger)0.01.01.01.0
Pow.renew(HashMap)5.01.06.06.0
Term.addFactor(Factor, boolean)0.01.01.01.0
Term.differentiate()10.01.05.05.0
Term.getExpression()4.01.03.04.0
Term.getFactors()0.01.01.01.0
Term.getNegative()0.01.01.01.0
Term.isEquivalent(Term)6.05.02.05.0
Term.merge(Term)5.01.03.03.0
Term.renew(HashMap)1.01.02.02.0
Term.setNegative(boolean)0.01.01.01.0

​ 仍然注意到，由于重复遍历元素，在关于表达式输出Output类中以及表达式优化的方法复杂度极高。这时常在exp嵌套层数高的时候，导致TLE，仍有极大的优化空间。

代码规模：1136行，可以看到改动相比于第一次迭代少了很多很多。

程序测试方法及BUG分析

程序测试方法

​ 在HW1中，感谢czx和Chatgpt的帮助从而生成一台自动评测机，在测试过程中，采用纯random的数据生成方式：

在这里插入图片描述

​ 在HW2和HW3中，感谢DPO OJ V2网站的建设同学，评测平台确实能够帮助发现一些Bug。除了借助该平台之外，笔者也针对自己的程序，通过手动构造递归层数较高的测试样例，从而降低总体运行时间，避免tle。

​ 在互测环节中，主要是结合本人在测试时发现的bug捏数据，比如HW1中捏0，HW2中exp的指数为0的情况进行hack。

BUG分析

自己的BUG

1.在HW2中，由于递归层数过高导致第二个点TLE，并且在互测中由于对表达式输出的理解错误，导致format error

2.在HW3中，对形如 f ( x ) = g ( x 2 ) f(x) = g(x^2) f(x)=g(x2) 的函数定义式，由于在优化运行时间是漏判（这很不oo），导致在互测中被刀了一次。

互测中他人的BUG

1.在HW1中，有同学因为对幂函数底数的解析有误，导致(x+0)^2会输出x^2+1

2.在HW2中，主要是exp的0次会出现一些bug

优化策略

​ 在三次作业中，优化主要分为两个方面：运行时间优化、输出长度优化

运行时间优化：

​ 对于笔者架构，其主要问题是递归层数过高导致TLE问题。显而易见，计算/输出一个表达式因子的递归深度远深于一个等价的其他类型因子，即对函数中因子、幂函数底数、指数进行精准分类，会大大降低运行时间。所以，在HW2到HW3中，针对HW2中无脑采用parserExpr将嵌套的因子一概而论地视作表达式因子，笔者进行了细化分类，从而大大降低运行时间。

输出长度优化：

​ 输出长度可以通过合并同类项、提取（最优的）公因子、符号调整等方面考虑。由于笔者实在愚钝，为了避免因为优化导致WA，所以仅进行了合并同类项，具体实现是根据我的输出表达方式： a ∗ e e x p r e s s i o n ∗ x b a*e^{expression}*x^b a∗eexpression∗xb （如果a不存在，则对这个Term添加一个+1），从而实现Term的比较（逐个因子判断是否等价），但实际来看，由于expression中仍可能继续嵌套Term，此方法在部分情况下会失效，导致性能分极大丢失。

反思与总结

​ 虽然上过oopre，但HW1点开的一瞬间，才感觉到真正的oo并不是pre中的“造玩具”行为。在HW1中，因为没有良好的架构，导致HW2中大量的重构。虽然有些难绷，但确实在重构的时候，才感受面向对象实质上是一种宏观的模型，即一个类要实现能做什么，而不是用冗长的代码实现怎么做，要实现宏观布局，而不能局限于某一小方法。

​ 总体来说，oo第一单元的体验还是很好的，确实能够感受到自己编程思想上的转变。但是，对于代码性能分，我有一些自己的看法：个人认为可以如同五级制度一般进行分档，从而减少同学们（尤指我这样的懒人）在优化结果的内卷行为（比如将exp(2)提出来这种绝活哥掀起新的内卷浪潮）。

​ Unit 2 启动！

【扬舲三山.】
关注
专栏目录
BUAA面向对象第一单元总结
weixin_40500026的博客
03-27 437
我的博客原文链接戳这里 OO Unit1总结博客 (｢･ω･)｢ 我用的是IntelliJ IDEA，下面的功能和插件都基于IDEA，所有的图如果觉得字太小可以右键查看高清大图～ 程序设计思路 第一单元主要做了含有幂函数和三角函数及其嵌套的表达式求导。 第一次作业由于只有幂函数，而且幂函数的形式很单一，所以可以直接用正则表达式 1 String reg =...
BUAA 面向对象 第二单元 总结
m0_72981432的博客
04-19 994
BUAA OO Unit2 2024 Summary
BUAA 面向对象 第四单元 及 期末 总结
m0_72981432的博客
06-11 1101
BUAA OO Unit4 and Final Summary
BUAA面向对象第一单元作业总结
03-26 211
前三次作业总结主要分为以下几个部分的内容： 数据抽象与类的设计 重构代码和功能的泛化 程序bug检验 基于度量的程序结构分析 数据抽象与类的设计 数据管理类 　　面向对象核心思想之一——“万物皆为对象”，在学习面向对象的编程伊始具有重要的意义。因为只有明确了程序依据数据抽象进行分类而不是依据算法执行的过程进行分类，才能在最开始设计程序时摆脱面向过程编程的烙印。第一次...
BUAA面向对象第二单元作业总结
weixin_30901729的博客
04-21 133
三次作业总结主要分为以下几个部分的内容： 多线程协同和控制 基于度量的程序结构分析 程序bug检验 心得体会 多线程协同和控制 　　第一次作业为傻瓜式先来先服务电梯调度，而且不考虑捎带优化。所以设计非常简单，只需要满足相关的线程同步避免轮询即可。 　　具体的设计为两个线程： (1) 电梯线程 （2）输入线程 　　　　线程互斥：两个线程竞争的资源区为 一个公共的队列，所以对该...
BUAA面向对象第三单元作业总结
weixin_30659829的博客
05-21 144
本次作业主要由以下内容构成 • (1)JML语言理论基础、应用工具链 • (2)SMT Solver • (3)JMLUnitNG/JMLUnit 　　针对Graph接口的实现自动生成测试用例， 并结合规格对生成的测试用例和数据进行简要分析 • (4)架构设计梳理以及重构 • (5)作业bug和修复 • (6)规格撰写体会 一、JML语言理论基础和工具链 　　JML注释结构. ...
BUAA面向对象设计与构造第四单元总结
m0_72656369的博客
06-15 872
本次作业实践了面向对象设计与构造课程的正向建模与开发流程，具体围绕小型图书馆管理系统展开，要求我们从零开始设计并实现一个符合特定业务规则的系统。1. 理解业务需求首先，我需要理解图书馆管理系统的业务场景，包括图书借阅、还书、查询、预约和取书的流程，以及图书馆的开馆闭馆整理规则。特别是对不同类别图书（A、B、C类）的借阅限制，以及图书在书架、借还处、预约处和用户之间的移动规则有了深入理解。2. 设计程序架构基于业务需求，我设计了系统的程序架构。
BUAA OO 第一单元总结
HYF333yyds的博客
03-17 264
这三次的作业对我个人来说难度较大，主要是因为我还对 Java 语言以及面向对象的编程思想不太熟悉。在刚开始编写程序的过程中，我大多是采用了面向过程的想法，在后来的作业中才逐渐理解到面向对象编程的基本思想以及面向对象的好处。在这一单元的测试里，虽然第一次和第三次作业均无 bug，但第二次作业的强测中我因为疏忽大意，没有充分测试，导致程序有 2 个 bug 没有被及时发现，挂掉了很多点，这也是我在第一单元中感到十分遗憾的地方。下面我将介绍我在第一单元中的设计以及心得体会。
BUAA_OO 第四单元总结
weixin_30507481的博客
06-19 300
BUAA_OO 第四单元总结 写在前面 UML是一种描述逻辑，提供了面向对象式的抽象与直观表述。本单元通过对UML语言内容的逐层深入（UML入门、UML模型关系、UML层次设计）进一步理解模型化设计的思想。下面对这一单元进行的实践操作进行小结，并对整个学期面向对象课程进行回顾总结。 第四单元作业总结 一、UML第一次作业 需求分析 概述 本次作业最终需要实现一个UML类图解析器，可以通过输入各种...
matlab终止以下代码-UML_Parser:BUAA面向对象的编程单元4
05-21
第四单元总结 总 本部分是2019年北航面向对象（OO）课程第四单元作业（UML）的总结。两次作业的要求大致如下： 第一次作业：实现一个UML类图解析器，可以通过输入各种指令来进行类图有关信息的查询。 第二次作业：...
BUAA-OO-2019 第二单元总结
TimDyh的博客
08-20 282
第五次作业 本次作业，需要完成的任务为单部多线程傻瓜调度（FAFS）电梯的模拟。 设计策略 先来先服务的单电梯是一个标准的**"生产者-消费者"模型**。虽然在本次作业中调度器似乎是不必要的，但为了更好地应用"生产者-消费者"模型，并方便下一次作业的扩展，还是应该保留了调度器的概念，将其作为"托盘"来存放还未服务的请求。 显然，读取输入并解析为请求就成为了生产者，而电梯就成为了消费者，而在本次作业...
BUAA-OO-2019 第一单元总结
TimDyh的博客
08-20 540
第一次作业 第一次作业需要完成的任务为简单多项式导函数的求解。 思路 因为仅仅是简单多项式的求导，所以求导本身没有什么可说的，直接套用幂函数的求导公式就行了，主要的精力是花在了正则表达式上。这里推荐两个网站： https://github.com/ziishaned/learn-regex https://regex101.com 前者可以用来学习正则表达式的语法，后者则提供实时的正则表达式匹配，...
BUAA-OO-2019 第三单元总结
TimDyh的博客
08-20 162
JML语言理论基础梳理及工具链 注释结构 JML以javadoc注释的方式来表示规格，每行都以@起头。 行注释：//@annotation 块注释：/* @ annotation @*/ JML表达式 JML的表达式是对Java表达式的扩展，新增了一些操作符和原子表达式。 原子表达式 \result表达式：表示一个非 void 类型的方法执行所获得的结果，即方法执行后的返回值。\resul...
[BUAA软工第三次]结对编程
weixin_45873510的博客
04-05 4083
[BUAA软工第三次]结对编程
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 231
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 289
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 912
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 836
知识量决定了未来能走多远
JavaWeb Servlet--09深入：注册系统04--修改页面
最新发布
weixin_62189092的博客
10-16 177
这里就会获取要修改的用户的id，返回用户，再把这个用户重定向跳转到update.jsp页面。在再UserServlet里书写修改的代码。分析：点击修改超链接，就跳转到一个修改界面，要显示原本的数据，且密码显示出来，在该页面将对用户的数据的进行修改，最后提交。findUserByID()----显示原本的内容，update()---修改数据库内容的方法。注意：修改信息是要展示密码的文本内容，所以在password处type="text";写法和register没有太大的区别，主要是对文本框获得值。
buaa数据结构第一次
06-28
第一次上课，可能会涵盖以下几个主题： 1. **数据结构概述**：介绍数据结构的定义、分类（如数组、链表、栈、队列、树、图等），以及它们在解决实际问题中的作用。 2. **基本数据结构**：详细讲解数组（顺序存储...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值