OOP课第三阶段总结

oop · 浏览次数 : 7

小编点评

**OOP课程第三阶段总结** 在前面的OOP课程第三阶段学习中，我经历了一系列的挑战和学习机会。在此，我想分享一些我在学习过程中遇到的问题和解决方案，以及对未来学习的展望。 首先，我想表达的是，我在设计上感受到了一些极大的缺陷。特别是在家电模拟大作业的三、四阶段，由于没有充分考虑引脚的存在，我在处理互斥开关和二极管等设备时遇到了困难。这导致了我在第四次大作业中的失败，成绩远低于预期。 然而，我也意识到，正是这些挑战促使我深入思考和学习。在处理复杂的电路情况时，我学会了如何使用等效的方式解决互斥开关的问题，并且为普通的开关定义了新的命名规则。此外，我还学会了如何处理二极管和输出引脚电势的情况，以及如何在输出每个电器的状态信息后，再依次输出该电器每个管脚的电压。 在UML类图设计思路上，我基本遵循了设备类的设计思路，将所有电路类都继承于设备类。这使得我在处理复杂的电路情况时能够更加灵活和高效。 在这次学习过程中，我最大的收获是明白了在设计程序时，需要考虑到各种可能的情况，并为每种情况制定相应的解决方案。同时，我也认识到了代码的可读性和可维护性对于程序的重要性。 对于未来的学习，我希望能够进一步提高我的代码质量和效率。我会更加注重代码的结构和逻辑性，以及如何更好地利用面向对象编程的优势。此外，我也会继续关注课程中的问题和技术细节，以便更好地理解和应用所学知识。 最后，我要感谢老师和同学们在这次学习过程中的帮助和支持。你们的指导和鼓励让我不断进步，也让我更加坚定了在OOP领域继续探索的决心。

正文

OOP课第三阶段总结

前言：

  • 我想说的第一句是：”我感受到了设计上的极大缺陷“，从一开始，我完全就忽略了引脚的存在。因为在第二阶段中，家电模拟大作业一、二在不需要考虑引脚的情况下也可以完成。但是当来到第三次，出现了互斥开关，因为互斥开关的特殊性，它具有1、2、3三个引脚，并且连接方式多种多样，所以再不考虑引脚，那么互斥开关的情况我是应对不了的。但是，我并没有为所有的设备保留其引脚信息，而是只考虑了互斥开关这一个另类。以至于，在第四次家电模拟大作业中，惨败。

  • 模拟电路是一个非常具有扩展性的题目，因为电路的连接方式可以千变万化，其中的设备也可以是五花八门。这就非常考验到了我写的代码，能不能应对多种多样的电路情况。而且在第四次大作业中还加入了二极管以及要求输出各个设备引脚的电势，其实我感觉只加入二极管不难，只加入输出引脚电势的需求也不难，但是这两者同时出现，却会导致难度陡然上升。

  • 最后一次大作业让我很遗憾，只拿到了不到1/3的分数。我想要投入更多的时间，好歹及格吧。但是接下来几天的考试又不允许我持续往PTA倾斜时间，所以在结束的最后一天，距离结束还有6个小时的时候，我停止了作答。并不是我想要放弃了，而是我真的必须去复习其他课程了，这是最具有性价比的。希望等待老师开启补练后，我可以完成最后一次大作业。在此我又统计了每次题目集的通过情况。可以看到，最后一次题目集的惨况，但提交次数却远不及同为通过率最低的第一次迭代（答题信息）的题目集三的提交次数，可见，在期末紧张的时间下，很多同学并没有足够多的时间投入其中。

8次大作业通过情况

正文：

  • 第七次题目集 ：

    新增设备：

    互斥开关：

    解释互斥开关有3个引脚：1个是汇总引脚，另两个是分支引脚。
开关电路示意图如图1所示，左边是汇总引脚，编号为1；右边两个是分支引脚，右上的输出引脚为2，右下输出引脚为3。图中1、2、3引脚均可以是输入引脚，当1为输入引脚时，2、3引脚为输出引脚；1为输出引脚时，2、3引脚为输入引脚。
互斥开关只有两种状态：开关接往上面的2号引脚、接往下面的3号引脚。开关每次只能接通其中一个分支引脚，而另一个分支引脚处于断开状态。
互斥开关的默认状态为1、2引脚接通，1、3引脚断开。
图1中所示的互斥开关可以反过来接入电路，即汇总引脚接往接地端，两个分支引脚接往电源端。

    受控窗帘：

    受控窗帘的电路符号为S，其最低工作电压为50V，电压达到或超过50V，窗帘即可正常工作，不考虑室外光照强度和室内空间大小等因素，窗帘受室内灯光的光照强度控制。

    解释当电路中所有灯光的光照强度总和在[0,50)lux范围内，窗帘全开；
在[50,100)lux范围内，窗帘打开比例为0.8；
在[100,200)lux范围内，窗帘打开比例为0.6；
在[200,300)lux范围内，窗帘打开比例为0.4；
在[300,400)lux范围内，窗帘打开比例为0.2；
在400lux及以上范围内，窗帘关闭。
当电压低于50V，窗帘不工作，默认为全开状态。
如果电路中没有灯或者灯全部关闭，光照强度为0，窗帘处于全开状态。

    新增电路情况：

    多个并联电路串联在一起的情况。

    考虑一条串联电路中包含其他串联电路的情况。

    第七次题目集新增两大内容，新的设备及新的电路情况。

    其实这并不会很难，因为互斥开关以及新的电路情况，都可以通过等效的方式来解决。

    • 互斥开关

      本质上，互斥开关可以等效为两条并联支路上的两个状态互异的正常开关，两个开关只能有一个处于闭合状态。当改变互斥开关的状态时，就分别改变两个开关的状态。并且对这两个开关进行电阻赋值。

      并且我为这两个由互斥开关等效而来的普通开关定义了新的命名规则：

      当互斥开关的信息为：H+"序号"+"-"+"引脚号"时

      等效开关的名称便被我定义为：K+"互斥开关的序号+100"+"-"+"当前电路上的互斥开关的引脚号"。

      例如：

      H1-2等效为K101-2，并且对此电阻赋值为5

      经过这样的操作后，我就可以很好的处理互斥开关的特殊性了。

      那么最后关于互斥开关的信息如何输出？这个也是很好解决的，我们只需要根据互斥开关的序号加上100，在开关中寻找与之对应的两个开关，根据两者的状态便可知道互斥开关的状态。当K101-2是闭合的且K101-3是断开的时候，H1就是闭合的。反之H1断开。

    • 受控窗帘

      这个再简单不过了，我只需要在输出受控窗帘的信息之前把所有的能产生光亮的设备的亮度进行相加求和就好了，再判断一下是不是达到了最低工作电压。

    • 串联电路包含串联

      这个我认为是所有特殊的电路情况里面最好解决的。因为我的所有电路类都继承于设备类，我只需要在遍历每一条串联电路的设备信息时，将其中含有的串联电路的所有设备依次添加到该串联电路中去。因为串联电路中包含串联电路的情况，本质上还是一条串联电路。所以是很好解决的。

    • 多个并联电路串联

      这个也算不上很难的点，很多人的代码都不需要或者经过少量的更改就能处理这个情况。本质上还是在主电路上添加一个并联电路信息，然后得到所有并联电路的等效电阻后一起计算分压就好了。

    到这里，题目集七就算是被解决了。思路很正确，但是代码呢？能提出解决方法的人不一定能很好的实现这个方法。

    UML类图

    类图就是这样，全都继承于设备类。

    Method CogC ev(G) iv(G) v(G)
    ControlledDevice.ControlledDevice() 0 1 1 1
    ControlledDevice.ControlledDevice(String, int) 0 1 1 1
    Controller.Controller(String, int) 0 1 1 1
    Controller.Controller(double) 0 1 1 1
    Controller.getGear() 0 1 1 1
    Controller.setGear(double) 0 1 1 1
    CurtainOfS.CalculateOpenScale(double) 10 1 7 8
    CurtainOfS.CurtainOfS(String, int) 0 1 1 1
    CurtainOfS.getOpenScale() 0 1 1 1
    CurtainOfS.setOpenScale(double) 0 1 1 1
    Device.Device() 0 1 1 1
    Device.Device(String, int) 0 1 1 1
    Device.getInputPin() 0 1 1 1
    Device.getInputV() 0 1 1 1
    Device.getName() 0 1 1 1
    Device.getNumber() 0 1 1 1
    Device.getOutPin() 0 1 1 1
    Device.getOutV() 0 1 1 1
    Device.getPartialPressure() 0 1 1 1
    Device.getResistance() 0 1 1 1
    Device.setInputPin(int) 0 1 1 1
    Device.setInputV(double) 0 1 1 1
    Device.setName(String) 0 1 1 1
    Device.setNumber(int) 0 1 1 1
    Device.setOutPin(int) 0 1 1 1
    Device.setOutV(double) 0 1 1 1
    Device.setPartialPressure(double) 0 1 1 1
    Device.setResistance(double) 0 1 1 1
    Fan.Fan(String, int) 0 1 1 1
    Fan.Fan(double) 0 1 1 1
    Fan.getSpeed() 0 1 1 1
    Fan.setSpeed(double) 0 1 1 1
    FanOfA.FanOfA(String, int) 0 1 1 1
    FanOfA.FanOfA(double) 0 1 1 1
    FanOfA.calculateSpeed() 5 1 4 5
    FanOfA.setSpeed(double) 0 1 1 1
    FanOfD.FanOfD(String, int) 0 1 1 1
    FanOfD.FanOfD(double) 0 1 1 1
    FanOfD.calculateSpeed() 3 1 3 3
    FanOfD.setSpeed(double) 0 1 1 1
    FilamentLamp.CalculateBrightness() 3 1 3 3
    FilamentLamp.FilamentLamp(String, int) 0 1 1 1
    FilamentLamp.setBrightness(double) 0 1 1 1
    FluorescentLamp.CalculateBrightness() 2 1 1 2
    FluorescentLamp.FluorescentLamp(String, int) 0 1 1 1
    FluorescentLamp.setBrightness(double) 0 1 1 1
    Lamp.Lamp(String, int) 0 1 1 1
    Lamp.getBrightness() 0 1 1 1
    Lamp.setBrightness(double) 0 1 1 1
    ParallelCircuit.ParallelCircuit(String, int, ArrayList) 0 1 1 1
    ParallelCircuit.ParallelCircuit(double, double) 0 1 1 1
    ParallelCircuit.getPartialPressure() 0 1 1 1
    ParallelCircuit.getSeriesNames() 0 1 1 1
    ParallelCircuit.setPartialPressure(double) 0 1 1 1
    ParallelCircuit.setSeriesNames(ArrayList) 0 1 1 1
    SeriesCircuit.SeriesCircuit(String, int, ArrayList) 0 1 1 1
    SeriesCircuit.SeriesCircuit(double, double) 0 1 1 1
    SeriesCircuit.getEquipments() 0 1 1 1
    SeriesCircuit.setEquipments(ArrayList) 0 1 1 1
    SwitchOfF.SwitchOfF(String, int) 0 1 1 1
    SwitchOfF.SwitchOfF(double) 0 1 1 1
    SwitchOfF.calculateState() 4 1 1 6
    SwitchOfF.getState() 0 1 1 1
    SwitchOfF.setState(double) 0 1 1 1
    SwitchOfH.IsClose() 2 2 1 2
    SwitchOfH.SwitchOfH(String, int) 0 1 1 1
    SwitchOfH.SwitchOfH(double) 0 1 1 1
    SwitchOfH.getState() 0 1 1 1
    SwitchOfH.setState(double) 0 1 1 1
    SwitchOfK.IsClose() 2 2 1 2
    SwitchOfK.SwitchOfK(String, int) 0 1 1 1
    SwitchOfK.SwitchOfK(double) 0 1 1 1
    SwitchOfK.isClose() 0 1 1 1
    SwitchOfK.setClose(boolean) 0 1 1 1
    SwitchOfL.SwitchOfL(String, int) 0 1 1 1
    SwitchOfL.SwitchOfL(int, double) 0 1 1 1
    SwitchOfL.calculateState() 0 1 1 1
    SwitchOfL.getState() 0 1 1 1
    SwitchOfL.setState(double) 0 1 1 1
    TotalCircuit.TotalCircuit(String, int) 0 1 1 1
    TotalCircuit.TotalCircuit(double, double) 0 1 1 1
    TotalCircuit.getInputV() 0 1 1 1
    TotalCircuit.getIsOk() 0 1 1 1
    TotalCircuit.getName() 0 1 1 1
    TotalCircuit.getNumber() 0 1 1 1
    TotalCircuit.getOutV() 0 1 1 1
    TotalCircuit.getResistance() 0 1 1 1
    TotalCircuit.setInputV(double) 0 1 1 1
    TotalCircuit.setIsOk(int) 0 1 1 1
    TotalCircuit.setName(String) 0 1 1 1
    TotalCircuit.setNumber(int) 0 1 1 1
    TotalCircuit.setOutV(double) 0 1 1 1
    TotalCircuit.setResistance(double) 0 1 1 1

    这张图是一个Kiviat（雷达）图，用来展示Java程序的多项度量指标。以下是对各个指标的分析：

    1. 平均复杂度 (Avg Complexity)：

      • 值：3.27，理想范围：[2.0-4.0]
      • 我的值处于理想范围内，说明代码的平均复杂度较为合理。

    2. 平均深度 (Avg Depth)：

      • 值：3.67，理想范围：[1.0-2.2]
      • 我的值高于理想范围，说明代码的嵌套深度较深，可能会导致代码难以理解和维护。

    3. 最大深度 (Max Depth)：

      • 值：9+，理想范围：[3-7]
      • 我的值显著高于理想范围，这可能意味着某些部分的代码嵌套过深，建议进行重构以减少嵌套深度。

    4. 最大复杂度 (Max Complexity)：

      • 值：181，理想范围：[2-8]
      • 我的值远高于理想范围，说明有部分代码的复杂度非常高，需要重点关注和优化。

    5. 每类方法数 (Methods/Class)：

      • 值：5.22，理想范围：[4-16]
      • 我的值处于理想范围内，说明每个类的方法数量较为合理。

    6. 每个方法的平均语句数 (Avg Stmts/Method)：

      • 值：6.33，理想范围：[6-12]
      • 我的值处于理想范围内，说明每个方法的语句数量适中。

    7. 注释百分比 (% Comments)：

      • 值：5.5，理想范围：[8-20]
      • 我的值低于理想范围，说明需要增加注释以提高代码的可读性和可维护性。

    总体来说，图中的某些指标如平均复杂度、每类方法数和每个方法的平均语句数都处于理想范围内，但最大深度、最大复杂度和注释百分比需要特别关注和改进，以提高代码质量。

  • 第八次题目集：

    新增设备：

    二极管：

    增加二极管元件，其电路特性为：正向导通，反向截止；其电器符号如图4所示，当电流从左至右流过时，二极管导通”conduction”，电阻为0；电流从右至左流动时，二极管截止”cutoff”，电阻无穷大，相当于开关打开。

    1、如果两端电压为0，二极管的导通/截止状态由接入方向决定，1号引脚靠近电源则状态为导通，反之为截止。
2、如果两端电压不为0，二极管导通。

    新增电路情况：

    并联电路中包含并联：

    本次迭代考虑并联电路中包含并联电路的情况，即构成并联电路的串联电路可以包含别的并联电路。例如如下输入的电路，并联电路M2的其中一条串联电路T4中包含了另一条并联电路M1：

    #T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]
#T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]
#M1:[T1 T2]
#T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]
#T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]
#M2:[T4 T5]

    新增处理情况：

    管脚电压的显示：

    在输出每个电器的状态信息后，再依次输出该电器每个管脚的电压。

    @B1:200 220-0

    电流限制：

    电器在工作时，过大的电流会引起电器过热，从而烧坏电路。本次迭代，每个元器件都有最大电流的设置，当实时电流超过最大电流时，在该电器输出信息的最后加入提示“exceeding current limit error”，与前面的信息之间用英文空格分隔。

    @B1:190 68-17 exceeding current limit error

    正如我前言所说，这次的重难点在于处理好二极管和输出引脚电势共同存在的情况，因为很难有一个通用的方法去应对每一种情况。我先将二极管和输出引脚电势的情况分开进行讨论：

    • 二极管

      分析一下，二极管正向电阻为0，逆向电阻为无穷大。我可以根据引脚的出现顺序来判断二极管的电流方向。

      当引脚1先出现时，我将二极管的电阻设置为0，否则通过：

      Integer.MAX_VALUE

      设置二极管电阻为一个很大的值。

    • 输出引脚电势：

      分析一下，如何输出引脚电势：

      因为大多数人选择的都是通过计算电阻来直接获取设备分压的，而不是通过引脚的电势差来获取设备分压，这样并不能直接计算出引脚的电势，所以存在很大的缺陷。

      但是也不是没有方法去处理这样的情况：

      我从主电路开始遍历，将主电路的输入引脚的电压计算出来，按照遇到设备（这里的设备包括可能遇到的并联电路/串联电路）便将设备的输入引脚的电压赋值为前一个输出引脚的电压（第一个设备的输入引脚的电压等于主电路的输入引脚的电压）。然后每得到一个设备的输入引脚的电压，就用这个值减去当前设备的分压，后赋值给其输出引脚的电压。

      这样，主电路被处理好了。

      接下来处理并联电路就好了：

      按照从后往前的顺序去处理并联电路，类似地，将并联电路的每一条支路的输入电压赋值为该并联电路的输入电压，再遍历这些支路上的设备，接下来的操作和刚才一样，不再赘述。

    • 输出电流过大警告：

      这个是最好处理的，因为在此之前我已经获取了每个设备的分压以及电阻，只需要通过：

      电流=分压/电阻

      就可以得到该设备当前的电流。

      但是值得注意的是，这种方法只对有电阻的设备有效，开关是无法通过这种方法得到的。

      那么开关电流就需要通过计算开关当前所在串联电路的电流来得到，只需要用开关所在串联电路的分压/总电阻就好了。这些数据我都是已经提前获取好的了。

    这也就算是能处理好每一种情况了，但是由于二极管的特殊性，导致电路中的电势情况更加复杂。目前我没有很好的方法去处理。

UML类图

设计思路基本一致。

Method CogC ev(G) iv(G) v(G)
ControlledDevice.ControlledDevice() 0 1 1 1
ControlledDevice.ControlledDevice(String, int) 0 1 1 1
Controller.Controller(String, int) 0 1 1 1
Controller.Controller(double) 0 1 1 1
Controller.getGear() 0 1 1 1
Controller.setGear(double) 0 1 1 1
CurtainOfS.CalculateOpenScale(double) 10 1 7 8
CurtainOfS.CurtainOfS(String, int) 0 1 1 1
CurtainOfS.getOpenScale() 0 1 1 1
CurtainOfS.setOpenScale(double) 0 1 1 1
Device.Device() 0 1 1 1
Device.Device(String, int) 0 1 1 1
Device.getExceedingLimitMax() 0 1 1 1
Device.getFirstPin() 0 1 1 1
Device.getInputPin() 0 1 1 1
Device.getInputV() 0 1 1 1
Device.getName() 0 1 1 1
Device.getNumber() 0 1 1 1
Device.getOutPin() 0 1 1 1
Device.getOutV() 0 1 1 1
Device.getPartialPressure() 0 1 1 1
Device.getPin1() 0 1 1 1
Device.getPin2() 0 1 1 1
Device.getResistance() 0 1 1 1
Device.isExceedingLimit() 0 1 1 1
Device.setExceedingLimit(boolean) 0 1 1 1
Device.setExceedingLimitMax(double) 0 1 1 1
Device.setFirstPin(int) 0 1 1 1
Device.setInputPin(int) 0 1 1 1
Device.setInputV(double) 0 1 1 1
Device.setName(String) 0 1 1 1
Device.setNumber(int) 0 1 1 1
Device.setOutPin(int) 0 1 1 1
Device.setOutV(double) 0 1 1 1
Device.setPartialPressure(double) 0 1 1 1
Device.setPin1(double) 0 1 1 1
Device.setPin2(double) 0 1 1 1
Device.setResistance(double) 0 1 1 1
Fan.Fan(String, int) 0 1 1 1
Fan.Fan(double) 0 1 1 1
Fan.getSpeed() 0 1 1 1
Fan.setSpeed(double) 0 1 1 1
FanOfA.FanOfA(String, int) 0 1 1 1
FanOfA.FanOfA(double) 0 1 1 1
FanOfA.calculateSpeed() 5 1 4 5
FanOfA.setSpeed(double) 0 1 1 1
FanOfD.FanOfD(String, int) 0 1 1 1
FanOfD.FanOfD(double) 0 1 1 1
FanOfD.calculateSpeed() 3 1 3 3
FanOfD.setSpeed(double) 0 1 1 1
FilamentLamp.CalculateBrightness() 3 1 3 3
FilamentLamp.FilamentLamp(String, int) 0 1 1 1
FilamentLamp.setBrightness(double) 0 1 1 1
FluorescentLamp.CalculateBrightness() 2 1 1 2
FluorescentLamp.FluorescentLamp(String, int) 0 1 1 1
FluorescentLamp.setBrightness(double) 0 1 1 1
Lamp.Lamp(String, int) 0 1 1 1
Lamp.getBrightness() 0 1 1 1
Lamp.setBrightness(double) 0 1 1 1
ParallelCircuit.ParallelCircuit(String, int) 0 1 1 1
ParallelCircuit.ParallelCircuit(String, int, ArrayList) 0 1 1 1
ParallelCircuit.getSeriesNames() 0 1 1 1
ParallelCircuit.getUpName() 0 1 1 1
ParallelCircuit.setSeriesNames(ArrayList) 0 1 1 1
ParallelCircuit.setUpName(String) 0 1 1 1
SeriesCircuit.SeriesCircuit(String, int, ArrayList) 0 1 1 1
SeriesCircuit.getEquipments() 0 1 1 1
SeriesCircuit.setEquipments(ArrayList) 0 1 1 1
SwitchOfF.SwitchOfF(String, int) 0 1 1 1
SwitchOfF.SwitchOfF(double) 0 1 1 1
SwitchOfF.calculateState() 4 1 1 6
SwitchOfF.getState() 0 1 1 1
SwitchOfF.setState(double) 0 1 1 1
SwitchOfH.IsClose() 2 2 1 2
SwitchOfH.SwitchOfH(String, int) 0 1 1 1
SwitchOfH.SwitchOfH(double) 0 1 1 1
SwitchOfH.getPin_1_v() 0 1 1 1
SwitchOfH.getPin_2_v() 0 1 1 1
SwitchOfH.getPin_3_v() 0 1 1 1
SwitchOfH.getState() 0 1 1 1
SwitchOfH.setPin_1_v(double) 0 1 1 1
SwitchOfH.setPin_2_v(double) 0 1 1 1
SwitchOfH.setPin_3_v(double) 0 1 1 1
SwitchOfH.setState(double) 0 1 1 1
SwitchOfK.IsClose() 2 2 1 2
SwitchOfK.SwitchOfK(String, int) 0 1 1 1
SwitchOfK.SwitchOfK(double) 0 1 1 1
SwitchOfK.isClose() 0 1 1 1
SwitchOfK.setClose(boolean) 0 1 1 1
SwitchOfL.SwitchOfL(String, int) 0 1 1 1
SwitchOfL.SwitchOfL(int, double) 0 1 1 1
SwitchOfL.calculateState() 0 1 1 1
SwitchOfL.getState() 0 1 1 1
SwitchOfL.setState(double) 0 1 1 1
SwitchOfP.SwitchOfP(String, int) 0 1 1 1
SwitchOfP.SwitchOfP(double) 0 1 1 1
SwitchOfP.isConduction() 0 1 1 1
SwitchOfP.setConduction(boolean) 0 1 1 1
SwitchOfP.setR() 2 1 2 2
TotalCircuit.TotalCircuit(String, int) 0 1 1 1
TotalCircuit.getIsOk() 0 1 1 1
TotalCircuit.setIsOk(int) 0 1 1 1
Class OCavg OCmax WMC
ControlledDevice 1 1 2
Controller 1 1 4
CurtainOfS 2.5 7 10
Device 1 1 28
Fan 1 1 4
FanOfA 2 5 8
FanOfD 1.5 3 6
FilamentLamp 1.67 3 5
FluorescentLamp 1.33 2 4
Lamp 1 1 3
ParallelCircuit 1 1 6
SeriesCircuit 1 1 3
SwitchOfF 2.2 7 11
SwitchOfH 1.09 2 12
SwitchOfK 1.2 2 6
SwitchOfL 1 1 5
SwitchOfP 1.2 2 6
TotalCircuit 1 1 3

  1. 平均复杂度 (Avg Complexity)

    • 值：3.17
    • 理想范围：[2.0-4.0]
    • 你的平均复杂度在理想范围内，表明代码的复杂度适中，易于理解和维护。

  2. 平均深度 (Avg Depth)

    • 值：3.65
    • 理想范围：[1.0-2.2]
    • 你的平均深度高于理想范围，意味着代码的嵌套层次较深，可能会增加理解难度和维护成本。

  3. 最大深度 (Max Depth)

    • 值：9+
    • 理想范围：[3-7]
    • 我的最大深度显著高于理想范围，表明某些代码块嵌套非常深，需要考虑简化这些代码块。

  4. 最大复杂度 (Max Complexity)

    • 值：190
    • 理想范围：[2-8]
    • 我的最大复杂度远高于理想范围，提示有些部分代码非常复杂，需要重点优化这些部分以提高代码质量。

  5. 每类方法数 (Methods/Class)

    • 值：5.42
    • 理想范围：[4-16]
    • 我的每类方法数在理想范围内，表明每个类的方法数量适中。

  6. 每个方法的平均语句数 (Avg Stmts/Method)

    • 值：6.37
    • 理想范围：[6-12]
    • 我的每个方法的平均语句数在理想范围内，意味着方法的长度适中。

  7. 注释百分比 (% Comments)

    • 值：3.8
    • 理想范围：[8-20]
    • 我的注释百分比低于理想范围，建议增加注释，以提高代码的可读性和可维护性。

与之前的分析相比，这张图的指标略有不同，但总体情况类似。你的Java程序在平均复杂度、每类方法数和每个方法的平均语句数方面表现良好，但在代码深度和复杂度方面需要改进，特别是最大深度和最大复杂度，需要优先考虑重构和优化。

总结：

  • 踩坑心得：

    • 一开始就没有考虑引脚的功能，导致后期代码修修补补，很难维护和拓展。

    • 没有保持PTA与电脑上代码的一致性，有时候为了图方便直接在PTA的提交界面修改代码，改完之后却没有修改本地代码，导致两个代码之间不同步。

    • 一开始设计的时候并没有将电路类继承于设备类，而是成为了一个独立存在的父类，导致后期处理复杂电路情况时很不方便。

  • 课程建议：

    • 希望老师可以积极回复同学的疑问，虽然很多时候都是问测试点的，但是这是真的“走投无路”了才会用的方法。

  • 最后：

    8次大作业到此也就结束了，象征着本学期的学习已经来到了尾声。感谢老师们的辛苦付出，敬礼！

oop

与OOP课第三阶段总结相似的内容：

OOP课第三阶段总结

OOP课第三阶段总结 前言： 我想说的第一句是：”我感受到了设计上的极大缺陷“，从一开始，我完全就忽略了引脚的存在。因为在第二阶段中，家电模拟大作业一、二在不需要考虑引脚的情况下也可以完成。但是当来到第三次，出现了互斥开关，因为互斥开关的特殊性，它具有1、2、3三个引脚，并且连接方式多种多样，所以再

oop
7
OOP课第二阶段总结

OOP课第二阶段总结 前言 作为第二次3+1的总结，明显感受到了此次题目集越来越复杂，结合了实际的物理知识来解决现实中的电路问题。因为电路可以一直扩展下去，情况千变万化，难以像上次题目集一样找到一个呆板的做法。这次题目集，让很多人连题目都无法理解，代码也是无从下手，因为这些人根本不知道如何去设计，如

oop
0
OOP第二阶段题集总结

一.前言 知识点：考察继承和多态为多，其中还涉及迭代器的使用，在每个题集中都有一个综合性题目设计多方面知识点考试，有List类和HashMap的使用以及正则表达式的运用，并且注重考查设计，理解类与类之间的关系进行合理设计，其中也要遵循我们所学的单一职责，开闭原则，迪米特法则等。 题量：第四次题集和第

oop
1
oop课程4-6次作业小结

目录（1）前言（2）设计与分析第四次作业(答题判题程序-4)新增多选类新增填空类第五次作业(家居强电电路模拟程序-1)Element类控制设备开关#分档调速器#受控设备白炽灯#日光灯#吊扇#计算电压(家庭电路类)第六次作业(家居强电电路模拟程序-2)Element类Light类Fan类（3）采坑心得

oop
0
深入理解 C++ 中的多态与文件操作

C++ 多态 多态（Polymorphism）是面向对象编程（OOP）的核心概念之一，它允许对象在相同操作下表现出不同的行为。在 C++ 中，多态通常通过继承和虚函数来实现。 理解多态 想象一个场景，你有一个动物园，里面有各种动物，如猫、狗、鸟等。每个动物都有自己的叫声。使用面向对象编程，我们可以创

5
C++ 多级继承与多重继承：代码组织与灵活性的平衡

C++ 多级继承 多级继承是一种面向对象编程（OOP）特性，允许一个类从多个基类继承属性和方法。它使代码更易于组织和维护，并促进代码重用。 多级继承的语法 在 C++ 中，使用 : 符号来指定继承关系。多级继承的语法如下： class DerivedClass : public BaseClass1

0
7.0 Python 面向对象编程

python是一种面向对象的编程语言，面向对象编程（Object-Oriented Programming，OOP）是一种编程思想，其核心概念是“对象”。对象是指一个具有特定属性和行为的实体，而面向对象编程就是通过对这些实体进行抽象、分类、封装和继承等操作，来实现程序的结构和逻辑。在python中，我们可以通过定义类、创建实例和调用方法等方式，来实现面向对象编程的思想，从而编写出更加灵活、可扩展、

python 面向对象编程
22
[转帖]JVM 系列 - 内存区域

一、对象在JVM中的表示: OOP-Klass模型 https://www.jianshu.com/p/424a920771a3 写的很赞。 注意：OOP-Klass是hotspot的JVM实现原理，其他JVM的实现可能不一样。、 OOP表示java实例，Klass表示class。 Klass: 包

jvm 系列 内存 区域
0
Netty-介绍-1

Netty介绍和应用场景 要求 已经掌握了 主要技术构成： Java OOP 编程、 Java 多线程编程、 Java IO 编程 、 Java 网络编程、 常用的Java 设计模式(比如 观察者模式 ，命令模式，职责链模式 )、 常用的数据结构(比如 链表) Netty的介绍 1、Netty 是由

netty 介绍
58
继承,super,重写,多态,抽象,接口

继承,super,重写,多态,抽象,接口 继承 extends 用于表示两个类之间的继承关系,继承是OOP的四大特性之一,他允许一个类(称之为子类或派送类) 继承另一个类(称之为父类或基类)的变量和方法,子类可以复用父类的方法和变量,也可以添加和覆盖父类的方法和变量 extends的基本语法 使用e

super
0
# 热门排行
微软 New Bing AI 申请与使用保姆级教程（免魔法） ChatGPT API使用介绍 ChatGPT开发实战 一篇带你了解如何使用纯前端类Excel表格构建现金流量表 手把手教你玩转 Excel 数据透视表 为什么 C# 可能是最好的第一编程语言 .NET 入门到高级路线 提高工作效率的神器：基于前端表格实现Chrome Excel扩展插件 React + Springboot + Quartz，从0实现Excel报表自动化 用Echarts实现前端表格引用从属关系可视化
© PmDaddy. 2023 PmDaddy教程网 All rights reserved.