InvalidCharacterException не перехватывает символы

Я выполняю задание для класса, который требует, чтобы я выдавал исключение RuntimeException, если пользователь вводит недопустимый символ. Эти входные данные будут использоваться для преобразования выражения в постфиксной нотации в инфиксную. Теперь мое задание выполнено, но я не могу заставить RuntimeException правильно поймать. Я попытался создать InvalidCharacterException, но это тоже ничего не улавливает.

Я спрашиваю, почему мой метод не ловит символы и не генерирует исключение. Вот мои классы для справки.

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();
   }
 } 

деревостроитель

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();
    }

}   
}

ИнвалидХарактерИсключение

public class InvalidCharacterException extends RuntimeException
{
private char c;

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

public char getCharacter()
{
    return c;
}
}

Класс узла

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;
}



}