InvalidCharacterException fängt keine Zeichen

Question

Ich mache eine Zuweisung für eine Klasse, die eine RuntimeException auslösen muss, wenn ein ungültiges Zeichen vom Benutzer eingegeben wird. Diese Eingabe wird verwendet, um einen Ausdruck in Postfix-Notation in Infix zu konvertieren. Jetzt habe ich meine Aufgabe abgeschlossen, aber ich kann die RuntimeException nicht richtig fangen. Ich habe versucht, eine InvalidCharacterException zu erstellen, aber das fängt auch nichts ein.

Was ich frage ist, warum meine Methode ist Zeichen und werfen eine Ausnahme Hier sind meine Klassen Referenz

postfixExpression

import javax.swing.*; 
import java.awt.*; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.awt.event.WindowAdapter; 
import java.awt.event.WindowEvent; 
import java.io.*; 
import java.util.*; 

public class postfixExpression extends JPanel 
{ 
    private JFrame frame;//The frame 
    private JPanel panel;//The panel 
    private JLabel enterPostfix; 
    private JTextField postfixExpression; 
    private JButton construct; 
    private JButton blank; 
    private JLabel results; 
    private JTextField resultsDisplay; 





    //Builds the GUI 
    public postfixExpression() 
    { 
     frame=new JFrame("Three Address Generator"); 
     panel=new JPanel(); 
     enterPostfix=new JLabel("Enter Postfix Expression"); 
     postfixExpression=new JTextField(""); 
     construct=new JButton("Construct Tree"); 
     blank=new JButton(); 
     results=new JLabel("Infix Expression"); 
     resultsDisplay=new JTextField(""); 







     construct.addActionListener(new ActionListener() 
     { 
      public void actionPerformed(ActionEvent e) 
      { 
       try 
       { 
        String expression=postfixExpression.getText(); 
        char[] charArray=expression.toCharArray(); 
        treeBuilder et=new treeBuilder(); 
        Node root=et.buildTree(charArray); 
        resultsDisplay.setText(treeBuilder.inorder(root)); 
        root=et.insertRegisters(charArray); 
        et.writeInstructions(root); 
       } 
       catch(InvalidCharacterException i) 
       { 
        JOptionPane.showMessageDialog(null, "Invalid character"); 
       } 

      } 
     }); 



      //Adding the parts together 
     panel.setLayout(new GridLayout(3,2)); 
     panel.add(enterPostfix); 
     panel.add(postfixExpression); 
     panel.add(construct); 
     panel.add(blank); 
     panel.add(results); 
     panel.add(resultsDisplay); 
     frame.add(panel); 
     frame.pack(); 
     frame.setLocationRelativeTo(null); 
     frame.setSize(600,300); 
     frame.setBackground(Color.red); 
     frame.setVisible(true);; 





    }   






    //Main method 
    public static void main(String[] args) 
    { 
     postfixExpression myGUI=new postfixExpression(); 
    } 
} 

TreeBuilder

import java.io.*; 
import java.util.*; 
public class treeBuilder 
{ 

//Checks if the current character is an operator 
public boolean isOperator(char c) 
{ 
    return Character.isDigit(c); 
} 

//Checks if the current character is an Integer 
public boolean isInteger(char c) 
{ 
    int test=Character.getNumericValue(c); 
    Integer test2=(Integer)test; 

    if(test2 instanceof Integer) 
    { 
     return true; 
    } 
    return false; 
} 
public static String inorder(Node t) 
{ 
    if(t!=null) 
    { 
     return "("+inorder(t.getLeft())+t.getValue()+" "+inorder(t.getRight())+")"; 
    } 
    return ""; 
} 

public Node buildTree(char postFix[]) throws RuntimeException 
{ 
    Stack<Node> nodeStack=new Stack<Node>(); 
    Node tree=null; 
    Node t1=null; 
    Node t2=null; 

    for(int i=0;i<postFix.length;i++) 
    { 
     if(!isOperator(postFix[i])&&!isInteger(postFix[i])) 
     { 
      throw new InvalidCharacterException(postFix[i]); 

     } 
     if(!isOperator(postFix[i])) 
     { 
      tree=new Node(postFix[i]); 
      nodeStack.push(tree); 
     } 
     else if(isOperator(postFix[i])) 
     { 
      tree= new Node(postFix[i]); 
      t1=nodeStack.pop(); 
      t2=nodeStack.pop(); 
      tree.setRight(t1); 
      tree.setLeft(t2); 
      nodeStack.push(tree); 
     } 
     else if(!isOperator(postFix[i])&& !isInteger(postFix[i])) 
     { 
      throw new InvalidCharacterException(postFix[i]); 
     } 


    } 
    tree=nodeStack.pop(); 
    return tree; 
} 


public Node insertRegisters(char[] postFix) 
{ 
    Stack<Node> nodeStack=new Stack<Node>(); 
    Node tree=null; 
    Node t1=null; 
    Node t2=null; 
    int registerCount=0; 
    for(int i=0;i<postFix.length;i++) 
    { 
     if(!isOperator(postFix[i])) 
     { 
      tree=new Node(postFix[i]); 
      nodeStack.push(tree); 
     } 
     else if(isOperator(postFix[i])) 
     { 
      tree = new Node(postFix[i], "R" + registerCount++); 
      t1 = nodeStack.pop(); 
      t2 = nodeStack.pop(); 
      tree.setRight(t1); 
      tree.setLeft(t2); 
      nodeStack.push(tree); 
     } 

    } 
    return tree; 
} 


public String writeInstructionsHelper(Node root) 
{ 
    String str=""; 
    if(root != null) 
    { 
     if(root.getLeft()!=null && root.getLeft().getRegister() !=null) 
     { 
      str += writeInstructionsHelper(root.getLeft()); 
     } 
     if(root.getRight()!=null && root.getRight().getRegister() !=null) 
     { 
      str += writeInstructionsHelper(root.getRight()); 
     } 

     String instructions=null; 
     if(root.getValue()=='+') 
     { 
      instructions="Add"; 
     } 
     else if(root.getValue()=='-') 
     { 
      instructions="Sub"; 
     } 
     else if(root.getValue()=='*') 
     { 
      instructions="Mul"; 
     } 
     else if(root.getValue()=='/') 
     { 
      instructions="Div"; 
     } 

     if(root.getRegister()==null) 
     { 
      str+=root.getValue(); 
     } 
     else 
     { 
      str += instructions + " "; 
      str += root.getRegisterOrValue() + " "; 
      str += root.getLeft().getRegisterOrValue() + " "; 
      str += root.getRight().getRegisterOrValue(); 
     } 
    } 
    str+="\r\n"; 
    return str; 
} 

public void writeInstructions(Node root) 
{ 
    String file="myFile.txt"; 
    try 
    { 
     String instructions = writeInstructionsHelper(root); 
     PrintWriter outputStream = new PrintWriter(file); 
     outputStream.println(instructions); 
     outputStream.flush(); 
     outputStream.close(); 
    } 
    catch(FileNotFoundException e) 
    { 
     e.printStackTrace(); 
    } 

} 
} 

InvalidCharacterException nicht fangen

public class InvalidCharacterException extends RuntimeException 
{ 
private char c; 

public InvalidCharacterException(char c) 
{ 
    this.c=c; 
} 

public char getCharacter() 
{ 
    return c; 
} 
} 

Node-Klasse

public class Node 
{ 
private char value; 
private String register; 
private Node left; 
private Node right; 

public Node(char value) 
{ 
    this.value=value; 
    left=null; 
    right=null; 
    register=null; 
} 
public Node(char value, String register) 
{ 
    this.value = value; 
    this.register = register; 
    left = null; 
    right = null; 
} 
public char getValue() { 
    return value; 
} 

public void setValue(char value) { 
    this.value = value; 
} 

public String getRegister() { 
    return register; 
} 

public void setRegister(String register) { 
    this.register = register; 
} 

public Node getLeft() { 
    return left; 
} 

public void setLeft(Node left) { 
    this.left = left; 
} 

public Node getRight() { 
    return right; 
} 

public void setRight(Node right) { 
    this.right = right; 
} 

public String getRegisterOrValue() 
{ 
    if (register == null) 
    { 
     return "" + value; // must convert to string 
    } 
    else 
    { 
     return register; 
    } 
} 



public String toStringHelper(int indents) { 
    String str = ""; 

    str += "value: " + value + "\n"; 

    for (int i = 0; i < indents; i++) { 
     str += "\t"; 
    } 
    if (left == null) 
     str += "LEFT: null\n"; 
    else 
     str += "LEFT: " + left.toStringHelper(indents + 1) + "\n"; 

    for (int i = 0; i < indents; i++) { 
     str += "\t"; 
    } 
    if (right == null) 
     str += "RIGHT: null\n"; 
    else 
     str += "RIGHT: " + right.toStringHelper(indents + 1) + "\n"; 

    return str; 
} 



} 

Answer 1

Ihre isInteger Methode immer zurückkehrt wahr. Sie werden also keine ungültigen Zeichen entdecken und daher niemals Ihre Ausnahme werfen.

Wie kann das sein? Für die meisten ungültigen Zeichen gibt Character.getNumericValue(c) -1 zurück. Sie konvertieren diese Nummer in eine Integer Instanz und testen dann, ob es sich um eine Integer handelt. Es ist. Es wird sogar zu einer Ganzzahl erklärt, so dass der Test niemals fehlschlagen kann. Ihre Methode gibt also true zurück. Zurück in Ihrer buildTree Methode wird die if Bedingung falsch sein und Ihre throw Anweisung nicht erreicht.

Meine sofortige Idee für eine Korrektur wäre in der isInteger Methode, false zurückgeben, wenn Sie ein negatives Ergebnis von Character.getNumericValue(c) erhalten. Vielleicht möchten Sie die Dokumentation dieser Methode noch einmal lesen, bevor Sie eine endgültige Entscheidung treffen.