面向对象第一单元总结

骑猪看日落 2021-09-29 13:20 470阅读 0赞

#  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的问题，而是，我太菜的问题。

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

![1616482-20190327122716076-935416054.png][]    闲话少叙，下面进入正题，三次OO作业的总结。

###### OO第一次作业总结 ######

![1616482-20190327123702813-20803492.png][]

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

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

用流程图表示如下：

![1616482-20190327132740522-174007527.png][]

存在的问题：

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

<table style="width:624px;"> 
 <tbody> 
  <tr> 
   <td>jly.Input.checkFormat()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Input.checkInteger()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Input.checkLength()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Input.clear()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Input.Input(String)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.changeFormat()</td> 
   <td>9.0</td> 
   <td>9.0</td> 
   <td>9.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.combine(Item)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.delete()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.derivative()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.indexEquals(Item)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.Item(BigInteger)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.Item(BigInteger,BigInteger)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.Item(String)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Item.positive()</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>jly.Main.main(String[])</td> 
   <td>1.0</td> 
   <td>4.0</td> 
   <td>4.0</td> 
  </tr> 
  <tr> 
   <td>jly.Polynomial.combineAll()</td> 
   <td>3.0</td> 
   <td>11.0</td> 
   <td>11.0</td> 
  </tr> 
  <tr> 
   <td>jly.Polynomial.derivative()</td> 
   <td>1.0</td> 
   <td>8.0</td> 
   <td>8.0</td> 
  </tr> 
  <tr> 
   <td>jly.Polynomial.Polynomial(String)</td> 
   <td>1.0</td> 
   <td>1.0</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>Total</td> 
   <td>28.0</td> 
   <td>46.0</td> 
   <td>46.0</td> 
  </tr> 
  <tr> 
   <td>Average</td> 
   <td>1.56</td> 
   <td>2.56</td> 
   <td>2.56</td> 
  </tr> 
 </tbody> 
</table>

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

*发现的bug*

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

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

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

###### OO第二次作业总结 ######

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

![1616482-20190327140020240-1125820906.png][]

由于这一次的要求稍微复杂里一些，因此除新增的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)。

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

从图中我们可以看出来，两个重写的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

![1616482-20190327144318043-2087215761.png][]

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

![1616482-20190327145228625-772784609.png][]

*发现的bug：*

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

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

**OO第三次作业总结**

![1616482-20190327150920700-381309656.png][]

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

![1616482-20190327152141503-1036679253.png][]

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

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

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

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

可以看到checkFormat()的复杂度果然较高。

*发现的bug：*

自己的bug：由于采用了不优化大法，故幸运地没有被hack。?

别人的bug：作为幂次的整数忘记了前面可以加‘+’；优化时多去掉了一层括号。

###### **找bug的策略** ######

其实没啥策略，多构造几个测试样例（例如，在每个能加空格的地方都加两个空格，多加幂次运算等等），看其他人代码感觉太麻烦了，主要是看了半天还看不懂......

总结一下：随缘测试，随缘hack(\*^\_^\*)

**针对第三次作业的重构**

由于我的第三次作业较为面向过程，也没有用到继承，故对其进行一些重构：

![1616482-20190327210625390-766071662.png][]

概括来说，就是将五种因子类（x/sin/cos/表达式/常数）统一继承factor基类，并建立求导接口。

使用如图所示的继承和接口的方式，可以显著提高程序的面向对象特性，也可以降低程序的复杂度，增强代码可读性，减少类和方法的长度，有效规避bug的出现等等优点不一而足，显然与原来的架构相比有着较为突出的优势。

**结语（突如其来的中二）**

在OO这条路上，我还只是一个初出茅庐的孩子，还有很多艰难险阻等着我去跨越，以后的路，也一定会越来越难走，但我有理由相信，凭借我的决心与毅力，我一定能顺利地抵达路途的终点（大佬们，快带带我~~~）。

> # 愿指引明路的苍蓝星为我们闪烁 #

转载于:https://www.cnblogs.com/17231041jly/p/10610747.html

[1616482-20190327122716076-935416054.png]: /images/20210725/836cb06f53c1422889c25d0ab228277c.png
[1616482-20190327123702813-20803492.png]: /images/20210725/c22e50a1058c45b9a6e2f8bd2f88a4ac.png
[1616482-20190327132740522-174007527.png]: /images/20210725/c9b3ffb33fdd4494a869c88b365f135b.png
[1616482-20190327140020240-1125820906.png]: /images/20210725/3cb43cefef3e4274bcf0d5be311fb70c.png
[1616482-20190327144318043-2087215761.png]: /images/20210725/ba8f4c2c58c2415ebd19b51e99072330.png
[1616482-20190327145228625-772784609.png]: /images/20210725/997159ed5cec4242a31dbfb3914d6bbb.png
[1616482-20190327150920700-381309656.png]: /images/20210725/6413a4a2c2694919abb84a6068f39e36.png
[1616482-20190327152141503-1036679253.png]: /images/20210725/fedf3d02955c431faa0dc33524d0f50f.png
[1616482-20190327210625390-766071662.png]: /images/20210725/ba8e2bfd22db404089b6134c9aada4c2.png