Question

我在这个网站上取得了一些成功，我希望找到更优秀的程序员来帮助我。

所以我在这个代码的最后。我对编程很新，特别是异常。我通过课程材料非常努力并寻求帮助，但我一直都很不成功。我正在尝试创建一个改进的解析器，它将覆盖另一个解析器。它读取一个.txt文件，其中包含一个ID，一个名称，一个等级，一个可选的电子邮件地址，以及可选的注释，作为以逗号分隔的字符串中的标记。覆盖检查每个令牌中的错误并抛出一个名为ParserException的异常。该异常将检查代码，如果错误不可修复则返回错误消息。

例如，如果学生为成绩输入AB，则异常将标记并检查输入是否为有效等级（它是否）然后返回，如果不是，则返回ParserException ，在这种情况下 throw new ParserException(ParserException.GRADE_INVALID_GRADE,lineIndex); 这表明该功能不起作用，并在GRADE_INVALID行

上发送消息indexLine

我列出了我需要输出的内容：

任何违反上面“输入文件格式说明”部分中指定的文件格式的行为都会导致ParcerException带有相应的消息
不允许重复ID
成绩值必须是浮点数（92.0）或字母等级而不是整数

我有所有代码要更正并检查错误，但我无法弄清楚如何让try-catch工作。这是覆盖代码：

@Override
    public ParserResult parseLine(int lineIndex) {    
        String[] tokens = lines.get(lineIndex).split(",");
        ArrayList<Integer> idList = new ArrayList<Integer>();
        Integer studentId;
        String name;
        String grade;
        String email;
        String comments;
        boolean isFloat;
        float gradeFinal;
        String editName;
        studentId = new Integer(tokens[0]);
        ParserResult result;

        try{
            return super.parseLine(lineIndex);
        }
        catch(ParserException e){

            // Check reasonable number of tokens
            if(tokens.length >= 3 && tokens.length <= 5){

                name = tokens[1];
                grade = tokens[2];

                // Check the student ID
                if(idList.contains(studentId)){
                    throw new ParserException(ParserException.DUPLICATE_ID, lineIndex);
                }else{
                    idList.add(studentId);
                }

                // Check the grade
                if(grade.trim().equalsIgnoreCase("A")){
                    gradeFinal = gradeA;
                }else if(grade.trim().equalsIgnoreCase("AB")){
                    gradeFinal = gradeAB;
                }else if(grade.trim().equalsIgnoreCase("B")){
                    gradeFinal = gradeB;
                }else if(grade.trim().equalsIgnoreCase("BC")){
                    gradeFinal = gradeBC;
                }else if(grade.trim().equalsIgnoreCase("C")){
                    gradeFinal = gradeC;
                }else if(grade.trim().equalsIgnoreCase("CD")){
                    gradeFinal = gradeCD;
                }else if(grade.trim().equalsIgnoreCase("D")){
                    gradeFinal = gradeD;
                }else if(grade.trim().equalsIgnoreCase("F")){
                    gradeFinal = gradeF;
                }else{
                    try{
                        Integer.parseInt(grade);
                        isFloat = false;
                    }
                    catch(Exception fl) {
                        isFloat = true;
                    }
                    if(isFloat){
                        if((Float.parseFloat(grade) < 100f) && (Float.parseFloat(grade) >= 0f)){
                            gradeFinal = Float.parseFloat(grade);
                        }else{
                            throw new ParserException(ParserException.GRADE_INVALID_GRADE,lineIndex);
                        }
                    }else{
                        throw new ParserException(ParserException.GRADE_INTEGER_VALUE,lineIndex);
                    }
                }

                // Check the name
                if(name.split(" ").length > 3){
                    throw new ParserException(ParserException.UNKNOWN, lineIndex);
                }else{
                    editName = name.trim().split(" ")[0];
                }

                result = new ParserResult(studentId, editName, gradeFinal);

                // Checks the email
                if(tokens.length >= 4){
                    email = tokens[3];

                    // Check for at sign
                    if(!email.contains("@")){
                        throw new ParserException(ParserException.UNKNOWN, lineIndex);
                    }


                    int count = 0;
                    // Counts number of @ symbols
                    for(int i=0; i<email.length(); i++){
                        if(email.indexOf(i) == '@'){
                            count++;
                        }
                    }
                    if(count > 1){
                        throw new ParserException(ParserException.EMAIL_MULTIPLE_AT,lineIndex);
                    }
                    if(email.split(".").length == 2){
                        if(!(email.trim().split(".")[1].contains(".edu")) && !(email.trim().split(".")[1].contains(".com"))){
                            throw new ParserException(ParserException.EMAIL_NOT_EDU_OR_COM,lineIndex);
                        }else{
                            result.setEmail(email);
                        }
                    }
                    // Checks if email contains .com or .edu

                    // Checks the comments
                    if(tokens.length == 5){
                        comments = tokens[4];
                        result.setComment(comments);
                    }
                }

                return result;
            }
        }

        // TODO Call Parser's parseLine() here to attempt to parse, catch any exceptions

        return null;
    }

被覆盖但仍然使用的原始parseLine是：

public ParserResult parseLine(int lineIndex) {
    String[] tokens = lines.get(lineIndex).split(",");
    ParserResult result = new ParserResult(Integer.parseInt(tokens[0]),
            tokens[1], Float.parseFloat(tokens[2]));
    result.setEmail(tokens[3]);
    return result;
}

这是main（）文件：

public static void main(String[] args){

    // TODO Change the line below to use ImprovedParser 
    Parser parser = null;
    try {
        parser = new ImprovedParser(args[0]);
    } catch (FileNotFoundException e) {
        e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        System.exit(-1);
    }
    List<ParserResult> results = parser.parse();

    int count = results.size();
    double sum = 0.0;
    for (ParserResult result : results) {
        sum += result.getGrade();
    }

    System.out.println("Number of valid input lines: " + results.size());
    System.out.println("Number of invalid input lines: "
            + (parser.getLineCount() - results.size()));
    System.out.println("Average grade: " + sum / count);
    for (ParserResult result : results) {
        System.out.println(result);
    }

}

最后，这是正在读取的.txt文件：

# student_id,name,grade,email
1234,Bob,92.0,bob@test.edu
4321,Alice,95.0,alice@test.edu
1111,Eve,80.0,eve@test.edu
1121,Barry,85.0,barrytest.edu
1131,Harry,86.0,h@rry@test.edu
1121,Larry,87.0,larry@test.edu
1141,Jim Song,88.0,jim@song.edu
1151,Jerry,77.0,jerry@test.net
1161,James,65.0,james@test.com

最后六个输入应该导致异常，但我无法弄清楚如何组织它来工作。代码用＃符号忽略该行。

以下是成功输出的示例：

Number of valid input lines: 3
Number of invalid input lines: 0
Average grade: 89.0
1234, 92.0, Bob, bob@test.edu,
4321, 95.0, Alice, alice@test.edu,
1111, 80.0, Eve, eve@test.edu,

主要的变化应该是在orverride方法中请尽可能帮助，我坐在我的办公桌前仍然在思考可能性，并且您的帮助将受到最大的赞赏。

Answer 1

假设ParseException error字段为int且someMethod()引发ParseException：

try {
    someMethod();
} catch (final ParseExeption ex) {
    if (ex.getError() == ParseException.SOME_ERROR) {
        // do something
    } else if (ex.getError() == ParseException.OTHER_ERROR) {
        // do something else
    }
}

请注意，对特定错误使用特定异常通常会更好，例如SomeErrorParseException，OtherErrorParseException，...（如果需要，可以扩展ParseException）和try-catch像这样：

try {
    someMethod();
} catch (final SomeErrorParseException ex) {
    // do something
} catch (final OtherErrorParseException ex) {
    // do something else
}

一些阅读：http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html

Answer 2

似乎没有代码实际上首先导致catch子句。在读取文件时检测到错误时尝试添加throw new ParserException(STUFF_HERE);。

例外组织援助？

2 个答案: