结对编程——队友代码分析

队友代码优点：

1.试卷生成方面：很好的实现了避免题目重复的功能，代码将题目生成之后不先输出到txt里，而是保存到一个总题集里，最后再将总题集输出。这样每次生成题目后都可以与总题集里的所有题目进行比对，不重复才能加到总题集中，重复便重新生成此题再次比对。

 1 String str_there = sBuffer.toString();
 2                                 
 3                                 int flag_there = 0;
 4                                 
 5                                 InputStreamReader reader = new InputStreamReader(new FileInputStream(f_all)); // 建立一个输入流对象reader
 6                                 BufferedReader br = new BufferedReader(reader); // 建立一个对象，它把文件内容转成计算机能读懂的语言
 7                                 String line = "";
 8                                 line = br.readLine();
 9                                 while (line != null) 
10                                 {
11                                     line = br.readLine(); // 一次读入一行数据
12                                     if(str_there.equals(line))
13                                     {
14                                         flag_there = 1;
15                                         break;
16                                     }
17                                 }
18                                 
19                                 if(flag_there == 0)
20                                 {
21                                     writer.append("(" + i + ")");
22                                     writer.append(str_there);
23                                     writer.append("\r\n");
24                                     writer_all.append(str_there);
25                                     writer_all.append("\r\n");
26                                 }
27                                 else
28                                 {
29                                     i--;
30                                 }

 

队友代码缺点：

1.账户的保存方面：账户信息没有保存于代码之外，且代码内也未用任何数据结构储存，而是在用户输入用户名和密码之后在循环内一一比对，这样做使得账户的保存功能扩展性很差，比如无法实现用户注册和断电保存功能。

 1 while(flag1 == 0)//账户登陆
 2         {
 3             if(("张三1".equals(user_name)) && ("123".equals(user_key))) 
 4             {
 5                 flag1 = 1;
 6                 user = 0;
 7                 level = 0;
 8             }
 9             if(("张三2".equals(user_name)) && ("123".equals(user_key))) 
10             {
11                 flag1 = 1;
12                 user = 1;
13                 level = 0;
14             }
15             if(("张三3".equals(user_name)) && ("123".equals(user_key))) 
16             {
17                 flag1 = 1;
18                 user = 2;
19                 level = 0;
20             }
21             if(("李四1".equals(user_name)) && ("123".equals(user_key))) 
22             {
23                 flag1 = 1;
24                 user = 3;
25                 level = 1;
26             }
27             if(("李四2".equals(user_name)) && ("123".equals(user_key))) 
28             {
29                 flag1 = 1;
30                 user = 4;
31                 level = 1;
32             }
33             if(("李四3".equals(user_name)) && ("123".equals(user_key))) 
34             {
35                 flag1 = 1;
36                 user = 5;
37                 level = 1;
38             }
39             if(("王五1".equals(user_name)) && ("123".equals(user_key))) 
40             {
41                 flag1 = 1;
42                 user = 6;
43                 level = 2;
44             }
45             if(("王五2".equals(user_name)) && ("123".equals(user_key))) 
46             {
47                 flag1 = 1;
48                 user = 7;
49                 level = 2;
50             }
51             if(("王五3".equals(user_name)) && ("123".equals(user_key))) 
52             {
53                 flag1 = 1;
54                 user = 8;
55                 level = 2;
56             }
57             if(flag1 == 0)
58             {
59                 System.out.println("请输入正确的用户名、密码");
60                 user_name = scan.next();
61                 user_key = scan.next();
62             }
63         }

2.代码的规范性：整个项目的代码没有实现模块化，即分模块实现各功能，且部分代码效率低，代码注释少，这样做使得代码可读性很差，也没有做到高内聚低耦合，假如我要修改代码的一个功能，可能花很长时间才找到代码的位置，而且修改一个部分很可能大程度上影响其他的部分。

  1                                 for(int j = 0; j < num_num; j++)
  2                                 {
  3                                     switch(random.nextInt(18))
  4                                     {
  5                                         case 0:
  6                                         {
  7                                             break;
  8                                         }
  9                                         case 1:
 10                                         {
 11                                             break;
 12                                         }
 13                                         case 2:
 14                                         {
 15                                             
 16                                             break;
 17                                         }
 18                                         case 3:
 19                                         {
 20                                             break;
 21                                         }
 22                                         case 4:
 23                                         {
 24                                             break;
 25                                         }
 26                                         case 5:
 27                                         {
 28                                             break;
 29                                         }
 30                                         case 6:
 31                                         {
 32                                             break;
 33                                         }
 34                                         case 7:
 35                                         {
 36                                             break;
 37                                         }
 38                                         case 8:
 39                                         {
 40                                             
 41                                             break;
 42                                         }
 43                                         case 9:
 44                                         {
 45                                             break;
 46                                         }
 47                                         case 10:
 48                                         {
 49                                             sBuffer.append("(");
 50                                             kuohao_qian++;
 51                                             flag_kuohao++;
 52                                             break;
 53                                         }
 54                                         case 11:
 55                                         {
 56                                             sBuffer.append("sin(");
 57                                             kuohao_qian++;
 58                                             flag_kuohao++;
 59                                             break;
 60                                         }
 61                                         case 12:
 62                                         {
 63                                             sBuffer.append("cos(");
 64                                             kuohao_qian++;
 65                                             flag_kuohao++;
 66                                             break;
 67                                         }
 68                                         case 13:
 69                                         {
 70                                             sBuffer.append("tan(");
 71                                             kuohao_qian++;
 72                                             flag_kuohao++;
 73                                             break;
 74                                         }
 75                                         case 14:
 76                                         {
 77                                             sBuffer.append("cot(");
 78                                             kuohao_qian++;
 79                                             flag_kuohao++;
 80                                             break;
 81                                         }
 82                                         case 15:
 83                                         {
 84                                             sBuffer.append("√(");
 85                                             kuohao_qian++;
 86                                             flag_kuohao++;
 87                                             break;
 88                                         }
 89                                         case 16:
 90                                         {
 91                                             break;
 92                                         }
 93                                         case 17:
 94                                         {
 95                                             break;
 96                                         }
 97                                     }
 98                                     sBuffer.append(random.nextInt(100) + 1);
 99                                     switch(random.nextInt(6))
100                                     {
101                                         case 0:
102                                         {
103                                             break;
104                                         }
105                                         case 1:
106                                         {
107                                             break;
108                                         }
109                                         case 2:
110                                         {
111                                             break;
112                                         }
113                                         case 3:
114                                         {
115                                             break;
116                                         }
117                                         case 4:
118                                         {
119                                             sBuffer.append(")");
120                                             kuohao_hou++;
121                                             break;
122                                         }
123                                         case 5:
124                                         {
125                                             sBuffer.append(")^2");
126                                             kuohao_hou++;
127                                             break;
128                                         }
129                                     }
130                                     if(j != (num_num-1))
131                                     {
132                                         switch(random.nextInt(4))
133                                         {
134                                             case 0:
135                                             {
136                                                 sBuffer.append("+");
137                                                 break;
138                                             }
139                                             case 1:
140                                             {
141                                                 sBuffer.append("-");
142                                                 break;
143                                             }
144                                             case 2:
145                                             {
146                                                 sBuffer.append("x");
147                                                 break;
148                                             }
149                                             case 3:
150                                             {
151                                                 sBuffer.append("÷");
152                                                 break;
153                                             }
154                                         }
155                                     }
156                                 }

3.高中题目括号功能：代码只能保证左括号和右括号数量相等，不能保证左括号与右括号匹配，即可能出现一对应匹配的括号右括号在左而左括号在右的情况。

互相学习：

看了润钊的代码我也意识到了自己代码的一些问题：没有实现括号和避免题目重复的功能，而且题目输出的方式也没有像润钊这样先保存后输出，导致扩展性很差。以后我会慢慢改正，和大家共同进步。

转载于:https://www.cnblogs.com/linhejiang/p/9714812.html