隊友代碼優點：

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.高中題目括號功能：代碼只能保證左括號和右括號數量相等，不能保證左括號與右括號匹配，即可能出現一對應匹配的括號右括號在左而左括號在右的情況。

互相學習：

看了潤釗的代碼我也意識到了自己代碼的一些問題：沒有實現括號和避免題目重復的功能，而且題目輸出的方式也沒有像潤釗這樣先保存後輸出，導致擴展性很差。以後我會慢慢改正，和大家共同進步。

結對編程——隊友代碼分析