结对编程

最新推荐文章于 2024-11-13 20:43:20 发布

weixin_30291791

最新推荐文章于 2024-11-13 20:43:20 发布

阅读量101

点赞数

文章标签： java 开发工具测试

原文链接：http://www.cnblogs.com/psps/p/9768652.html

版权

合作者：201631062319，201631062424

代码地址：https://gitee.com/this-hui/WordCount

本次作业要求：系统分析与设计结对项目

一、结对的PSP表格

PSP阶段	预估耗时（分钟）	实际耗时（分钟）
计划	30	60
估计这个任务需要多少时间	20	20
开发	100	150
需求分析	30	30
生成设计文档	20	20
设计复审	30	20
代码规范	20	20
具体设计	30	30
具体编码	60	90
代码复审	30	30
测试	30	40
报告	20	20
测试报告	20	20
计算工作量	10	20
事后总结	20	30
合计	470	600

　　在做项目的时候，我们自己预先估计的时间与实际时间之间还是存在着一些问题，比如在做项目计划

的时候，我们预先估计的是30分钟，没有想到由于两个人之间的分歧，导致我们用了60分钟才完成。

还有就是编程的时间也超过了我们的预期时间。

二、互审代码情况

　　1.代码复审前

　　在代码复审前，我们各自确定我们的代码能够在自己的机子上进行编译成功，然后各自对自己的

代码进行了测试，测试完成后，我们便开始了代码复审。

　　2.复审时

　　在代码复审时，我们每个人提供了新的代码，查看了双方代码的时间复杂度和空间复杂度。在复

审我的代码的时候，我控制着流程，讲述了修改代码的前因后果，我的合作者逐一提供了反馈意见。

同样，在审查他的代码的时候也是一样。

　　3.复审结果

　　我们代码复审的结果就是双方达成了一致的意见，再总结出了一份双方一致同意的程序代码。

三、设计过程

　　1.确定编程语言及编程工具

　　我们两人都对java比较熟悉，所以这次我们的程序决定用java语言来写，对于我们来说，eclipse

编程工具是我们最熟悉的，所以我们都选择了这个编程工具。

　　2.思考创建类的个数

　　在思考怎么编程的时候，我们考虑了创建5个类，分别是Creat_data类、test类、ToolUtil类、

View类、WordCount类。

　　3.实现项目功能

　　程序包含5个类，分别是Creat_data类、test类、ToolUtil类、View类、WordCount类。下面，

我会依次讲述每个类的功能及如何实现的。

四、代码说明

　　Creat_data类

　　用于创建文件列表

Creat_data

 1 import java.io.BufferedReader;
 2 import java.io.FileInputStream;
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.util.HashSet;
 7 import java.util.Set;
 8 
 9 public class Creat_data {
10 
11     
12     Set<String> all_file =new HashSet<String>();//创建文件列表
13     String Output_file = "result.txt";
14     String Result ="";//创建结果的字符集
15     boolean F_Characters=false;
16     boolean F_Lines =false;
17     boolean F_wods =false;
18     public boolean F_difine=false;
19     public boolean F_NULL=false;
20     public boolean F_Code=false;
21    
22     String result = "";
23     //创建可以操作的IO流
24     FileInputStream in = null; 
25     InputStreamReader isr = null;
26     BufferedReader bis = null;
27     FileOutputStream os = null;
28     public int Count=0;
29      
30 
31 //关闭IO流
32     public void Close() {
33         
34         try {
35             in.close();
36             isr.close();
37             bis.close();
38         } catch (IOException e) {
39             // TODO Auto-generated catch block
40             e.printStackTrace();
41         }
42         
43     }
44 }

　　WordCount类

　　用于检查字符数、行数、单词数、代码行、注释行、空行

WordCount

 1 import java.io.IOException;
 2 
 3 public class WordCuont {
 4     //主程序用于判断
 5     public static  void main(String [] args) {
 6         Creat_data data =new Creat_data();//创建的数据类
 7         ToolUtil toolUtil = new ToolUtil();//创建的工具类
 8         for(int i=0 ;i<args.length;i++)
 9         {
10             
11             if(args[i].startsWith("-")) {
12                 
13                 switch (args[i])
14                 {
15                 case "-c"://检查字符数
16                    data.F_Characters=true;
17                    break;
18                 case "-l"://检查行数
19                     data.F_Lines=true;
20                     break;
21                 case "-w"://检查单词数
22                     data.F_wods=true;
23                     break;
24                 case "-a"://检查代码行，注释行，空行，
25                     data.F_difine=true;
26                     break;
27                
28                 case "-o":
29                     if(!args[i+1].startsWith("-"))
30                     {
31                         data.Output_file=args[i+1];
32                         i++;
33                     }else {
34                         System.out.println("Your intput is illigal!");
35                         System.exit(0);
36                     }
37                     break;
38                     default:
39                         System.out.println("Your intput is illigal!");
40                         break;
41                 
42                 }
43             }
44             else data.all_file.add(args[i]);
45             
46             
47         }
48         //判断然后传入数据
49         if(data.F_Characters)
50         {
51             data.Result+=toolUtil.ReturnChara(data.all_file)+"\r\n";
52         }
53         if(data.F_Lines)
54         {
55             data.Result+=toolUtil.ReturnLines(data.all_file)+"\r\n";
56             
57         }
58         if(data.F_wods)
59         {
60             data.Result+=toolUtil.ReturnWords(data.all_file)+"\r\n";
61         }
62         if(data.F_difine)
63         {
64             try {
65                 data.Result+=toolUtil.difflineGUI(data.all_file)+"\r\n";
66             } catch (IOException e) {
67                 // TODO Auto-generated catch block
68                 e.printStackTrace();
69             }
70         }
71    
72         
73         System.out.println(data.Result);
74         toolUtil.OutpuFile(data.Output_file,data.Result);
75     }
76 
77 }

ToolUtil类
用于创建检查字符数，行数，单词数，空行，注释行的方法

  1 import java.io.BufferedReader;
  2 import java.io.File;
  3 import java.io.FileInputStream;
  4 import java.io.FileNotFoundException;
  5 import java.io.FileOutputStream;
  6 import java.io.IOException;
  7 import java.io.InputStreamReader;
  8 import java.util.Set;
  9 import java.util.regex.Pattern;
 10 
 11 public class ToolUtil {
 12 //创建检查字符数，行数，单词数，空行，注释行的方法
 13     public String ReturnChara(Set<String> all_file) {  
 14         // TODO Auto-generated method stub]
 15         Creat_data data_R=new Creat_data(); //调用数据类创建数据和IO流
 16         byte [] S_byte=new byte[20*1024];
 17         int len =S_byte.length;
 18         int Byetes=0;
 19         try {
 20            for(String all_file1:all_file)
 21            {
 22                
 23                 data_R.in =new FileInputStream(all_file1);
 24                 while((Byetes = data_R.in .read(S_byte,0,len))!=-1)
 25                 {
 26                     data_R.Count+=Byetes;
 27                 }
 28                 data_R.result+=all_file1+",字符数:"+data_R.Count+"   ";
 29                 data_R.Count =0;
 30             }
 31         }catch(FileNotFoundException e)
 32         {
 33             System.out.println("文件输入错误请检查后重新输入");
 34             System.exit(0);
 35             
 36         }catch(IOException e) {
 37             e.printStackTrace();
 38         }finally
 39         {
 40             try {
 41                 data_R.in.close();
 42             } catch (IOException e) {
 43                 // TODO Auto-generated catch block
 44                 e.printStackTrace();
 45             }
 46             }
 47         
 48     return data_R.result;
 49         
 50     }
 51 
 52     public String ReturnLines(Set<String> all_file) {
 53         // TODO Auto-generated method stub
 54         Creat_data data_L=new Creat_data();
 55         try
 56         {
 57             for(String all_file1:all_file)
 58             {
 59                 data_L.in=new FileInputStream(all_file1);
 60                 data_L.isr=new InputStreamReader(data_L.in);
 61                 data_L.bis=new BufferedReader(data_L.isr);
 62                 while(data_L.bis.readLine()!=null)
 63                 {
 64                     data_L.Count++;
 65                 }
 66                 data_L.result+=all_file1+",行数："+data_L.Count+"    ";
 67                 data_L.Count=0;
 68                 
 69             }
 70         }catch(FileNotFoundException e)
 71         {
 72             System.out.println("文件输入错误请检查后重新输入");
 73             System.exit(0);
 74             
 75         }catch(IOException e) {
 76             e.printStackTrace();
 77         }finally
 78         {
 79             data_L.Close();
 80             }
 81         
 82     return data_L.result;
 83         
 84     }
 85 
 86     public String ReturnWords(Set<String> all_file) {
 87         // TODO Auto-generated method stub
 88         Creat_data data_W=new Creat_data();
 89         StringBuffer saveString = new StringBuffer();
 90         String tmp = ""; //缓存字符串
 91 
 92         try {
 93         
 94             for(String all_file1:all_file)
 95             {
 96                 data_W.in=new FileInputStream(all_file1);
 97                 data_W.isr=new InputStreamReader(data_W.in);
 98                 data_W.bis=new BufferedReader(data_W.isr);
 99                 while((tmp=data_W.bis.readLine())!=null)
100                 {
101                   saveString.append(tmp);
102                 }
103                 tmp =saveString.toString();
104                 String [] all= tmp.split("[\\s+,\\.\n]");
105                 data_W.Count = all.length;
106                 data_W.result+=all_file1+",单词数："+data_W.Count+"    "; 
107             }
108             
109             
110         }catch(FileNotFoundException e)
111         {
112             System.out.println("文件输入错误请检查后重新输入");
113             System.exit(0);
114             
115         }catch(IOException e) {
116             e.printStackTrace();
117         }finally
118         {
119             data_W.Close();
120             }
121         
122         
123         return data_W.result;
124     }
125 
126     public boolean OutpuFile(String output_file, String Result) {
127         // TODO Auto-generated method stub
128         File OUtputFile =new File(output_file);
129         FileOutputStream os =null;
130         byte[] b=null;
131         try {
132             if(!OUtputFile.exists())
133             {
134                 OUtputFile.createNewFile();
135             }
136             os = new FileOutputStream(OUtputFile);
137             b= Result.getBytes();
138             os.write(b);
139         }catch(IOException e)
140         {
141             e.printStackTrace();
142         }finally
143         {
144             try
145             {
146                 os.close();
147             }catch(IOException e)
148             {
149                 e.printStackTrace();
150             }
151         }
152         return true;
153     }
154     String difflineGUI(Set<String> all_file) throws IOException {
155          int Sode_Line = 0;  
156          int Code_Line = 0;
157          int Null_Line = 0;
158          Creat_data data_n =new Creat_data();
159          BufferedReader bufr = null;
160              for (String all_files : all_file) {
161                  bufr = new BufferedReader(new InputStreamReader(new FileInputStream(all_files)));
162             
163                  Pattern nodeLinePattern = Pattern.compile("((//)|(/\\*+)|((^\\s)*\\*)|((^\\s)*\\*+/))+", 
164                          Pattern.MULTILINE + Pattern.DOTALL);   
165                String line = null;
166                      while((line = bufr.readLine()) != null) {
167                          if (nodeLinePattern.matcher(line).find()) {
168                             
169                              Sode_Line++;
170                          
171                      }
172                          else if(line.matches("^\\s*$")){
173                              
174                              Null_Line ++;
175                              
176                          }
177                          else
178                              Code_Line ++;
179              }
180              
181           
182                    
183                      data_n.result+=all_files+",代码行:"+Code_Line+",注释行:"+Sode_Line+",空行数:"+Null_Line+"   ";
184          
185      }
186              return data_n.result;
187  }
188 }

ToolUtil

五、单元测试

单元测试代码：

 1 import java.io.IOException;
 2 import java.util.HashSet;
 3 import java.util.Set;
 4 
 5 import org.junit.Test;
 6 
 7 
 8 public class test {
 9      @org.junit.Test
10      public void testDifine() {
11             Set<String> all_files = new HashSet<String>();
12             String file1 = "D:test.java";
13             all_files.add(file1);
14             try {
15             
16                   System.out.println(new ToolUtil().difflineGUI(all_files));
17                 
18            
19             } catch (IOException e) {
20                 // TODO Auto-generated catch block
21                 e.printStackTrace();
22             }
23         }
24 
25      @org.junit.Test
26     public void testReturnCharacters() {
27         Set<String> all_files = new HashSet<String>();
28         String file1 = "D:test.java";
29         all_files.add(file1);
30         System.out.println(new ToolUtil().ReturnChara(all_files));
31     }
32 
33     @org.junit.Test
34     public void testReturnWords() {
35         Set<String> all_files = new HashSet<String>();
36       
37         String file1 = "D:test.java";
38         all_files.add(file1);
39         System.out.println(new ToolUtil().ReturnWords(all_files));
40     }
41 
42     @org.junit.Test
43     public void testReturnLines() {
44         Set<String> all_files = new HashSet<String>();
45         String file1 = "D:test.java";//哈哈哈哈
46         all_files.add(file1);
47         System.out.println(new ToolUtil().ReturnLines(all_files));
48     }
49   
50 
51     @org.junit.Test
52     public void testOutputFile() {
53         String all_files  = "result.txt";
54         String context = "OutPutFile test !";
55         new ToolUtil().OutpuFile(all_files, context);
56     }
57 
58 }

test

六、可视化界面：

可视化界面代码：

 1 import java.awt.Color;
 2 import java.awt.GridLayout;
 3 import java.awt.event.ActionEvent;
 4 import java.awt.event.ActionListener;
 5 import java.io.IOException;
 6 import java.util.HashSet;
 7 import java.util.Set;
 8 
 9 import javax.swing.JButton;
10 import javax.swing.JFrame;
11 import javax.swing.JLabel;
12 import javax.swing.JPanel;
13 import javax.swing.JTextField;
14  
15 public class View {
16  
17      
18  
19      
20     public static void main(String[] args) {
21         JFrame frame = new JFrame("WordCount");
22         frame.setResizable(false);//固定大小
23          
24         JPanel panel = new JPanel();
25         panel.setBackground(new Color(250,250,250));
26         panel.setLayout(new GridLayout(10,10,1,1));
27          
28          
29         JLabel text1 = new JLabel("文件：");
30         JLabel text3 = new JLabel("单词数,字符数：");
31         JLabel text2 = new JLabel("行数：");
32  
33         JLabel text5 = new JLabel("代码行，注释行，空行数：");
34         JTextField FileInput = new JTextField("");
35         JTextField Words = new JTextField("");
36         JTextField Line = new JTextField("");
37         JTextField Char = new JTextField("");
38         JTextField Code = new JTextField("");
39         
40         JButton bt = new JButton("结果");
41          
42          
43         frame.setBounds(300, 300, 210, 250);
44         panel.setBounds(0, 0, 200, 200);
45          
46         panel.add(text1);
47         panel.add(FileInput);
48         panel.add(text2);
49         panel.add(Words);
50         panel.add(text3);
51         panel.add(Line);
52         panel.add(text5);
53         panel.add(Code);
54         panel.add(bt);
55          
56         frame.add(panel);
57         frame.setVisible(true);
58         ToolUtil tool =new ToolUtil();
59          
60         bt.addActionListener(new ActionListener() {
61              
62             @Override
63             public void actionPerformed(ActionEvent e) {
64                 // TODO Auto-generated method stub
65                  
66                 JButton bt = (JButton) e.getSource();
67                  try{
68                      Set<String> all_files = new HashSet<String>();
69                      String file1 = FileInput.getText();
70                      all_files.add(file1);
71                      Words.setText(tool.ReturnWords(all_files));
72                      Line.setText(tool.ReturnLines(all_files)+tool.ReturnChara(all_files));
73                      Code.setText(tool.difflineGUI(all_files));
74                     
75                  } catch(NumberFormatException n)
76                  {
77                         FileInput.setText("你输入的文件！");
78                  } catch (IOException e1) {
79                     // TODO Auto-generated catch block
80                     e1.printStackTrace();
81                 }
82                  
83             }
84         });
85     }
86  
87 }