I am trying to figure out what I did wrong in this assignment. My objective is to convert from infix to postfix and evaluate it. I can't seem to get the correct end result. The test class is correct and aside from the evaluateRPN class, everything else has no errors. Where am I going wrong and what should I do to correct it?


Java Code: 
package arithmetic;

import java.util.Stack;
import java.util.EmptyStackException;
import java.util.Scanner;


class Constants
{
    static char LEFT_NORMAL;
    static char RIGHT_NORMAL;

}
class Arithmetic
{
    Stack stk;
    String expression, postfix;
    int length;

    Arithmetic (String s)
    {
        expression = s;
        postfix = "";
        length = expression.length();
        stk = new Stack();
    }

    boolean isBalance()
    {

        boolean fail = false;

        try
        {
            stk.clear();

			stk.clear();

			for(int i=0; i<length; i++)
			{
				char token = expression.charAt(i);

				if(token == Constants.LEFT_NORMAL)
				{
					stk.push(new Character(token));
				}
				else if(token == Constants.RIGHT_NORMAL)
				{
					stk.pop();
				}
			}
        }
            catch (EmptyStackException e)
            {
              System.out.println(e.toString());
              fail = true;
            }
            if (stk.empty() && !fail)
                return true;
            else
                return false;
        
    }
    void postfixExpression()
    {
        Scanner scan = new Scanner(expression);
        char current;
        while (scan.hasNext())
        {
            String token = scan.next();
            if (isNumber(token))
                postfix = postfix + token + " ";
            else
            {
                current = token.charAt(0);
                if (isParentheses(current))
                {
                    if (stk.empty() || current == Constants.LEFT_NORMAL)
                        {
                            stk.push(new Character (current));
                        }
                
                else if (current == Constants.RIGHT_NORMAL)
                {
                    try
                    {
                        Character ch = (Character)stk.pop();
                        char top = ch.charValue();

                        while (top != Constants.LEFT_NORMAL)
                        {
                            postfix = postfix + top + " ";
                            ch = (Character)stk.pop();

                            top = ch.charValue();
                        }
                    }
                    catch(EmptyStackException e)
                    {
                    }
                }
            }
            else if (isOperator(current))
            {
                if(stk.empty())
                    stk.push(new Character(current));
                else
                {
                    try
                    {
                        char top = (Character)stk.peek();
                        boolean higher = hasHigherPrecedence(top, current);

                        while(top != Constants.LEFT_NORMAL && higher)
                        {
                            postfix = postfix + stk.pop() + " ";
                            top = (Character)stk.peek();
                        }
                        stk.push(new Character(current));
                    }
                    catch(EmptyStackException e)
                    {
                        stk.push(new Character(current));
                    }
                }
            }
        }
}
try
{
    while (!stk.empty())
    {
            postfix = postfix  + stk.pop() + " ";
    }
}
catch(EmptyStackException e)
{

}
}
boolean isNumber(String str)
{
		try
		{
			Integer.parseInt(str);
			return true;
		}
		catch(NumberFormatException e)
		{
			return false;
		}
}
boolean isParentheses(char current)
{
		if(current == Constants.LEFT_NORMAL || current == Constants.RIGHT_NORMAL)
		{
			return true;
		}
		else
		{
			return false;
		}
}
boolean isBracket(char current)
{
		if(current == Constants.LEFT_NORMAL || current == Constants.RIGHT_NORMAL)
		{
			return true;
		}
		else
		{
			return false;
		}
}
boolean isCurly(char current)
{
		if(current == Constants.LEFT_NORMAL || current == Constants.RIGHT_NORMAL)
		{
			return true;
		}
		else
		{
			return false;
		}
}
boolean isOperator(char ch)
{
		switch(ch)
		{
			case '+':
			case '-':
			case '*':
			case '/':
				return true;

			default:
				return false;
		}
}
boolean hasHigherPrecedence(char top, char current)
{
		int topPrecedence = 0;
		int currentPrecedence = 0;

		switch(top)
		{
			case '+':
			case '-':
				topPrecedence = 0;
				break;

			case '*':
			case '/':
				topPrecedence = 1;
				break;
		}

		switch(current)
		{
			case '+':
			case '-':
				currentPrecedence = 0;
				break;

			case '*':
			case '/':
				currentPrecedence = 1;
				break;
		}

		if(topPrecedence >= currentPrecedence)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

String getPostfix()
{
		stk.clear();
		Scanner scan = new Scanner(postfix);

		while(scan.hasNext())
		{
			String token = scan.next();
			char currentChar = token.charAt(0);

			if(isNumber(token))
			{
				stk.push(token);
			}
			else if(isOperator(currentChar))
			{
				int t1 = 0, t2 = 0;

				try
				{
					t1 = Integer.parseInt((String)stk.pop());
					t2 = Integer.parseInt((String)stk.pop());
				}
				catch(EmptyStackException e)
				{
					return "The expression was invalid!";
				}

				int t3 = 0;
				switch(currentChar)
				{
					case '+':
						t3 = t2 + t1;
						break;

					case '-':
						t3 = t2 - t1;
						break;

					case '*':
						t3 = t2 * t1;
						break;

					case '/':
						t3 = t2 / t1;
						break;
				}

				stk.push(new Integer(t3).toString());
			}
		}

		if(stk.size() == 1)
		{
			return stk.pop().toString();
		}
		else
		{
			String val = "";
			try
			{
				while(true)
				{
					val = val + stk.pop().toString();
				}
			}
			catch(EmptyStackException e)
			{
				return val;
			}
		}
}
public void evaluateRPN()
{
        Stack stk=new Stack();
        char ch;
            for(int i=0;i<expression.length();i++)
                {
                    ch=expression.charAt(i);
                    if(((int)expression.charAt(i))>=0&&((int)expression.charAt(i))<=9)
                    stk.push(i);

                    if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='%')
                    {
                        double t1=(double)(stk.pop());
                        double t2=(double)(stk.pop());

                        switch(ch)
                    {
                    case '+':value=t2+t1; break;
                    case '-':value=t2-t1; break;
                    case '*':value=t2*t1; break;
                    case '%':value=t2%t1; break;
                    case '/':value=t2/t1; break;
                    }
                    stk.push(value);
                    }

                }
        value=(double)sc.pop();
}
}

here is the test class
Java Code: 
package arithmetic;

class RPN
{
	public static void main(String[] arg)
	{
		String s[] = {"5 + ) * ( 2",
					  " (  { [ } ) ] ",
		              " 2 + ] - 3 * 5 [ ",
		              "[( 2 + 3 ) * 5] * 8 ",
		              "5 * 10 + ( 15 - 20 ) )  - 25",
		              "5 * { 10 + ( 15 - 20 ) }  - 25",
		              " 5 + [ 5 * { 10 + ( 15 - 20 ) }  - 25 ] * 9"
		             };
		for (int i = 0; i < s.length; i++)
		{

			Arithmetic a = new Arithmetic(s[i]);
			if (a.isBalance())
			{
				System.out.println("Expression " + s[i] + " is balanced\n");
				a.postfixExpression();
				System.out.println("The post fixed expression is : " + a.getPostfix());
				a.evaluateRPN();
				System.out.println("The result is : " + a.getResult()  + "\n" );
			}
			else
				System.out.println("Expression is not balanced\n");
		}
	}
}