來自接口類調用的未報告異常

Question

我正在研究一個將中綴表達式轉換爲後綴的初學者java應用程序，然後對它們進行評估。我花了很多時間試圖修復以下錯誤消息：

Interface.java:21: error: unreported exception SyntaxErrorException; must be caught or declared to be thrown 

String conversion = infix.convert(str); 
                   ^
Interface.java:22: error: unreported exception SyntaxErrorException; must be caught or declared to be thrown 

System.out.println(postfix.eval(conversion)); 
                  ^
2 errors 

你能幫我解決這些錯誤嗎？我一直在搞try/catch語句和移動SyntaxErrorException類，但我還沒有運氣。這裏是到目前爲止我的程序：

Interface.java

import java.util.*; 

/** 
* Interface: 
*/ 
class Interface { 
    /** 
    * 
    */ 
    public static void main(String [ ] args) 
    { 
     String str = ""; 
     Scanner keyboard = new Scanner (System.in);   
     InfixToPostfix infix = new InfixToPostfix(); 
     PostfixEvaluator postfix = new PostfixEvaluator(); 

     System.out.println("Enter expressions, one per line:"); 
      while((str = keyboard.next()) != null) 
      { 
       System.out.println("Read: " + str); 
       String conversion = infix.convert(str); 
       System.out.println(postfix.eval(conversion)); 
       System.out.println("Enter next expression:"); 
      } 
    } 
} 

InfixToPostfix.java

import java.util.*; 

/** 
* Translates an infix expression to a postfix expression. 
*/ 

public class InfixToPostfix { 

    // Nested Class 
    /** Class to report a syntax error. */ 
    public static class SyntaxErrorException 
     extends Exception { 
    /** Construct a SyntaxErrorException with the specified 
     message. 
     @param message The message 
    */ 
    SyntaxErrorException(String message) { 
     super(message); 
    } 
    } 

    // Data Fields 
    /** The operator stack */ 
    private Stack <Character> operatorStack; 

    /** The operators */ 
    private static final String OPERATORS = "+-*/"; 

    /** The precedence of the operators, matches order in OPERATORS. */ 
    private static final int[] PRECEDENCE = { 
     1, 1, 2, 2}; 

    /** The postfix string */ 
    private StringBuilder postfix; 

    /** Convert a string from infix to postfix. 
     @param infix The infix expression 
     @throws SyntaxErrorException 
    */ 
    public String convert(String infix) throws SyntaxErrorException { 
    operatorStack = new Stack <Character>(); 
    postfix = new StringBuilder(); 
    StringTokenizer infixTokens = new StringTokenizer(infix); 
    try { 
     // Process each token in the infix string. 
     while (infixTokens.hasMoreTokens()) { 
     String nextToken = infixTokens.nextToken(); 
     char firstChar = nextToken.charAt(0); 
     // Is it an operand? 
     if (Character.isJavaIdentifierStart(firstChar) 
      || Character.isDigit(firstChar)) { 
      postfix.append(nextToken); 
      postfix.append(' '); 
     } // Is it an operator? 
     else if (isOperator(firstChar)) { 
      processOperator(firstChar); 
     } 
     else { 
      throw new SyntaxErrorException 
       ("Unexpected Character Encountered: " 
       + firstChar); 
     } 
     } // End while. 

     // Pop any remaining operators and 
     // append them to postfix. 
     while (!operatorStack.empty()) { 
     char op = operatorStack.pop(); 
     postfix.append(op); 
     postfix.append(' '); 
     } 
     // assert: Stack is empty, return result. 
     return postfix.toString(); 
    } 
    catch (EmptyStackException ex) { 
     throw new SyntaxErrorException 
      ("Syntax Error: The stack is empty"); 
    } 
    } 

    /** Method to process operators. 
     @param op The operator 
     @throws EmptyStackException 
    */ 
    private void processOperator(char op) { 
    if (operatorStack.empty()) { 
     operatorStack.push(op); 
    } 
    else { 
     // Peek the operator stack and 
     // let topOp be top operator. 
     char topOp = operatorStack.peek(); 
     if (precedence(op) > precedence(topOp)) { 
     operatorStack.push(op); 
     } 
     else { 
     // Pop all stacked operators with equal 
     // or higher precedence than op. 
     while (!operatorStack.empty() 
       && precedence(op) <= precedence(topOp)) { 
      operatorStack.pop(); 
      postfix.append(topOp); 
      postfix.append(' '); 
      if (!operatorStack.empty()) { 
      // Reset topOp. 
      topOp = operatorStack.peek(); 
      } 
     } 
     // assert: Operator stack is empty or 
     //   current operator precedence > 
     //   top of stack operator precedence. 
     operatorStack.push(op); 
     } 
    } 
    } 

    /** Determine whether a character is an operator. 
     @param ch The character to be tested 
     @return true if ch is an operator 
    */ 
    private boolean isOperator(char ch) { 
    return OPERATORS.indexOf(ch) != -1; 
    } 

    /** Determine the precedence of an operator. 
     @param op The operator 
     @return the precedence 
    */ 
    private int precedence(char op) { 
    return PRECEDENCE[OPERATORS.indexOf(op)]; 
    } 
} 

PostfixEvaluator.java

import java.util.*; 

/** 
* Class that can evaluate a postfix expression. 
* */ 

public class PostfixEvaluator { 

    // Nested Class 
    /** Class to report a syntax error. */ 
    public static class SyntaxErrorException 
     extends Exception { 
    /** Construct a SyntaxErrorException with the specified 
     message. 
     @param message The message 
    */ 
    SyntaxErrorException(String message) { 
     super(message); 
    } 
    } 

    // Constant 
    /** A list of operators. */ 
    private static final String OPERATORS = "+-*/"; 

    // Data Field 
    /** The operand stack. */ 
    private Stack <Integer> operandStack; 

    // Methods 
    /** Evaluates the current operation. 
     This function pops the two operands off the operand 
     stack and applies the operator. 
     @param op A character representing the operator 
     @return The result of applying the operator 
     @throws EmptyStackException if pop is attempted on 
       an empty stack 
    */ 
    private int evalOp(char op) { 
    // Pop the two operands off the stack. 
    int rhs = operandStack.pop(); 
    int lhs = operandStack.pop(); 
    int result = 0; 
    // Evaluate the operator. 
    switch (op) { 
     case '+': 
     result = lhs + rhs; 
     break; 
     case '-': 
     result = lhs - rhs; 
     break; 
     case '/': 
     result = lhs/rhs; 
     break; 
     case '*': 
     result = lhs * rhs; 
     break; 

    } 
    return result; 
    } 

    /** Determines whether a character is an operator. 
     @param op The character to be tested 
     @return true if the character is an operator 
    */ 
    private boolean isOperator(char ch) { 
    return OPERATORS.indexOf(ch) != -1; 
    } 

    /** Evaluates a postfix expression. 
     @param expression The expression to be evaluated 
     @return The value of the expression 
     @throws SyntaxErrorException if a syntax error is detected 
    */ 
    public int eval(String expression) throws SyntaxErrorException { 
    // Create an empty stack. 
    operandStack = new Stack <Integer>(); 

    // Process each token. 
    StringTokenizer tokens = new StringTokenizer(expression); 
    try { 
     while (tokens.hasMoreTokens()) { 
     String nextToken = tokens.nextToken(); 
     // Does it start with a digit? 
     if (Character.isDigit(nextToken.charAt(0))) { 
      // Get the integer value. 
      int value = Integer.parseInt(nextToken); 
      // Push value onto operand stack. 
      operandStack.push(value); 
     } // Is it an operator? 
     else if (isOperator(nextToken.charAt(0))) { 
      // Evaluate the operator. 
      int result = evalOp(nextToken.charAt(0)); 
      // Push result onto the operand stack. 
      operandStack.push(result); 
     } 
     else { 
      // Invalid character. 
      throw new SyntaxErrorException(
       "Invalid character encountered"); 
     } 
     } // End while. 

     // No more tokens - pop result from operand stack. 
     int answer = operandStack.pop(); 
     // Operand stack should be empty. 
     if (operandStack.empty()) { 
     return answer; 
     } 
     else { 
     // Indicate syntax error. 
     throw new SyntaxErrorException(
      "Syntax Error: Stack should be empty"); 
     } 
    } 
    catch (EmptyStackException ex) { 
     // Pop was attempted on an empty stack. 
     throw new SyntaxErrorException(
      "Syntax Error: The stack is empty"); 
    } 
    } 
} 

預先感謝任何有用的提示或解決方案。

Answer 1

錯誤告訴你有一個checked exception that you haven't handled。 「檢查」意味着編譯器強制你對它做某些事情，並且你不能忽略它。您必須使用try/catch塊來捕獲它，或者聲明發生問題的方法會引發此異常。在這種情況下，您的主要方法是調用convert（）和eval（），兩者都會拋出SyntaxErrorException。這意味着你需要在convert（）和eval（）的main方法中使用try/catch，否則main必須聲明throws SyntaxErrorException。

編輯：啊，我沒有仔細看。你的問題是你有兩個不同的SyntaxErrorExceptions，雖然錯誤信息只給你簡單的類名，使得很難區分。你真的需要兩個不同的例外嗎？他們具有相同名稱的事實意味着沒有。無論如何，在你目前的情況下，你只需要確保處理兩個例外。無論是

public static void main(String[] args) throws InfixToPostfix.SyntaxErrorException, PostfixEvaluator.SyntaxErrorException { 

或

try { 
    String conversion = infix.convert(str); 
    System.out.println(postfix.eval(conversion)); 
} catch (InfixToPostfix.SyntaxErrorException e) { 
    ... 
} catch (PostfixEvaluator.SyntaxErrorException e) { 
    ... 
}