来自接口类调用的未报告异常

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) { 
    ... 
}