OOP7-8次作业

OOP7-8次作业

一.前言：

1.第七次PTA：

根据之前的内容在，之前的内容上进行修改和扩增。

①题目理解：

1.增加了互斥开关，互斥开关的难点在于他可以转换每条路的通路和断路，而且你切换的两个引脚他的电阻也是不一样的，这就增加了你获得电路电阻的难度。

2.对于在电路的获得这个互斥开关也是需要更改的。因为我获得每个用电电器的方法是不需要查找引脚的，但是互斥开关开始，他是需要根据互斥开关来去找到他的对应的引脚对应的串联位置。所以我的输入获取方式的代码也得更改。

3.增加了多个串联的并联，然后这样的电路，也存在一些特殊情况，比如说他可能会短路，他也可能因为互斥开关的转换造成一条串连电路的短路。所以我的并联类需要更改为串联数组，对于他的获得也需要更改。

4.增加了受控窗帘这个用电器，他的难点在于我们要根据能发光的用电器来算得他的总光亮，来算出受控窗帘打开的百分比，然后输出出来。

5.他的输出顺序是根据字符串得直接比较，而不是比数字。例如D11比D2更先输出，所以这个地方还是比较坑的点。

6.然后如何去赋值正确的电压，和其对应的电阻，的顺序其实也是需要考虑的。这次迭代我们是通过赋值非干路的串联电路的电阻，然后赋值并联电路的电阻，然后赋值干路上的电阻，然后赋值干路上的电压，然后最后赋值并联电路每个串联的电压，然后每个用电器的电压。在下一次迭代中，这样会出现一个文体，但是本次迭代还是能通过测试的。

②知识点：

具体的知识点倒是没啥更新的，主要是思维逻完成一个项目的能力。

一·用正则表达式的匹配（split函数的使用）；

二·如何Java中创建一个二维数组，或者一维数组；

三·Java中如何将int型转化成String类型（valueOf，Integer.paseInt）；

③题量：

正常；

④难度：

正常；

2.第八次PTA:

有一说一，最后一次了，有点小激动，哈哈哈。

①题目理解：

这次的更改会有一点多。

1.增加了二极管，这个电路元件，然后这个电路元件是根据电流流过的方向和其引脚的不同来判断是不是相同的，如果相同则当导线，如果不同则被判断为为断路，电流走不通。这就对串联的判断增加了许多情况。

2.输出了引脚的电压显示，这样就增加了大量的工作量。因为之前的测试都与引脚无关，但是本次的迭代，包括了引脚，所以得全部修改，然后如何判断他的引脚是12还是21，还有互斥开关的123引脚还是个问题。所以我规定12为正的状态21为负的状态，123为正的状态，321为负的状态，然后先获得两端引脚的值，不管他是12还是21，最后输出的时候查看一下状态，看看要不要更改，这样就可以输出正确了。然后还有一个方面，当前面的这条路是断路但是最后一个用电器的右引脚是有电压的，这样仅仅通过简单赋值是不可取的。然后你还有回去检查一下干路的情况，这个点也比较坑。

3.还有几个电流过大的判断，我们还是把各个串联电路和并联电路看成一个用电器，然后去判断他流过的电流情况，如果这个电路是断路那么我们根本就不用判断他里面的用电器，这样能节省点，运行的时间。

4.然后这次增加了串联中的并联，那么串联中有并联，并联中有串联，这样的循环就形成了闭环，这就要求你不能只找到串联或者是并联去赋值，这样的赋值应该是一个递归的操作。这样我们就会有一个闭环，在串联电路中我们会有并联数组，串联数组，用电器，和控制器。在并联电路中，我们只需要有串联电路数组，一切都可以在获得并联的时候，去用并联类的方法，这样就会形成一个递归。

5.然后是整个电路的如果他是一个断路的状态还会有输出语句，这样我们还要判断整个干路串联是不是都是短路的，是的话就输出。

②知识点：

具体的知识点倒是没啥更新的，主要是思维逻完成一个项目的能力。

一·用正则表达式的匹配（split函数的使用）；

二·如何Java中创建一个二维数组，或者一维数组；

三·Java中如何将int型转化成String类型（valueOf，Integer.paseInt）；

③题量：

我觉得正常，就是大概每个星期自己做，差不多一个星期可以做完，但是有时候一直有的点过不去，就一直卡着；

④难度：

不正常；

二.内容：

1.第七次PTA：

①题目简介：

1.增加了互斥开关和受控窗帘；

2.本次迭代考虑多个并联电路串联在一起的情况。

本题考虑一条串联电路中包含其他串联电路的情况。例如：

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

本例中T1\T2两条串联电路T3的一个部分，本题考虑这种类型的输入

3.本次迭代模拟一种受控窗帘：

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

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

②内容实现：

1.对于每个对象数组，你构造对象是实现自增的方式。

   public void setTandemDevices(TandemDevice tandemDevice) {
        if (this.tandemDevices == null) {
            this.tandemDevices = new TandemDevice[1];
        }
        this.tandemDevices[hh4] = tandemDevice;
        hh4++;
        this.tandemDevices = Arrays.copyOf(this.tandemDevices, this.tandemDevices.length + 1);
    }

这样的写法，当你后期判断这个数组有没有时，直接就能判断，不存在空者的数组但是被调用或者使用了，更加自动。

2.面对互斥开关的三个引脚，然后我对他的获取方式进行修改。

  for (int i = 0; i < get77.length; i++) {
                    if (get77[i].length() > 3) {
                        numc++;
                    }
                }
                get88 = new String[numc];
                for (int i = 0, j = 0; i < get77.length; i++) {
                    if (get77[i].length() > 3) {
                        get88[j] = get77[i];
                        j++;
                    }
                }
                get = new String[get88.length / 2];
                for (int i = 0, j = 0; i < get88.length; i = i + 2) {
                    if(get88[i].charAt(0)=='H'){
                        String[] temp=get88[i].split("-");
                        if(temp[1].equals("1")){
                            get[j]=get88[i+1];
                        }else{
                            get[j]=get88[i];
                        }
                    }else {
                        get[j] = get88[i];
                    }

                    j++;
                }

因为每个互斥开关的两个引脚都是写在一起的，当我们判断了一个引角这个对象已经存在在，然后就不用在新建一个对象了。这样的写法可以实现，题目的要求。

2.然后我们要判断互斥开关的引脚到底连在那条路上。

   if (((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).number.equals("2")) {
                            if (((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice2.deviceControlings != null) {
                                for (int z = 0; z < ((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice2.deviceControlings.length - 1; z++) {
                                    if (((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice2.deviceControlings[z] instanceof Switch && ((Switch) ((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice2.deviceControlings[z]).state == 0) {
                                        target2++;//表示在互斥开关，有用一端有断开的开关，加数量
                                        break;
                                    }
                                }
                            }
                        }
                        if (((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).number.equals("3")) {
                            if (((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice3.deviceControlings != null) {
                                for (int z = 0; z < ((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice3.deviceControlings.length - 1; z++) {
                                    if (((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice3.deviceControlings[z] instanceof Switch && ((Switch) ((MutexSwitch) parallelDevice[j].tandemDevices[i].deviceControlleds[k]).tandemDevice3.deviceControlings[z]).state == 0) {
                                        target2++;//表示在互斥开关，有用一端有断开的开关
                                        break;
                                    }
                                }
                            }

我在互斥开关加了两个串联对象，放2，3引脚的串联位置，然后判断这个电路是不是在这个引脚里，那么通过上述代码可以实现。

3.在窗帘上增加了亮度这个成员变量，记录最后获得的总亮度。

 if(voltage<50){
            System.out.println("@S"+name+":"+100+"%");
        }
        else{
            if(lightness>=0&&lightness<50){
                System.out.println("@S"+name+":"+100+"%");
            } else if (lightness>=50&&lightness<100) {
                System.out.println("@S"+name+":"+80+"%");
            } else if (lightness>=100&&lightness<200) {
                System.out.println("@S"+name+":"+60+"%");
            } else if (lightness>=200&&lightness<300) {
                System.out.println("@S"+name+":"+40+"%");
            }else if(lightness>=300&&lightness<400){
                System.out.println("@S"+name+":"+20+"%");
            } else if(lightness>=400) {
                System.out.println("@S"+name+":"+0+"%");
            }
        }

4.还有在输出时，我们是根据字符串来排序的，但是我们已经把字符串改成了数字，所以需要一些改变来，重新排序。

 if (deviceControlleds != null) {


                Curtain[] ct = new Curtain[1];
                int num_ct = 0;
                for (int i = 0; i < deviceControlleds.length - 1; i++) {
                    if (deviceControlleds[i] instanceof Curtain) {
                        ct[num_ct] = (Curtain) deviceControlleds[i];
                        ct = Arrays.copyOf(ct, ct.length + 1);
                        num_ct++;
                    }
                }
                for (int i = 0; i < ct.length - 1 - 1; i++) {
                    for (int k = 0; k < ct.length - i - 1 - 1; k++) {
                        if (String.valueOf(ct[k].name).compareTo(String.valueOf(ct[k + 1].name)) > 0) {
                            Curtain temp = ct[k];
                            ct[k] = ct[k + 1];
                            ct[k + 1] = temp;
                        }
                    }
                }
                for (int i = 0; i < ct.length - 1; i++) {
                    ct[i].setLightness(this.lightness);
                    ct[i].show();
                }
            }

先判断，用电器数组中是否有有用电器；

在从用电器数组中提取出窗帘，放到一个新的窗帘数组中去；

然后用冒泡排序，把窗帘的名字转换成字符串，用compareTo函数进行比较；

然后附上每个亮度，然后输出。

③踩坑心得：

1.忽略了没有用电器，或者是控制器，或者是并联电路，所以当我去查找他们的时候我要先判断是不是存在这样一个用电器，然后再去判断，这样的一个方式要一直用。

2.当我们去查找一个用电器的时候，可能会从他的并联中找他的串联，再从串联找他的用电器，这样经过多层循环之后，可能会一不小心少了一个修饰符，这样就会查找出现问题。

2.第八次PTA:

①题目简介：

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

2.如果电路出现无穷大的电流造成短路，所有元器件信息不输出，仅输出提示“short circuit error”

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

②内容实现：

1.对于他在每个引脚都要输出对应的电压，我们要先调整他的状态，判断他是正的还是逆的。

if (get88[i].charAt(0) == 'R') {  //日光灯
                        String[] get1 = get88[i].split("-");
                        String[] zz = get1[0].split("R");
                        if(Integer.parseInt(get[1])==1){
                            int target_pdshunxu=0;
                            if(deviceControlleds!=null){
                                for(int b=0;b<deviceControlleds.length-1;b++){
                                    if(deviceControlleds[b] instanceof fluorescentLamp &&((fluorescentLamp) deviceControlleds[b]).name==Integer.parseInt(zz[1])){
                                        target_pdshunxu=1;//已经存在了
                                    }
                                }
                            }
                            if(target_pdshunxu==0){//判断为null
                                fluorescentLamp1 = new fluorescentLamp(Integer.parseInt(zz[1]));
                                fluorescentLamp1.setShunorni(1);
                                if(deviceControlleds==null){
                                    deviceControlleds=new deviceControlled[1];
                                }
                                deviceControlleds[num] = fluorescentLamp1;
                                num++;
                                deviceControlleds = Arrays.copyOf(deviceControlleds, deviceControlleds.length + 1);
                                tandemDevices[number].setListChildren(fluorescentLamp1);
                                tandemDevices[number].setDeviceControlleds(fluorescentLamp1);
                            }
                        }
                        if(Integer.parseInt(get[1])==2){
                            int target_pdshunxu=0;
                            if(deviceControlleds!=null){
                                for(int b=0;b<deviceControlleds.length-1;b++){
                                    if(deviceControlleds[b] instanceof fluorescentLamp&&((fluorescentLamp) deviceControlleds[b]).name==Integer.parseInt(zz[1])){
                                        target_pdshunxu=1;//已经存在了
                                    }
                                }
                            }
                            if(target_pdshunxu==0){//判断为null
                                fluorescentLamp1 = new fluorescentLamp(Integer.parseInt(zz[1]));
                                fluorescentLamp1.setShunorni(0);
                                if(deviceControlleds==null){
                                    deviceControlleds=new deviceControlled[1];
                                }
                                deviceControlleds[num] = fluorescentLamp1;
                                num++;
                                deviceControlleds = Arrays.copyOf(deviceControlleds, deviceControlleds.length + 1);
                                tandemDevices[number].setListChildren(fluorescentLamp1);
                                tandemDevices[number].setDeviceControlleds(fluorescentLamp1);
                            }
                        }

2.然后对每个串联都增加了一个状态的变量，记录他这个串联是属于短路还是断路还是通路，

   for(int i=0;i<deviceControlings.length-1;i++) {
                if(deviceControlings[i] instanceof Diode && ((Diode) deviceControlings[i]).shunorni==0){//他是逆电路，则他为断路，电阻为零
                   target_0=1;
                }
            }

            for (int i = 0; i < deviceControlings.length - 1; i++) {
                if (deviceControlings[i] instanceof Switch && ((Switch) deviceControlings[i]).state == 0) { //开关断开
                    target_0=1;
                }
            }

一般是先判断是否存在二极管，二极管是否顺序；

在判断开关是否断开，在判断互斥开关是否连到这个线路上来；

在判断是否存在用电器，这样就可以判断他是通路，还是断路，还是短路了；

③踩坑心得：

1.他连接gnd的引脚还是有电压的，所以我们还要去找寻一遍他在gnd所在位置有哪些引脚；

2.为了让他实现递归，当我们要调用到其他串联或者并联电路中，直接调用他的方法，然后要返回他的状态，还有他的电阻。

3.在最后的判断中我们还要考虑他是不是整体短路。

三.总结：

一.要懂得基本的工具，和相关函数；

二.要明白代码的逻辑，熟悉idea调试的方法；