WorldCount 结对项目

合作者：201631062129，201631062501

队友博文

代码地址

本次作业链接地址

一、PSP

二、代码互审

• 队友：
  • 代码中硬编码地方较多，程序的扩展性不强；
  • 代码缺少注释，功能实现完成，但是缺少编程规范。
  • 程序流程和结构清晰
• 自己：
  • 程序结构清晰但流程复杂，代码注释少且不够清晰；
  • 多出使用接口，提高了程序的扩展性，但是增加了系统的复杂度；
  • 想的太多，程序边界分不清楚。

二、设计过程

• 主要类：
  • WorldCount类。该类主要用于接受用户的输入和处理结果输出。
  • Analyzer类。该类主要用于分析参数和处理参数的缺省，错误等问题。
  • Processor类。该类接受Analyzer类消息，并根据消息执行相应的功能。
  • Format类。该类接受Processor类的处理结果，并对结果进行格式化处理。
  • Command，抽象类。所有选项（如：-s、-w等）对用的功能执行类都要继承该类。
  • Filter，接口。对用户输入的选项和参数进行过滤，判断是否是合格的数据。
    
    
• UML简图：
  • 点击查看

• 代码实现：
  • CommandA：统计源文件空行数、注释行数和代码数：
    • 点击查看
  • CommandE：停词功能：
    • 点击查看
  • CommandS：递归分析：
    • 点击查看

• 运行效果：
  • 选项：-s
    • 点击查看
  • 选项：-a
    • 点击查看
  • 选项：-e
    • 点击查看

三、总结：

准确的说在这次对结编程项目中，我们并没有完全遵循结对编程的要求。原因是第一次使用结对编程的方法没有经验，不知怎么进行；并且在先前的项目中，我们两人的编程语言不同，程序设计不同；还有两个人的空闲时间不一样。最终结对编程的方式不是很成功。
但是在这次项目中，我也体会到了交流的好处。在项目的最后阶段，我与同伴各自交流自己的程序设计。俗话说，一个苹果交换一个苹果最后还是得到了一个苹果；但是思想交换得到了思想确是大于二的。在不断地交流中，我学到了很多，同时也迸发出来新的思想。遗憾的是这次结对编程不是那么的成功。(；′⌒`)(╯︵╰)

四、图片：

• UML简图：
  • 点击返回
    

• 选项：-s
  • 点击返回
  • 文件：
    
  • 结果：
    

• 选项：-a
  • 点击返回
  • 文件：
    
  • 结果：
    

• 选项：-e
  • 点击返回
  • 文件：
    
  • 结果：
    

五、部分代码

• CommandA类：
  点击返回

//统计空行数
    public boolean blankLine(String line) {
        if(line.length() > 1) {  //字符串是否大于0
            return false;
        }
        //判断“{”或“}”独占一行
        if(line.length() == 1) {
            char ch = line.charAt(0);
            if(ch != ‘}‘ && ch != ‘{‘) {
                return false;
            }
        }
        return true;
    }
    
    //统计注释行数
    public int annotationLine(String line, int annotationStatus) {
        char[] chars = line.toCharArray();
        boolean leftQuotation = false;
        
        if(annotationStatus == annotation_start) {
            for(int i = chars.length - 1; i > 0; --i) {
                if(chars[i] == ‘/‘) {  //判断字符串是否存在“/”
                    if(chars[i - 1] == ‘*‘) { //判断在“/”前面是否存在“*”
                        return annotation_end;  //返回当前注释部分统计结束
                    }
                }
            }
            return annotation_start;  //返回注释统计开始
        }
        
        //注释统计中间过程
        for(int i = 1; i < chars.length; ++i) {
            if(chars[i] == ‘"‘) {  //防止双引号里的转义字符
                leftQuotation = !leftQuotation;
            }else if(chars[i] == ‘/‘){
                if(!leftQuotation) {
                    if(chars[i - 1] == ‘/‘){
                        return annotation_end;
                    }
                }
            }else if(chars[i] == ‘*‘){  // 判断是否是多行注释
                if(!leftQuotation) {
                    if(chars[i - 1] == ‘/‘) {
                        i ++;
                        for(int j = chars.length - 1; j > i; --j) {
                            if(chars[j] == ‘/‘) {
                                if(chars[j - 1] == ‘*‘) {
                                    return annotation_end;
                                }
                            }
                        }
                        return annotation_start;
                    }
                }
            }
        }
        return annotation_none;
    }
    
    //统计代码行数
    public boolean codeLine(String line) {
        
        if(line.length() > 2) {
            if((line.charAt(line.length() - 1) != ‘/‘) && (line.charAt(line.length() - 2) != ‘*‘)) {
                return true;
            }else {
                if(line.charAt(0) != ‘/‘ && line.charAt(1) != ‘*‘) {
                    return true;
                }
            }
        }
        return false;
    }
    
    
    @Override
    public Status execute() {
        int annotationState = annotation_end;
        
        Data dataf = (Data)(this.getProcessor().getPool().getData(Option.option_f));
        String[] strings = (String[])dataf.getValue(true);
        
        for(int i = 0; i < strings.length; ++i) {
            String temp = strings[i].trim();
            
            if(blankLine(temp)) {
                blankLines ++;
                continue;
            }
            
            if((annotationState = annotationLine(temp, annotationState)) != annotation_none) {
                annotatinLines ++;
                if(annotationState == annotation_start) {
                    if(annotationStartCount > 0) {
                        continue;
                    }
                    annotationStartCount ++;
                }else if(annotationStartCount == annotation_end){
                    annotationStartCount = 0;
                }
            }
            
            if(codeLine(temp)) {
                codeLines++;
                continue;
            }
            
        }
        
        return Status.OVER;
    }

• CommandE类：
  点击返回

@Override
    public Status execute() {
        
        if(regex == null) {
            return Status.OVER;
        }
        messages.clear();  //清空CommandE对象的数据存储器
        //获取CommandF的对象的数据存储器
        Data dataf = (Data)(this.getProcessor().getPool().getData(Option.option_f));
        String[] messBuiders = (String[])dataf.getValue(true);  //获取数据的值
        StringBuilder builder = new StringBuilder("");
        
        
        //使用正则表达式除去停用词，再添加到本对象的数据存储器中
        for(int i = 0; i < messBuiders.length; ++i) {
            String temp = messBuiders[i];
            String[] mess = temp.toString().split(regex);
            
            for(int j = 0; j < mess.length; ++j) {
                builder.append(mess[j]);
            }
            messages.add(builder.toString());
            builder.delete(0, builder.length());
        }
        
        return Status.OVER;
    }

• CommandS类：
  点击返回

//递归读取文件，类似树的先序遍历
    private Status fileRecurseRead() {
        int count = 0;
        File[] files = innerFiles.files;  
        
        while(innerFiles != null){  //递归读取文件结束标志
            while(innerFiles.index < files.length) {  //判断当前文件的子文件是否读完
                if(files[innerFiles.index].isDirectory()) {
                    File[] filesTemp = files[innerFiles.index ++].listFiles();
                    if(filesTemp.length > 0) {  //判断是否存在子文件
                        InnerFile inFile = new InnerFile();
                        //交换节点
                        inFile.files = filesTemp;
                        inFile.parent = innerFiles; 
                        innerFiles = inFile;
                        
                        files = filesTemp;
                    }
                }else {
                    if(count < capacity) {
                        count++;
                        //把递归到的文件当作参数传给CommandF对象
                        commandF.addArgument(files[innerFiles.index ++].getPath());
                    }else {
                        return Status.PAUSE;  //文件暂停
                    }
                }
            }
            
            //放回到上一个文件
            innerFiles = innerFiles.parent;
            if(innerFiles != null) {
                files = innerFiles.files;
            }
        }
        return Status.OVER;  //文件递归完毕
    }

WorldCount 结对项目

原文：https://www.cnblogs.com/guilinyunya/p/9800347.html