OOP最后两次作业总结

OPP最后两次作业总结
前言
两次题目集其实都是在前面的基础上进行迭代，第一次作业说实话我没花什么时间，毕竟我从写第一次PTA就是给电器使用两个接点，我从拿到题目到达到及格分只用了半天时间，然后最后又花了点时间测试几个样例，拿到了82分。然后最后一次作业嘛，我几乎是直接开摆了，总共有四个样例，我只过了三个就没管了，然后就直接交了，勉强拿到了25分，但是最后一看排名，没想到居然是99名，也是有点出乎我的意料。这大概就是我这两次作业是怎么完成的了。

设计与分析
两次作业都没怎么做设计方面的事情，就是把需求直接加到代码里面，然后遇到问题就调试几下，最后调试到样例都过了就自己在那边写几个样例进行自测，最后写的差不多了就交PTA上，没设计这回事。

踩坑心得

在写最后这次作业的时候我倒是踩了一些坑，首先就是我的线路连接方面的问题，我的线路连接函数设计比较混乱，导致从一个线路连接到另外一个线路比较难，其实大体的结构没什么问题，但是到后面出现一些新的需求的时候我就要反复修改代码了，估计这是刚开始写代码的时候几乎从来没有好好想过怎么连接，就是直接上手开练的结果，导致最后就是反复修改，改的自己都不知道怎么运行的逻辑，然后在混乱的体系中尝试理解，利用反复的调试来解决错误，最后虽然也能获得一个正确的结构，但是说实话挺像在混日子的，
我的线路代码定义在四个类中,这是类设计的核心部分

Line(抽象电路类)
class Line {
public double resistance = 0;
public double inputVoltage = 0;
public double inVoltage = 0;
public double outVoltage = 0;
public double electricity = 0;
// public TreeMap <String, ArrayList > route = new TreeMap<>();
//public TreeMap <String, Double> PointVoltage = new TreeMap<>();
}

Circuit（串联电路类）

class Circuits extends Line{
public String tick;
public Boolean mainState = false;
public ArrayList circuits = new ArrayList<>();
public double electricity = 0;
public boolean judgeShortCircle(){
boolean state = false;
if(this.resistance == 0){
state = true;
}
return state;
}
}

ParallelConnection(并联电路类)

class ParallelConnection extends Line{
public double resistance = -1;
public String tick;
public ArrayList parallelConnection = new ArrayList<>();
}

ConnectionManager(计算线路属性的函数)
class ConnectionManager {

public static double getComponentResistance(Component component, Map<Component, Device> devices, TreeMap<String, Circuits> circuits, TreeMap<String, ParallelConnection> parallelConnections) {
    double resistance = 0;
    if (component.type.equals("T")) {
        resistance = circuits.get(component.tick).resistance;
    } else if (component.type.equals("M")) {
        resistance = parallelConnections.get(component.tick).resistance;
    } else {
        resistance = devices.get(component).getResistance();
    }
    return resistance;
}

public static void chargeOpenParallelConnection(Map<Component, Device> devices, ParallelConnection parallelConnection, TreeMap<String, ParallelConnection> parallelConnections, TreeMap<String, Circuits> circuits) {
    for (Circuits c : parallelConnection.parallelConnection) {

// if(parallelConnection.inputVoltage == -1){
// parallelConnection.inputVoltage = 0;
// }
if (c.resistance == -1) {
c.inVoltage = parallelConnection.inVoltage;
chargeOpenCircuits(devices, c, parallelConnections, circuits);
} else {
c.inVoltage = parallelConnection.inVoltage;
c.inputVoltage = parallelConnection.inputVoltage;
chargeCircuits(devices, c, parallelConnections, circuits);
}
}
}

public static void chargeOpenCircuits(Map<Component, Device> devices, Circuits circuit, TreeMap<String, ParallelConnection> parallelConnections, TreeMap<String, Circuits> circuits) {
    double voltage = circuit.inVoltage;
    for (Component c : circuit.circuits) {
        if (c.type.equals("M")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                parallelConnections.get(c.tick).inVoltage = voltage;
                chargeOpenParallelConnection(devices, parallelConnections.get(c.tick), parallelConnections, circuits);
            } else {
                parallelConnections.get(c.tick).inVoltage = voltage;
                parallelConnections.get(c.tick).outVoltage = voltage;
                chargeOpenParallelConnection(devices, parallelConnections.get(c.tick), parallelConnections, circuits);
            }
        } else if (c.type.equals("T")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                circuits.get(c.tick).inVoltage = voltage;
                chargeOpenCircuits(devices, circuits.get(c.tick), parallelConnections, circuits);
            } else {
                circuits.get(c.tick).inVoltage = voltage;
                circuits.get(c.tick).outVoltage = voltage;
                chargeOpenCircuits(devices, circuits.get(c.tick), parallelConnections, circuits);
            }
        } else if (devices.get(c).ChargeCircuitsState) {
            continue;
        } else if (c.type.equals("F") || c.type.equals("L")) {
            devices.get(c).setInputVoltage(circuit.inputVoltage);
            circuit.inputVoltage = devices.get(c).getOutputVoltage();
            devices.get(c).setOutVoltage(voltage);
        }
        if (!c.type.equals("T") && !c.type.equals("M")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                devices.get(c).setInVoltage(voltage);
                devices.get(c).setChargeCircuitsState(true);
                break;
            } else {
                devices.get(c).setInVoltage(voltage);
                devices.get(c).setOutVoltage(voltage);
                devices.get(c).setChargeCircuitsState(true);
            }
        }//这里重复了两次
    }
}

public static void chargeCircuits(Map<Component, Device> devices, Circuits circuit, TreeMap<String, ParallelConnection> parallelConnections, TreeMap<String, Circuits> circuits) {
    double voltage = circuit.inVoltage;
    for (Component c : circuit.circuits) {
        if (c.type.equals("M")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                parallelConnections.get(c.tick).inVoltage = voltage;
                parallelConnections.get(c.tick).inputVoltage = 0;
                chargeOpenParallelConnection(devices, parallelConnections.get(c.tick), parallelConnections, circuits);
            } else {
                parallelConnections.get(c.tick).inVoltage = voltage;
                parallelConnections.get(c.tick).inputVoltage = circuit.inputVoltage * (parallelConnections.get(c.tick).resistance / circuit.resistance);
                voltage -= parallelConnections.get(c.tick).inputVoltage;
                parallelConnections.get(c.tick).outVoltage = voltage;
                chargeParallelConnection(devices, parallelConnections.get(c.tick), parallelConnections, circuits);
            }
        } else if (c.type.equals("T")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                circuits.get(c.tick).inVoltage = voltage;
                circuits.get(c.tick).inputVoltage = 0;
                chargeOpenCircuits(devices, circuits.get(c.tick), parallelConnections, circuits);
            } else {
                circuits.get(c.tick).inVoltage = voltage;
                circuits.get(c.tick).inputVoltage = circuit.inputVoltage * (circuits.get(c.tick).resistance / circuit.resistance);
                voltage -= circuits.get(c.tick).inputVoltage;
                circuits.get(c.tick).outVoltage = voltage;
                chargeCircuits(devices, circuits.get(c.tick), parallelConnections, circuits);
            }
        } else if (devices.get(c).ChargeCircuitsState) {
            continue;
        } else if (c.type.equals("F") || c.type.equals("L")) {
            devices.get(c).setInputVoltage(circuit.inputVoltage);
            circuit.inputVoltage = devices.get(c).getOutputVoltage();
            devices.get(c).setOutVoltage(voltage);
        } else {
            if(Math.abs(circuit.resistance + 1.0) < 0.0001){
                devices.get(c).setInputVoltage(0);
            }
            else {
                devices.get(c).setInputVoltage(circuit.inputVoltage * (devices.get(c).getResistance() / circuit.resistance));//注意这里每个电路循环了两遍
            }
        }
        if (!c.type.equals("T") && !c.type.equals("M")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                devices.get(c).setInVoltage(voltage);
                devices.get(c).setChargeCircuitsState(true);
                break;
            } else {
                devices.get(c).setInVoltage(voltage);
                voltage -= devices.get(c).inputVoltage;
                devices.get(c).setOutVoltage(voltage);
                devices.get(c).setChargeCircuitsState(true);
            }
        }//这里重复了两次
    }
    circuit.outVoltage = voltage;
}//为串联电路充能

public static void chargeParallelConnection(Map<Component, Device> devices, ParallelConnection parallelConnection, TreeMap<String, ParallelConnection> parallelConnections, TreeMap<String, Circuits> circuits) {
    for (Circuits c : parallelConnection.parallelConnection) {

// if(c.resistance != -1) {
// if (parallelConnection.inputVoltage == -1) {
// parallelConnection.inputVoltage = 0;
// }//不知道有什么用
c.inVoltage = parallelConnection.inVoltage;
if(c.resistance != -1) {
c.inputVoltage = parallelConnection.inputVoltage;
}
chargeCircuits(devices, c, parallelConnections, circuits);
// }
}
}//为并联电路充能

public static void GenerateCurcuitsEletricity(Map<Component, Device> devices, Circuits circuit, TreeMap<String, ParallelConnection> parallelConnections, TreeMap<String, Circuits> circuits) {
    double eletricity = circuit.inputVoltage / circuit.resistance;
    for (Component c : circuit.circuits) {
        if (c.type.equals("M")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                parallelConnections.get(c.tick).electricity = -1;
                GenerateParallelEletricity(devices, parallelConnections.get(c.tick), parallelConnections, circuits);
            } else {
                GenerateParallelEletricity(devices, parallelConnections.get(c.tick), parallelConnections, circuits);
            }
        } else if (c.type.equals("T")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                circuits.get(c.tick).electricity = -1;
                GenerateCurcuitsEletricity(devices, circuits.get(c.tick), parallelConnections, circuits);
            } else {
                GenerateCurcuitsEletricity(devices, circuits.get(c.tick), parallelConnections, circuits);
            }
        } else if (devices.get(c).isGenerateState()) {
            continue;
        } else {
            devices.get(c).setInputVoltage(circuit.inputVoltage * (devices.get(c).getResistance() / circuit.resistance));//注意这里每个电路循环了两遍
        }
        if (!c.type.equals("T") && !c.type.equals("M")) {
            if (getComponentResistance(c, devices, circuits, parallelConnections) == -1) {
                devices.get(c).setGenerateState(true);
                break;
            } else {
                devices.get(c).setEletricity(eletricity);
                devices.get(c).setGenerateState(true);
            }
        }//这里重复了两次
    }
}
public static void GenerateParallelEletricity(Map<Component, Device> devices,ParallelConnection parallelConnection,TreeMap<String, ParallelConnection> parallelConnections,TreeMap<String, Circuits> circuits){
    for (Circuits c : parallelConnection.parallelConnection) {

// if (parallelConnection.electricity == -1) {
// parallelConnection.electricity = 0;
// }//不知道有什么用
if(c.inputVoltage == -1) {
continue;
}
else if(c.inputVoltage == 0){
parallelConnection.electricity = 0;
break;
}
c.electricity = c.inputVoltage / c.resistance;
GenerateCurcuitsEletricity(devices, c, parallelConnections, circuits);
}
}
}

(在此附上类图)

对本学期本门课程的改进建议及意见
我感觉今年的课程有点虎头鼠尾了，刚开始上的各种面向对象原则都是必要的东西，但是到后面讲的那些原则多数不能直接了解真正的用法，不使用也没有太大关系，说实话，我这学期写的代码确实多数是垃圾代码，老师并没有真正教会我太多，倒是给了我几个教训，
1.那就是多数知识都是从小圈子里面学习出来的，周围人什么样自己常常就会什么样，就像PTA里排名靠前的总是那一堆人，我嘛其实也不怎么样，虽然我给自己的要求比较低，每次PTA及格就行，但是就是发现就算这样我也超过一半人了，也是很奇怪，我总觉得自己是比较开摆的人，这学期线代都没考及格，但是这门课程确超过一半的人了，大概是我宿舍的其他三个人大部分PTA都是满分把我逼上去的吧，。
2.原来学习成果确实不是和学习时间成正比，只是要养成一个习惯，每天学多久，玩多久，而且要以一种沟通的心态找到和自己一起学的人，这才算是有效的学习，自己一个人在图书馆学是造不出任何东西的，沟通始终是必要的，我的线代就是这么挂的。
3.每次上完课记得回课，这样才是有效率的学习，这学期我自己找了一个音乐学院的研究生教我美声，我发现这才是主动学习，从小学到现在我所接受的教育都是被逼着去学的，我也是才明白有一门爱好的重要性，还有打游戏确实有点浪费时间，毕竟现在的游戏套路就那么几种，不同类型和风格的游戏水平总是迭代上升的，那么每隔两个月玩七天貌似是更加合理的选择。
4.然后就是刷视频的问题，现在的自媒体也总是在批评一些有的没的东西，不管怎么说都是套路化的，每个自媒体博主都像是一个小吃店，跟你讲一些能够让你高兴但却是套路化的东西，看了多久都学不会做早餐，最多也只是供我们评价一下早餐的形状和样式，并不能教我多少东西，所以，除了聊天还是少刷视频吧

）前言：总结两次题目集的题目的知识点、题量、难度等情况
（2）设计与分析：重点对题目的提交源码进行分析，可参考SourceMontor的生成报表内容以及PowerDesigner的相应类图，要有相应的解释和心得（做到有图有真相），本次Blog必须分析题目集1~3的最后一题
（3）采坑心得：对源码的提交过程中出现的问题及心得进行总结，务必做到详实，拿数据、源码及测试结果说话，切忌假大空
（4）改进建议：对相应题目的编码改进给出自己的见解，做到可持续改进
（5）总结：对本阶段两次题目集的综合性总结，学到了什么，哪些地方需要进一步学习及研究
（6）最后一段，给出对本学期本门课程的改进建议及意见（难度大就不要提了）。