结对编程之代码分析

结对编程队友使用的是Java语言。

主函数内有用户登陆以及模型选择和出题数量的功能代码。

有3个出题函数，分别用于实现小学出题，初中出题，高中出题。

接下来是对代码的分析，先讲缺点，再讲优点，互相提高。

 

①：代码的可移植性差。

这里对于路径的控制是直接在代码里输入的，而不是自动寻路或者是人工在控制台输入。如下

 private static String path = "G:\\java_practice\\Auto_question\\";

那么对于这样的情况，如果是在一个没有G盘的电脑上运行，那么就会出现问题。 

而且在这里没有人工的提示，一开始使用的时候就会出现无法运行的情况，得自行在源代码里修改才能运行，这样的话，不仅使用效果差，并且代码安全性，也就是可封装性不高。

 

②：冗余代码多，在三个出题函数里面，有大段的重复代码。不利于提高程序的内聚性，诸如创建文件，添加换行，可以直接提取出一个新的函数。而添加括号等可以也成为一个新的函数。

这样避免了一个函数内的代码过多。目前的函数最长的有大约80行，期望通过结对编程以后可以降低函数长度，达到最长函数在40行以内。

  1 public static void Output_to_primary(File f,int num_exc) { 
  2         
  3         FileWriter fw = null;
  4         
  5         //创建字符输出流类对象和已存在的文件相关联,若文件不存在，则创建；
  6                 try {
  7                     if(!f.exists()) {
  8                         f.createNewFile();
  9                     }
 10                     fw = new FileWriter(f);
 11                             
 12                     for(int i=1;i<=num_exc;i++) {
 13                         fw.write(i+"、");
 14                         Random r = new Random();
 15                         //操作数的数量
 16                         int num_opr = r.nextInt(4)+2;
 17                         //括号的有无,加减乘除操作符,括号的数量，操作数大小
 18                         int flag_bracket = 0,opt=0,num_bracket=0,opt_num=0;
 19                         for(int j=1;j) {                    
 20                             if(j!=1) {
 21                                 flag_bracket = r.nextInt(2);
 22                                 if(flag_bracket == 1) {
 23                                     fw.write("(");
 24                                     num_bracket++;
 25                                 }
 26                             }
 27                             opt_num = r.nextInt(100)+1;
 28                             fw.write(String.valueOf(opt_num));
 29                             opt = r.nextInt(4);
 30                             fw.write(operator_type[opt]);
 31                         }
 32                         
 33                         opt_num = r.nextInt(100)+1;
 34                         fw.write(String.valueOf(opt_num));
 35                         for(int j=0;j) {
 36                             fw.write(")");
 37                         }
 38                         //Windows下的换行，Linux下的换行为\n;
 39                         fw.write("\r\n");
 40                         fw.flush();
 41                     }
 42                     
 43                 }catch(IOException e) {
 44                     e.printStackTrace();
 45                 }finally {
 46                     if(fw != null){
 47                         try {
 48                             fw.close();
 49                         } catch (IOException e) {
 50                             e.printStackTrace();
 51                         }
 52                     }
 53                 }
 54     }
 55     //生成初中的题目
 56     public static void Output_to_middle(File f,int num_exc) {    
 57         FileWriter fw = null;
 58         
 59         //创建字符输出流类对象和已存在的文件相关联,若文件不存在，则创建；
 60         try {
 61             if(!f.exists()) {
 62                 f.createNewFile();
 63             }
 64             fw = new FileWriter(f);
 65             
 66             int flag_squ,flag_sqrt;
 67             for(int i=1;i<=num_exc;i++) {
 68                 fw.write(i+"、");
 69                 Random r = new Random();
 70                 //操作数的数量
 71                 int num_opr = r.nextInt(4)+2;
 72                 //依次为括号的有无,加减乘除操作符,括号的数量，操作数大小，平方标志，开方标志
 73                 int flag_bracket = 0,opt=0,num_bracket=0,opt_num=0;
 74                 flag_squ=0;
 75                 flag_sqrt=0;
 76                 for(int j=1;j) {
 77                     
 78                     flag_sqrt = r.nextInt(4);
 79                     if(flag_sqrt == 3) {
 80                         fw.write("√");
 81                     }
 82                     if(j!=1) {
 83                         flag_bracket = r.nextInt(2);
 84                         if(flag_bracket == 1) {
 85                             fw.write("(");
 86                             num_bracket++;
 87                         }
 88                     }
 89                     
 90                     opt_num = r.nextInt(100)+1;
 91                     fw.write(String.valueOf(opt_num));
 92                     flag_squ = r.nextInt(6);
 93                     if(flag_squ == 5) {
 94                         fw.write("^2");
 95                     }
 96                     opt = r.nextInt(4);
 97                     fw.write(operator_type[opt]);
 98                 }
 99                 opt_num = r.nextInt(100)+1;
100                 fw.write(String.valueOf(opt_num));
101                 for(int j=0;j) {
102                     fw.write(")");
103                     flag_squ = r.nextInt(2);
104                     if(flag_squ == 1) {
105                         fw.write("^2");
106                     }
107                 }
108                 //Windows下的换行，Linux下的换行为\n;
109                 fw.write("\r\n");
110                 fw.flush();
111             }        
112             
113         }catch(IOException e) {
114             e.printStackTrace();
115         }finally {
116             if(fw != null){
117                 try {
118                     fw.close();
119                 } catch (IOException e) {
120                     e.printStackTrace();
121                 }
122             }
123         }
124  
125     }
126     //生成高中的题目
127     public static void Output_to_high(File f,int num_exc) {
128         FileWriter fw = null;
129         
130         //创建字符输出流类对象和已存在的文件相关联,若文件不存在，则创建；
131         try {
132             if(!f.exists()) {
133                 f.createNewFile();
134             }
135             fw = new FileWriter(f);
136             
137             int flag_squ,flag_sqrt,flag_trigo;
138             for(int i=1;i<=num_exc;i++) {
139                 fw.write(i+"、");
140                 Random r = new Random();
141                 //操作数的数量
142                 int num_opr = r.nextInt(4)+2;
143                 //依次为括号的有无,加减乘除操作符,括号的数量，操作数大小，平方标志，开方标志,三角标志
144                 int flag_bracket = 0,opt=0,num_bracket=0,opt_num=0;
145                 flag_squ=0;
146                 flag_sqrt=0;
147                 flag_trigo=0;
148                 for(int j=1;j) {
149                     
150                     flag_sqrt = r.nextInt(8);
151                     if(flag_sqrt == 7) {
152                         fw.write("√");
153                     }
154                     if(j!=1) {
155                         flag_bracket = r.nextInt(2);
156                         if(flag_bracket == 1) {
157                             fw.write("(");
158                             num_bracket++;
159                         }
160                     }
161                     
162                     flag_trigo = r.nextInt(5);
163                     if(flag_trigo==4) {
164                         fw.write(trigo[r.nextInt(3)]);
165                     }
166                     opt_num = r.nextInt(100)+1;
167                     fw.write(String.valueOf(opt_num));
168                     flag_squ = r.nextInt(6);
169                     if(flag_squ == 5) {
170                         fw.write("^2");
171                     }
172                     opt = r.nextInt(4);
173                     fw.write(operator_type[opt]);
174                 }
175                 opt_num = r.nextInt(100)+1;
176                 fw.write(String.valueOf(opt_num));
177                 for(int j=0;j) {
178                     fw.write(")");
179                     flag_squ = r.nextInt(2);
180                     if(flag_squ == 1) {
181                         fw.write("^2");
182                     }
183                 }
184                 //Windows下的换行，Linux下的换行为\n;
185                 fw.write("\r\n");
186                 fw.flush();
187             }        
188             
189         }catch(IOException e) {
190             e.printStackTrace();
191         }finally {
192             if(fw != null){
193                 try {
194                     fw.close();
195                 } catch (IOException e) {
196                     e.printStackTrace();
197                 }
198             }
199         }
200  
201     }

 

③：程序的持续运行性没有考虑到。该程序运行了一次，打印了一次试卷后就结束了。对用户的体验不好。一个用户应该要有自己选择是否退出的权力，不然对于同一个用户，想打印10张试卷，要登陆十次，这就太麻烦了。

④：没有采用缓冲存储BufferedWriter。程序的性能不高。

 

⑤：没有实现查重功能，不能对一张试卷上是否有相同题目进行查重。

 

⑥：平方的输出是^2，而不是日常数学中使用的 “ ² ” 。所以对于用户来说是不友好的。作为一张试卷是不合格的。这里面设计到的内容是编码格式，我们一般的Java的编码格式是GBK格式，而GBK格式是存不进 “ ² ” 符号的，所以需要把自己的格式转化为UFT-8，这样才能存入 “ ² ” 。

 

⑦：代码的注释不够详细，只有一些比较概念性的注释，比如这个函数的功能是什么。 对于里面实现的细节注释少，并且函数体太长，冗长的函数体里面注释太少，对于程序维护者，观看者来说太难受了。

⑧：终于讲到优点来了，代码的格式比较标准，变量的命名几乎都是用的英文缩写，所以变量的含义便于人的理解。（小声bb一下，期待有一天中文拼音可以成为主流。毕竟英文缩写对于英语不好的人来说，很难受）。