oo第一次博客

最新推荐文章于 2025-12-19 15:39:34 发布
转载 最新推荐文章于 2025-12-19 15:39:34 发布 · 93 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/wevolf/p/8694163.html
文章标签：

#java #c/c++

第一次作业，正则表达式

本周我们迎来第一项任务，java面向对象之实现对一串字符的匹配以及构造出计算的多项式，最终得出计算的结果。简而言之，可以用以下的要求来看题目：

  1. 输入的多项式字符串中不得出现非法字符
  2. 多项式的输入型式，{多项式 1}+{多项 式 2}-…… +{多项式 n}，多项式内部格式为{(c1,n1),(c2,n2),…,(cm,nm)}
  3. 其中多项式的输入个数不得超过20个，同时多项式的内部数据的对数不会超过50对
  4. 输入中的所有空格应该被过滤掉
  5. 在本次编程过中， 对 于数(c,n)，c为系数， 有-10^6<c<10^6（即 c前面可以 有‘ -’） , n为幂， 有 0<=n<10^6，即 c最大为 6位十进制整数， 位十进制整数， n最大为 6位十进 制整数。所有均可能出现前导 制整数。所有均可能出现前导 0，但 c和 n除去符号位之外的长度分别不超过 6和 6。
  6. 对于所有的不合法的输入，程序要给出响应，即输出为“ERROR”

那我们社会人应该怎么解决这道题目呢？

如果按照面向流程的思路设计，我们以c语言为例，首先是判断输入是否合法，采用的方法是对输入进行输入流判断，然后就是一路遍历，取出合法的多项式，然后构成多项式，最后进行计算，而作为初入面向对象的小白来说，第一次作业就用面向对象来写，着实有些困难，所以在下还是用一个C语言的形式来实现这个作业了，那么我是具体如何实现的呢？

首先是正则表达式：对于转换可以大家可以自行搜索，主要讲一下正则表达式的匹配的吧，对于该问题，我是这样考虑的，从整体的多项式的结构来看，我们分析其中的字符特点，有以下几个特点：

  1. 对于输入字符串的第一个和最后一个字符，只能是‘{’和‘}‘，当然这里是过滤了开头的字符，因为那本身并没有太大意义
  2. 统计输入字符串，对于合法的输入，‘{’的个数一定等于‘}’的个数，一定等于“\\{(\\([+-]?[0-9]{1,6},(([+]?[0-9]{1,6})|([-]?[0]{1,6}))\\),){0,49}\\([+-]?[0-9]{1,6},(([+]?[0-9]{1,6})|([-]?[0]{1,6}))\\)\\}”的个数，且一定比”\\}[+-]\\{“多一个，所以我们采用统计这几类正则表达式的个数来判断输入字符串是否合法
  3. 在统计的过程中对输入的个数进行判断，
  4. 最后我们提取出每一个多项式，并在多项式中提取出数字
  5. 根据之前我们在分段时候采用的”\\}[+-]\\{”,将计算符号记录下来，最后进行计算，

关于正则匹配的代码

public static void find(String All_2, String str_num) {
        Pattern p_2 = Pattern.compile(str_num);
        Matcher m_2 = p_2.matcher(All_2);
        while(m_2.find() && result4==1) {
            formula(big, m_2.group(), no_5);
            big++;
        }
    }

这里ALL_2,表示输入的字符串，str_num表示多项式的正则表达式，find()函数就是找出符合条件的多项式，在find()内部调用formula的作用是分析多项式，取出数字，为了计算多项式的个数我们采用了m.find()方法，而不是matches(),是正则表达式的完全匹配，而find()是包含匹配，所以能过找到多个不同的符合条件的式子，其实对于这一过程使用split也可以达到同样的效果。之后的计算以及输出过程就不做过多的叙述了。

 oo第二次作业，傻瓜电梯

本周我们完成的任务是傻瓜电梯的调度，对于那十分十分详细的指导书，我感觉想要说明白题目要求，是做不到的，所以就把指导书贴出来给大家看了，，由于在下还不会网页制作，只能通过百度网盘了，https://pan.baidu.com/s/12KLXnQa9ifh1hZQrvqhjAw/pdf争取下次用网页吧，虽然不知道什么时候才能学会。

看完题目我们开始分析吧，

从最直接的角度分析就是请求与调度的关系，直接点就是，发出请求，然后处理请求，将所有合法请求过程构成请求队列，调度器处理一个请求就是根据当前电梯状态发出一条指令，然后电梯运行该条指令，然后更新电梯的状态，然后返回状态只调度器，直到执行完最后一条指令。所以按照思想构造出五个类，但这次作业，在下并没有完全按照要求写，虽然是五个类，但是五个类的作用并不是完全按给出的建议。首先说一下几个类的功能：

  1. 输入我们使用主类，虽然输入是来自电梯类与楼层类，但是作为两处输入太过于麻烦，所以我们使用主类输入
  2. W_legal类，该类作为对于输入的第一层判断，也就是简单的过滤一些不合法输入
  3. Demand类，该类也是作为对于输入的判断，将所有不合法的输入过滤，得到是正确的请求队列
  4. Scheduler类，该类就调度器类，在该类中判断是否是同质请求，同时时间与队列是该类的关键的两个属性，时间用于判断当前类的请求时间与当前时间的大小，请求队列用于判断是否执行结束
  5. Elevator类，该类就是电梯类，接收来自调度器的指令，然后执行该指令，该类中的方法change()意思就是执行指令，然后改变电梯的运行状态，然后返回状态给调度类

对于该想法，本来我也觉得天衣无缝，只可惜还是有漏网之鱼，先列出自己的bug吧：

  1. 对于输入，我依旧采用了第一次作业方法，对输入使用find(),错误……，导致只要存在符合条件的输入就会执行，而忽略了必须是完全匹配的条件
  2. 对于数字的判断，题目的要求是4字节的整数，由于在java中是不存在unsigned类型的数据类型的，也就意味着，我们的数字最大位2^32-1，而不是2^31-1，所有数据类型要是long类型，我都是这么写的，但是还是错了，那么错误在哪里呢？本来在使用下面的这个方法时要注意一点时，一定要是有try catch，除非你事先确定了数据的位数
  3. max = Long.parseLong("4294967295");

     

对于自己想法的优化：

  1. 最需要优化的地方当然是输入，所以第三次作业在下重写写了一个输入，具体见第三次作业，
  2. 如果还有什么要优化的话那就是代码风格吧

为了纪念自己第一次使用面向对象的方法来实现这个作业，容我贴一点核心代码

request_new.request_old = legal_1.num;
        request_new.deal();  //得到一个队列，队列中是按时间顺序的请求都是合法请求
        sche.request_n = request_new.request1;
        sche.fetch();
        while(sche.request_n[sche.i][0]!=0) {
            sche.state_c = elev.state;
            sche.stop_time = elev.st_time;
            sche.deal_t();
            elev.move = sche.instr_o; elev.change(); sche.i++; }

 oo第三次作业，电梯进化

在上一周完成的基础上，大家觉得这电梯是不是有点low啊，现在都智能化了，哪还有这么蠢的电梯啊，所以我们要让电梯的调度智能化，怎么个智能化呢？我们这里也只是简单的考虑以下捎带问题，所谓捎带，就是当我在电梯去往目的地的途中，按下一个可以在途中解决的按钮，那么这次请求就可以被捎带了，具体怎么说呢？主要以下说明：

  1. (e.sta = UP→10>=e.n>e.e_n) || (e.sta = DOWN1<=e.n<e.e_n)1 注释：本段所述的可捎带条件可以这样理解：①电梯状态向上运行时，发出向上请求的楼层处于当前楼层和10层之间；②电梯状态向下运行时，发出向下请求的楼层处于当前楼层和1层之间。
  2. 对于任意一个楼层请求r=(FR, n, dir, t)，如果电梯当前是运动状态，则顺路捎带请求一定有： (r.dir=e.sta) && ((r.dir=UP(r.n <= e.n)&&(r.n>e.e_n)) || (r.dir=DOWN(r.n>=e.n)&&(r.n<e.e_n))) 注释：本段所述的可捎带条件可以这样理解：电梯状态向上或向下运行时，新楼层请求的运动方向与当前方向一致，而且新请求发生的楼层在当前所处楼层和目标楼层之间。
  3. 对于任意一个电梯内运行请求r=(ER,n,t)，如果是电梯当前运动状态下的顺路捎带请求，则一定有： (e.sta=UP(10=>r.n > e.e_n)) || (e.sta=DOWN (1<=r.n<e.e_n)) 注释：本段所述的可捎带状态可以这样理解：电梯内请求的目标楼层在电梯的前进方向上
  4. 对于e.sta = STILL状态分为2种情况。一是在电梯处于停留状态（WFS状态），此种情况没有“顺路捎带”请求，因为此时请求队列为空；（注意STILL状态仅用于输出表达，输入只有UP/DOWN两个状态）
  5. 可捎带请求的条件是，该请求时非同质请求

 当时我看的时一脸懵逼啊，可谓是一点思路都没有。现在才发现，当老师也不容易啊，写完了讲不清…………

待我慢慢道来，我们分为以下几步； 

如何解决捎带问题

我们可以将捎带分为两类：

  1. 第一类，在电梯途中的电梯外的请求，该请求必须在电梯的当前楼层与目标楼层之间，且方向与电梯运动方向相同
  2. 第二类，电梯内的请求，这一类请求意味着只要请求在电梯当前楼层之外，并且方向与运动方向相同，都可以捎带

那么如何捎带了，相信大家到这时思路都差不多了，构建捎带队列，而捎带队列的构建，小编我是想了整整一晚上啊，硬是没开始写代码。当时构建的方法主要有两种想法

  1. 按照时间构建捎带队列，将请求队列中符合稍带条件的请求按时间直接装入捎带队列，执行时按楼层执行，这样就不可避免的在执行的时候需要遍历一遍捎带队列，找出最接近的楼层捎带，更多的细节在于捎带请求完成后需要清空这一条捎带请求，需要将捎带队列改变，又会构成麻烦
  2. 按照楼层直接存储捎带队列，由于捎带有一个特点，那就是捎带会沿着电梯前进方向执行，举例来说，从一楼到十楼的过程中，被捎带的请求一定是从中间楼层，且方向向上的请求，或者电梯内请求。按照这种方式存储电梯也会带来麻烦，那就是同一楼层不止一条请求，且同一楼层的请求要按照输入的顺序输出，也就意味这在楼层中的请求也需要排序，不过相对于第一种，这个时间就不算什么了，所以我们在调度器中构建三维数组表示捎带请求队列

这里给出上行途中电梯内请求的捎带的例子：

 

if(this.request_n[k][0] > this.station[0] && this.pr_instr[0]>this.station[0] && this.request_n[k][2]==2 && this.request_n[k][4]==0) {
                    for(floor=this.station[0];floor < this.request_n[k][0];floor++) {
                        if(this.on_way[floor][0][0]!=0) {
                            arrive++;
                        }
                        arrive+=0.5;
                    }
                    //计算出从当前楼层到队列中一层的时间
                    if(this.occupy[(int) this.request_n[k][0]][1]!=0 && (arrive+this.stop_time)>this.request_n[k][1])  //表示该层楼电梯内的按钮已经被占用
 { this.request_n[k][4] = 1; System.out.printf("#SAME"); output2(this.request_n[k]); } /*import*/ else if((arrive+this.stop_time) > this.request_n[k][1] && this.request_n[k][4]==0) { //判断时间问题，运行时有没有已经到达这一层 chose = 0; while(this.on_way[(int) this.request_n[k][0]][chose][0]!=0) { //表示按钮还没有被按，可以捎带,不是同质请求 chose++; } if(chose==1){ //如果改楼层有多条请求被捎带，按照输入顺序排好顺序 if((k+1)<this.on_way[(int) this.request_n[k][0]][0][4]) { temp = this.on_way[(int) this.request_n[k][0]][0]; this.on_way[(int) this.request_n[k][0]][0] = this.request_n[k]; this.on_way[(int) this.request_n[k][0]][chose] = temp; } else { this.on_way[(int) this.request_n[k][0]][chose] = this.request_n[k];//表示向上运行的电梯内请求捎带  } } else{ this.on_way[(int) this.request_n[k][0]][chose] = this.request_n[k];//表示向上运行的电梯内请求捎带  } if(this.occupy[(int) this.request_n[k][0]][2]==0 || this.occupy[(int) this.request_n[k][0]][3]==0) { j++; } this.occupy[(int) this.request_n[k][0]][1]=1; //表示电梯内的按钮被按下 this.request_n[k][4] = k+1; //表示该指令放入捎带队列中将被执行 } }
主请求起到关键的作用

主请求作为该次电梯执行的目标楼层，就是运行的最后一层，决定了电梯的运行方向，以及会捎带那些请求，在我们采用第二种方法后，每次执行的时整个请求队列，也就意味着，我们每次都将主请求执行结束，才意味着一次执行的结束，所以每次执行后都需要更新主请求，更新的主请求有两个来源，捎带队列中还未执行的请求，请求队列中还未执行的请求。主请求被确定后该请求就会被加入到捎带队列中，同时改楼层按钮被按下；代码实例如下

 

if(this.station[1]==2){ //表示电梯之前是向下运行的，所以找出楼层最低的作为主请求
                for(num=1;num<=10;) {
                    if(this.on_way[num][0][0]==0)
                        num++;
                    else 
                        break;
                }  //判断捎带队列中的哪一个作为下一个主请求
                if(num==11) {     //num==11.表示捎带队列已经空了，所以将请求队列中的下一个作为主请求，并加入到捎带队列中
                    while(this.request_n[i][4]!=0)
                        i++;  //表示在请求队列中将已经执行的队列过滤掉
                    this.on_way[0][0] = this.request_n[i]; this.pr_instr = this.request_n[i]; this.on_way[(int) this.request_n[i][0]][0] = this.request_n[i];//表示主请求的哪一个楼层的请求 this.request_n[i][4] = i+1; } else { this.on_way[0][0] = this.on_way[num][0]; //第0个表示主请求 this.pr_instr = this.on_way[num][0]; } }//如果是下行就找到最远的哪一个作为主请求，也就是楼层最小的那个作为朱请求 // ② else if(this.station[1]==1){ //表示电梯之前是向上运行的 for(num=10;num>=1;) { if(this.on_way[num][0][0]==0) num--; else break; } //判断捎带队列中的哪一个作为下一个主请求 if(num==0) { //num==0.表示捎带队列已经空了，所以将请求队列中下一个作为主请求，并加入到捎带队列中 while(this.request_n[i][4]!=0) i++; //表示在请求队列中将已经执行的队列过滤掉 this.on_way[0][0] = this.request_n[i]; this.pr_instr = this.request_n[i]; this.on_way[(int) this.request_n[i][0]][0] = this.request_n[i];//表示主请求的哪一个楼层的请求 this.request_n[i][4] = i+1; } else { this.on_way[0][0] = this.on_way[num][0]; //表示上行的时候将楼层最大的作为主请求 this.pr_instr= this.on_way[num][0]; } } // ③，表示之前电梯是静止的 else { while(this.request_n[i][4]!=0) i++; //表示在请求队列中将已经执行的队列过滤掉 this.on_way[0][0] = this.request_n[i]; this.pr_instr = this.request_n[i]; this.on_way[(int) this.request_n[i][0]][0] = this.request_n[i];//表示主请求的哪一个楼层的请求 this.request_n[i][4] = i+1; } if(this.pr_instr[3]==1) { //表示上行的 this.occupy[(int) this.pr_instr[0]][2]=1; } else if(this.pr_instr[3]==2) { //表示下行 this.occupy[(int) this.pr_instr[0]][3]=1; } else if(this.pr_instr[2]==2) { //表示在电梯内 this.occupy[(int) this.pr_instr[0]][1]=1; } } 

 

 判断同质请求会很麻烦

 

同质请求的判断稍不留神就出错了，小编也是打了好几次补丁才最终完成同质请求的判断，因为同质请求牵涉到的属性有点多；楼层，时间，请求队列，捎带队列，这些都会影响到同质请求的判断，那么到底什么样的请求才算是同质请求呢？以及判断为什么会如此的麻烦呢？

  1. 同质请求意味着在请求到达目标楼层之前，对于目标楼层发出了多个相同请求，小编在室友的指导下，采用了他的方法，楼层的按钮。同一楼层只有三种按钮，当该楼层的按钮被按下以后，在该楼层的请求完成之前，按钮都处于按下的状态，也就意味着继续按同一按钮是没有意义的，所以这样来判断同质
  2. 关于同质牵涉到的时间问题是，电梯在运动过程中，途中电梯有捎带请求执行的时候，他需要执行捎带请求，所以时间会向后延长1s，所以在计算同质请求的时候，时间要计算到判断同质请求的那一楼层

见代码：

for(floor=this.station[0];floor < this.request_n[k][0];floor++) {
                        if(this.on_way[floor][0][0]!=0) {
                            arrive++;
                        }
                        arrive+=0.5;
                    }
                    //计算出从当前楼层到队列中一层的时间
                    if(this.occupy[(int) this.request_n[k][0]][1]!=0 && (arrive+this.stop_time)>this.request_n[k][1])  //表示该层楼电梯内的按钮已经被占用
                    {
                        this.request_n[k][4] = 1; System.out.printf("#SAME"); output2(this.request_n[k]); //在时间允许内，按钮已经被按下了，所以判断为同质请求 }

 

如何解决请求时间与执行时间

 

 关于请求时间与执行时间的计算，有几点感觉需要注意，重要的是，时间与请求有关，还与主请求有关。对于当前时间，如果主请求时间晚于当前时间，那么电梯就要停止运行，等待主请求的到来，因为没有主请求，电梯是不会运行的。而电梯运行的途中，对于请求时间，需要计算从此次运行的开始时刻到达该楼层的时间。用来判断是否需要等待，如果需要等待，还需要在计算一次运行的时间，代码如下

 

if(state_in[0]==move[0]) {
                        if(this.in_way[this.state_in[0]][0][1]>this.st_time) {
                            this.st_time = this.in_way[this.state_in[0]][0][1];
                        }
                        this.st_time = this.st_time + this.mo_time;
                    }
                    else {
                        this.st_time = this.st_time + this.mo_time; if(this.in_way[this.state_in[0]][0][1]>this.st_time) { this.st_time = this.in_way[this.state_in[0]][0][1]; this.st_time = this.st_time + this.mo_time; } } this.mo_time = 0; //判断是否是主指令

 

总结

 

对于本题我的类图如下：

 

代码耦合度：

 

小小收获

 

对于本课程收获，前三周虽然过的十分十分的辛苦，但是收获还是有的。感觉从来没有de过这么久的bug，没有写过这么久的bug，没有从头速成写代码。这些都是第一次。还有就是在计组课程之上对于设计理解了更多。关于设计思路，方法等，所以一般会在写代码之前写readme。对于整体的设计还是要更加的注重细节的处理，多在细节上花功夫，会使debug的过程简单很多。另一方面，互测虽然不是很“友好”，但是在看别人的代码中，收获了很多，代码的风格，处理问题的方式，等等。

 

 

 

 

 

转载于:https://www.cnblogs.com/wevolf/p/8694163.html

SAP_ABAP_OO_ALV案例
java_zhong1990的专栏
08-29 1万+
SAP ABAP OO ALV开发实战指南 本文详细介绍了SAP ABAP OO ALV（面向对象ALV）开发的核心概念和实践方法，旨在帮助1-3年经验的ABAP开发人员快速提升技能。 核心内容要点 能力模型：涵盖ALV/REPORT、SMARTFORM、BAPI/BDC、IDOC/RFC等关键开发技术 实战案例：通过收款清账平台开发案例演示OO ALV开发流程，包含完整的程序结构和代码模板 技术要点： OO ALV与传统ALV的对比 ALV Grid Control的使用方法 面向对象的事件处理机制 数据
java接口和实现分离_设计与实现分离——面向接口编程（OO博客第三弹）
weixin_30888681的博客
02-13 949
如果说继承是面向对象程序设计中承前启后的特质，那么接口就是海纳百川的体现了。它们都是对数据和行为的抽象，都是对性质和关系的概括。只不过前者是纵向角度，而后者是横向角度罢了。今天呢，我想从设计+语法角度说一说我感受到的面向接口编程，从而初探设计与实现分离的模式。(本文所使用的面向对象语言为java，相关代码都是java代码)设计——接口抽象设计继承的思想很容易理解，提取几类相近数据中的公共部分为基类...
OO第一次博客
04-03 127
作为一个面向对象编程的小白，这三次作业对于我来说难度其实非常大。所幸，OO教务组合理地安排作业让我这个小白也能逐渐接受这一切。 第一次作业分析： 由于是首次使用Java语言编写面向对象程序，因此本次作业写得并不理想。事实上，也正是因为第一次的原因，导致我的代码充满了面向过程的感觉，并没有很好的将表达式类的属性进行封装。因而在DEBUG阶段造成了很大的麻烦。 ...
OO第一次博客作业
weixin_30872733的博客
03-27 191
OO第一次博客作业 一、三次作业的bug反省 1、自己发现别人的问题 （1）输入处理的问题，比如第一次作业，主要就是处理输入的字符串，然后有同学的正则表达式有问题，则对于一些错误输入就不能正确判断。 （2）在求导求完之后的合并项的时候出问题，在第二次作业中我发现了两个同学都是在和并项的时候出了问题，导致两个指数相同的项没有成功合并，然后出现了一些奇奇怪怪的错误。 （3）输入没有处理好，具...
OO第一次博客总结
aidan0171的博客
04-02 238
OO第一次博客总结 　　大一就久仰OO大名。曾经有一份真挚的JAVA课放在我的面前，我没有好好的珍惜，等到OO到来后，我才追悔莫及。人世间最痛苦的事莫过于此……现在来分析一下自己的代码和心得，总结一下一个月来的收获。 第一次作业 　　难点分析 　　第一次作业的要求是实现有一定鲁棒性的多项式加减法，C语言代码大家都练习过，因此算法部分其实并非难点。对于大多数刚开始接触JAV...
oo 第一次博客作业
anchoupi8353的博客
03-26 237
oo 第一次博客作业 oo 第一次博客作业 早在大一就听说了oo的各种传奇故事，大二下学期终于也开始了我的oo之旅。 基于度量来分析自己的程序结构 第一次作业 类图分析 耦合度分析 可以看出在第一次作业中，我的耦合度非常高，还停留在面向过程式的设计。 第...
oo第一次博客作业
weixin_30817749的博客
03-27 229
oo第一次博客作业 前言：前两次作业感觉还比较人畜无害，到第三次给我整崩溃了。可能前两次作业还是对于数据结构的考察比较大，而第三次作业则要求有一个比较清晰的面向对象式的架构体系。三次作业的输入处理都比较恶心，第三次尤甚，主要的原因之一可能是在上这门课之前自己对于正则表达式的应用太少了。 oo第一次作业 第一次作业的重点在于用输入处理正则表达式。至于多项式的一些操作以及求导还是比较简单的...
oo第一次博客总结
weixin_30565199的博客
04-04 92
自古以来，oo就有着6系大魔王的名声，自开学便诚惶诚恐，心中少不了忐忑。果然第一次作业便显得有些不留情面。 第一次作业 　　第一次作业的目标是实现具有一定鲁棒性的多项式运算程序。难点不在逻辑，而是在于对java语法的熟悉、使用，对输入的识别判断。作为第一次接触java的萌新，初上手是毫无头绪，不知道程序该如何下手，就像第一次接触编程一般。虽然始终记得java是面向对象语言，也是照猫画虎的...
OO第一次博客总结作业
weixin_30548917的博客
04-03 216
从前听学长学姐们口中说过无数次的OO，这学期终于接触到了-- 抱着一种“没事，再难也难不过计组”的心态，我成功地被OO教育得明明白白的 第一次作业 第一次作业的主题并不陌生——多项式加减，学C语言的时候也有过类似的题目，所以，这一次作业首先要求我们回顾了一下C语言，要求先用C语言完成一次该作业，再写JAVA的版本。 坦白说，我在接触这门课之前并没有做好十分充足的准备，尽管道听途说...
buaaoo第一次博客
weixin_30877227的博客
03-23 332
经历了四周的oo课程学习，对本单元进行一个总结。 因为前两次的作业对类的划分提醒的都很明确，所以在总体设计上并没有遇到太大的困难，不过由于自身把握的不到位，老是想着一个类的目的，所以导致一个类里面的属性和方法都很单一，类之间的交互也极其少，说直接点就是更像是写得一个应用了正则表达式的过程式程序，看不出什么面向对象的思想。类图大概是这种样子： 前两次的设计思路 前两...
OO第一次博客作业--第一单元总结
weixin_30410119的博客
03-26 140
OO第一单元总结 　　面向对象设计与构造的第一单元，对“面向对象”的概念还根本不理解不熟悉，只觉得需要“分模块”，但不知道怎么分，分多少模块，怎么根据需要的模块的功能建立类。学习的进度又太慢，根本跟不上出作业的速度，导致三次作业的代码都写得很乱，很不面向对象。 1. 第一次作业 1.1 程序结构分析 　　第一次的作业比较简单，但由于刚刚接触面向对象，程序的结构仍然不太好...
java 电梯调度_OO第二次博客作业——电梯调度
weixin_28902131的博客
02-21 755
OO第二次博客作业——电梯调度前言最近三周，OO课程进入多线程学习阶段，主要通过三次电梯调度作业来学习。从单部电梯的傻瓜式调度到有性能要求的调度到多部电梯的调度，难度逐渐提升，对同学们的要求逐渐变高，我们对线程的理解也逐渐加深。下面笔者将对三次作业分别进行总结。一、单部多线程傻瓜调度(FAFS)电梯说明：本次作业需要模拟一个多线程实时电梯系统，从标准输入中输入请求信息，程序进行接收和处理，模拟电梯...
OO Unit2 博客总结
i_want_ak_noip的博客
04-19 852
我的双轿厢影子电梯的思路是这样的：对于影子电梯而言，两个轿厢的运行是不会存在协作的，如果一个乘客想跨越转换层，那么对于影子电梯而言乘客在转换层下去的那一刻就已经和这个电梯无关了——之后是经过重新调度重新给下去的乘客分配一个新的电梯。在第一次作业中，我采用了单例模式和生产者-消费者，输入类承担生产者的角色，电梯承担消费者的角色，同时实现了一个仅包含静态方法的策略类，该类接受电梯参数并给出电梯下一步操作的建议。wxm巨佬认为，在复制、克隆、模拟影子电梯运行的过程中，必须要保证影子电梯的参数是实时正确的。
BUAA-OO-2019 第一单元总结
TimDyh的博客
08-20 627
第一次作业 第一次作业需要完成的任务为简单多项式导函数的求解。 思路 因为仅仅是简单多项式的求导，所以求导本身没有什么可说的，直接套用幂函数的求导公式就行了，主要的精力是花在了正则表达式上。这里推荐两个网站： https://github.com/ziishaned/learn-regex https://regex101.com 前者可以用来学习正则表达式的语法，后者则提供实时的正则表达式匹配，...
车载系统应用开发集成系统API
yangyulong0622的博客
12-16 249
车载开发中，为了快速迭代常将系统应用剥离为普通应用开发，但调用系统API时反射效率低。解决方法是通过集成framework.jar，但会遇到编译报错问题。通用方案是在gradle中配置bootstrapClasspath引入jar包。当使用高版本JDK时，必须强制指定模块使用JDK8并关闭lint检查才能生效。关键步骤：先加载jar包到工程，再设置模块JDK版本为1.8。
命令执行漏洞 (RCE) 渗透测试实战指南
weixin_45631123的博客
12-15 347
Burp Suite 或 OWASP ZAP 抓包工具、授权测试环境。：Burp Collaborator 或公网DNS服务器。：Java Web应用，可注入Java代码。：安装ysoserial工具、Java环境。：安装Commix、Python3环境。：识别表单输入点（如登录框）：无回显但命令执行成功时。：确认RCE漏洞存在。
JAVA设计模式之观察者模式
pingguocu3的博客
12-17 314
在我们开发的过程中，经常会遇到一些当什么什么事情发生的时候，然后做什么什么事。比如某种商品的物价上涨时会导致部分商家高兴，而消费者伤心。平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。著作权归作者所有,转载或内容合作请联系作者。
使用idea启动一个springboot项目
最新发布
qq_51389137的博客
12-19 585
5.装配置maven配置到idea下载项目依赖。4.装navicat。
mysql 查询第一次记录
05-27
### 在 MySQL 中查询第一条记录的方法 在 MySQL 数据库中，可以通过多种方式实现对第一条记录的查询。以下是几种常见的方法及其适用场景： #### 方法一：使用 `LIMIT` 关键字 最简单的方式是利用 `LIMIT` 来限制返回的结果数量为 1。这种方式适用于不需要复杂排序的情况。 ```sql SELECT * FROM table_name LIMIT 1; ``` 这条语句会从指定表中选取任意的第一条记录[^1]。然而需要注意的是，如果没有明确指定顺序，不同运行环境下的结果可能会有所差异。 #### 方法二：结合 `ORDER BY` 进行排序后再取第一条 为了确保获得期望中的“第一条”记录，通常还需要配合 `ORDER BY` 子句来进行显式的排序处理。例如按主键ID升序排列并获取最小的一个： ```sql SELECT * FROM table_name ORDER BY id ASC LIMIT 1; ``` 此处通过设定 `id` 列作为依据从小到大整理好所有的行之后再截断输出前头那个唯一实例[^2]。 对于日期型字段或者其他具有自然先后关系属性的数据类型同样如此操作即可得到最新或者最早的单项资料。 #### 方法三：采用子查询与 EXISTS 结构定位特定分组内的首个成员 当面临更复杂的业务需求比如要分别统计各个类别下各自独立存在的初始状态对象时，则需要用到嵌套查询技术加上存在测试逻辑共同构建解决方案。下面展示了一个范例说明如何高效地检索出每个用户最新的订单详情而无需多次扫描全量数据集: ```sql SELECT o.* FROM orders AS o WHERE NOT EXISTS ( SELECT 1 FROM orders AS oo WHERE oo.user_id = o.user_id AND oo.order_time > o.order_time ); ``` 在这个例子当中，外层循环逐一考察每一个潜在候选方案即原始订单列表里的各项实体；内部则负责验证是否存在任何其他关联相同客户编号但是发生时刻晚于当前正在评估的那个版本的情形——一旦发现就排除掉后者从而留下最早产生的那份副本成为最终呈现给调用者的成果之一部分[^3]。 --- #### 注意事项 尽管上述三种途径都能达到预期效果，但在实际运用过程中还需综合考量诸如性能瓶颈等因素的影响程度以便做出最优抉择。特别是面对海量级规模存储单元的时候更要谨慎对待常规做法可能引发资源过度消耗的风险隐患问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值