面向对象第一单元总结-CSDN博客

OO第一单元总结

17231041 金陆洋

一点杂谈

　　由于这是我第一次写博客，在正式开始之前，就先谈一些个人的想法吧，权当是正菜之前的甜品了。

　与Java的初见：作为一个菜鸡，第一次真正动手编写Java程序是上个学期的Java程序设计，那门课的大作业我写了一个小游戏，第一次真正了解了“对象”这一概念，也第一次了解了多线程，也因此，第一次接触了线程冲突这个令人头秃的问题。

　而为了解决这个问题，当时年轻的我（其实现在也很年轻）根本不知道还有volatile/synchronized抑或是Lock锁这种东西，于是我十分头铁地采用了大量的Arrays.copyOf方法，啥？你问我为啥使用Array这么“朴素”的东西？那当然是为了挑战自己，提高自己的编程水平啦，其实是因为年轻的我当时还不知道容器（ArrayList、Map、Set等）这个如此好用的东西（当然，好用也是有局限性的，使用HashMap的心碎历程见下文），其实，就算是这样做其实也是会有问题的，但总算不会玩着玩着就报错了......?

　那接下来，就说一下我用的第一个Java IDE，也就是Eclipse，啥？你又要问我IntelliJ IDEA这么好用的IDE为啥不用捏？emmm，当时哪有这么善良的助教推荐IDEA，作为编程菜鸡又不知道，感觉比VC6.0好用，就这么用下去了?

我在那回眸的一瞥错过了你，还好，这一次的错过，并不是永恒。

——本菜鸡

　　很显然，半年后，我用上了IDEA。

　　于是，我与Java就这么稀里糊涂地初见了，不知道他对我感觉咋样，我对他，感觉可能和初见沙河的感觉一样吧，但现在回想起来，这并不是Java的问题，而是，我太菜的问题。

这就好比人家拿来了钢筋混凝土让我造房子，我不知道咋用，然后用砖头造了一个，没过两天房子塌了，结果说人家材料不行

闲话少叙，下面进入正题，三次OO作业的总结。

OO第一次作业总结

这次作业的功能较为简单，因此，我采用的架构也相对简单，大致逻辑如下：

读入字符串
对读入的字符串进行格式检查
对输入格式正确的字符串进行分割，分割成多个项（Item）
对每一个项进行求导
对求导后得到的所有项进行合并同类项等化简
将化简后的项进行输出

　　用流程图表示如下：

　　存在的问题：

在main函数中进行读入，应新建InputString类进行单独处理，增强可拓展性
使用大正则进行匹配
```
public boolean checkFormat() {
        return input.matches("-?((\\d+(\\*x(\\^-?\\d+)?)?)|(x(\\^-?\\d+)?))" +
                "(\\+-?((\\d+(\\*x(\\^-?\\d+)?)?)|(x(\\^-?\\d+)?)))*");
    }
```
其实，我这里匹配的已经不是最原始的字符串了，而是经过处理的（去掉空字符、替换加减号等），因此正则表达式似乎不那么复杂，但无论如何，这不是一种好的习惯（十分幸运，未发生爆栈问题，实测极限在1700-1800个字符）。

jly.Input.checkFormat()	1.0	1.0	1.0
jly.Input.checkInteger()	1.0	1.0	1.0
jly.Input.checkLength()	1.0	1.0	1.0
jly.Input.clear()	1.0	1.0	1.0
jly.Input.Input(String)	1.0	1.0	1.0
jly.Item.changeFormat()	9.0	9.0	9.0
jly.Item.combine(Item)	1.0	1.0	1.0
jly.Item.delete()	1.0	1.0	1.0
jly.Item.derivative()	1.0	1.0	1.0
jly.Item.indexEquals(Item)	1.0	1.0	1.0
jly.Item.Item(BigInteger)	1.0	1.0	1.0
jly.Item.Item(BigInteger,BigInteger)	1.0	1.0	1.0
jly.Item.Item(String)	1.0	1.0	1.0
jly.Item.positive()	1.0	1.0	1.0
jly.Main.main(String[])	1.0	4.0	4.0
jly.Polynomial.combineAll()	3.0	11.0	11.0
jly.Polynomial.derivative()	1.0	8.0	8.0
jly.Polynomial.Polynomial(String)	1.0	1.0	1.0
Total	28.0	46.0	46.0
Average	1.56	2.56	2.56

　　从这张代码复杂度的图中我们可以看出来合并同类项（Polynomial.combineAll()方法）的复杂度较高，其实这就涉及到我程序中的第三个问题：没有真正做到一个方法只做一件事，为了方便，我在该方法中除合并同类项外还进行了一些其他化简以及toString()方法，导致耦合度较高。

发现的bug

　　自己的bug：正则表达式存在问题，某个位置少打了一个‘+’，导致只能识别一个空字符。因此

不要用大正则！！不要用大正则！！不要用大正则！！重要的话说三遍

　　别人的bug：/f/v的组合轰炸（太可怕了~~）其实第一次作业比较简单，感觉大家都没有什么bug。

OO第二次作业总结

　　这次作业，总结起来就是和hashMap奋战的一次惨痛经历。

　　由于这一次的要求稍微复杂里一些，因此除新增的InputString类对输入字符串进行处理外（这次放弃了大正则，改为一项一项进行提取并匹配），还新增了Deried类作为多项式类和因子类的桥梁（Deried对象是乘法求导法则中的单独一项），此外总体思路与第一次作业相差不大。

例如：f(x) = 3*x*sin(x) ,f(x)' = 3*sin(x) + 3*x*cos(x), 那么Deried中就会有两个对象，分别是3*sin(x)和3*x*cos(x)。

oo.Deried.Deried(int,ArrayList)	4.0	3.0	4.0
oo.Deried.getFac()	1.0	1.0	1.0
oo.Deried.getNumber()	1.0	1.0	1.0
oo.Factor.canCombine(Factor)	1.0	6.0	6.0
oo.Factor.derivative()	3.0	3.0	3.0
oo.Factor.equals(Object)	3.0	3.0	5.0
oo.Factor.Factor(BigInteger,BigInteger,BigInteger)	1.0	1.0	1.0
oo.Factor.Factor(String)	1.0	7.0	10.0
oo.Factor.getNum()	1.0	1.0	1.0
oo.Factor.hashCode()	1.0	1.0	1.0
oo.Factor.isVariable()	1.0	1.0	1.0
oo.Factor.multiply(String)	1.0	1.0	1.0
oo.Factor.toString()	1.0	11.0	11.0
oo.Factor.toString(Factor)	1.0	20.0	20.0
oo.InputString.checkFormat()	3.0	2.0	4.0
oo.InputString.checkLength()	1.0	1.0	1.0
oo.InputString.dispose()	1.0	2.0	2.0
oo.InputString.InputString()	1.0	2.0	2.0
oo.Main.main(String[])	3.0	7.0	7.0
oo.Polynomial.combine()	6.0	7.0	9.0
oo.Polynomial.insert(Factor)	1.0	9.0	9.0
oo.Polynomial.insertTwo(Factor,Factor)	1.0	9.0	9.0
oo.Polynomial.Polynomial(ArrayList<arraylist>)	1.0	5.0	5.0

　　从图中我们可以看出来，两个重写的toString()方法复杂度很高，这就暴露了这次代码的一个重大问题（不过当时没发现导致第三次作业没改过来?），就是没有为x/sin/cos单独建类，而是统一到一个类中，导致我使用了较多的分支语句。

注：关于为什么有两个toString()，因为另一个toString()是为了合并诸如sin(x)^2+cos(x)^2这种因子使用的，小伙伴们不必过分纠结?

　　接下来，我想重点探（tu）讨（cao）一下HashMap这个神奇的东西。

　　这次作业，在助教的推荐下，我尝试使用了HashMap来存储求导之后的每一项。

　　众所周知，使用自定义类需要重写hashCode()和equals()方法，我就不过多赘述了，直接贴一下代码（应该没写错吧......）。

　　@Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Factor)) {
            return false;
        }
        Factor fac = (Factor) obj;
        return this.xxIndex.equals(fac.xxIndex)
                && this.sinIndex.equals(fac.sinIndex)
                && this.cosIndex.equals(fac.cosIndex);
    }

    @Override
    public int hashCode() {
        return this.xxIndex.toString().hashCode()
                + this.sinIndex.toString().hashCode()
                + this.cosIndex.toString().hashCode();
    }

　　在使用HsanMap的过程中，我发现合并同类项格外的简单，比ArrayList简单了不是一点半点。

　　等到了化简的时候，我就傻了眼。

　　当我想做类似如下事情的时候（由于HashMap遍历推荐使用迭代器）：

List<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("bbc");
        list.add("abc");
        list.add("cbc");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String str = it.next();
            Iterator<String> itAno = list.iterator();
            while (itAno.hasNext()) {
                String strAno = itAno.next();
                if (str.equals(strAno)) {
                    it.remove();
                    itAno.remove();
                }
            }
        }
    }

　　恭喜我自己，喜提Exception

　　其实不知可否通过添加try/catch块来解决这个问题，当时的尝试失败了，最终通过为每一个元素添加一个flag标志位解决了这个问题（菜鸡想不出别的办法了，求问各位大佬有更好的办法吗......）。

发现的bug：

　　自己的bug：依然是正则表达式的问题，由于改成一项一项进行匹配，忘记了最后一项末尾可能存在的空字符问题。

　　别人的bug：大多数是*sin(x)、sin(x) + 这种WF的问题。

OO第三次作业总结

　　这次的作业，采用了递归下降的方式，流程图如下：

　　这次的程序，与前两次的相比，更加面向过程了一些，其实这是个很大的问题，但当时只想完成作业，没有想这么多。

　　这次的程序，概括下来有如下几个特点（与前两次相比）：

边checkoutFormat边求导（其实这导致了程序耦合度较高，不大可取）。
舍弃优化（不优化保命大法好）。

oo.Factor.checkFormat()	4.0	4.0	4.0
oo.Factor.diff()	1.0	4.0	4.0
oo.Factor.Factor(String)	1.0	1.0	1.0
oo.Factor.triDiff()	1.0	4.0	4.0
oo.InputString.checkFormat()	7.0	15.0	18.0
oo.InputString.InputString()	1.0	2.0	2.0
oo.InputString.InputString(String)	1.0	1.0	1.0
oo.InputString.toItem()	1.0	2.0	2.0
oo.Item.checkFormat()	6.0	9.0	9.0
oo.Item.Item(String)	1.0	6.0	6.0
oo.Item.toFactor()	1.0	4.0	4.0
oo.Main.add(BigInteger)	1.0	1.0	1.0
oo.Main.add(char)	1.0	1.0	1.0
oo.Main.add(int)	1.0	1.0	1.0
oo.Main.add(String)	1.0	1.0	1.0
oo.Main.delete()	1.0	1.0	1.0
oo.Main.main(String[])	1.0	2.0	2.0
Total	31.0	59.0	62.0
Average	1.8235294117647058	3.4705882352941178	3.6470588235294117