java - 异常(exception)组织协助？

Question

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

所以我对这段代码束手无策。我对编程非常陌生，尤其是异常。我非常努力地浏览我的类(class) Material 并寻求帮助，但我一直很不成功。我正在尝试创建一个改进的解析器来覆盖另一个解析器。它读取一个 .txt 文件，其中包含学生信息，包括 ID、姓名、成绩、可选电子邮件地址和可选注释，作为以逗号分隔的字符串中的标记。覆盖检查每个标记中的错误并引发名为 ParserException 的异常。异常将检查代码，如果错误无法修复，则返回错误消息。

例如，如果学生输入了 AB 成绩，异常将标记并检查输入是否是有效成绩(确实如此)，然后返回，如果不是，则会抛出 ParserException ， 在这种情况下 抛出新的ParserException(ParserException.GRADE_INVALID_GRADE,lineIndex); 这表明该功能不起作用，并在 indexLine

行上发出消息 GRADE_INVALID

我有一个需要输出的列表:

• 任何违反上面输入文件格式描述部分中指定的文件格式的行为都会导致 ParcerException 并显示相应的消息

• 不允许使用重复的 ID

• 成绩值必须是 float (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 方法中 如果可以的话请提供帮助，我坐在办公 table 前仍在思考各种可能性，非常感谢您的帮助。

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