I have written a program to convert Infix to Postfix and evaluate the expression in java

I'm writing a program that reads an Infix notation, converts it to Postfix and then evaluates that Postfix. This program takes an expression fully parenthesized or not fully parenthesized and after it evaluates. Here's my program:

  import java.util.Stack;
  import java.util.Scanner;
  import java.util.regex.Pattern;
  import java.util.*;

public class ConvertDemonstration
{
private static final char ADD = '+', SUBTRACT = '-';
        private static final char MULTIPLY = '*', DIVIDE = '/';
        private static final char POWER ='^';

    public ConvertDemonstration(){

    }
// Private methods:

   private static boolean isOperator(char c) { // Tell whether c is an operator.

     return c == '+'  ||  c == '-'  ||  c == '*'  ||  c == '/'  ||  c == '^'
           || c=='(' || c==')';

   }//end isOperator



   private static boolean isSpace(char c) {  // Tell whether c is a space.

     return (c == ' ');

   }//end isSpace


   private static boolean lowerPrecedence(char op1, char op2) {
      // Tell whether op1 has lower precedence than op2, where op1 is an
      // operator on the left and op2 is an operator on the right.
      // op1 and op2 are assumed to be operator characters (+,-,*,/,^).

      switch (op1) {

         case '+':
         case '-':
            return !(op2=='+' || op2=='-') ;

         case '*':
         case '/':
            return op2=='^' || op2=='(';

         case '^':
            return op2=='(';

         case '(': return true;

         default:  // (shouldn't happen)
            return false;
      }

   } // end lowerPrecedence


// Method to convert infix to postfix:

   public static String convertToPostfix(String infix) {
          Stack operatorStack = new Stack();
     char c;
     StringTokenizer parser = new StringTokenizer(infix,"+-*/^() ",true);
     StringBuffer postfix = new StringBuffer(infix.length());
        while (parser.hasMoreTokens()) {
           String token = parser.nextToken();
           c = token.charAt(0);
           if ( (token.length() == 1) && isOperator(c) ) {
              while (!operatorStack.empty() &&
                  !lowerPrecedence(((String)operatorStack.peek()).charAt(0), c))

                 postfix.append(" ").append((String)operatorStack.pop());
              if (c==')') {
                    String operator = (String)operatorStack.pop();
                    while (operator.charAt(0)!='(') {
                       postfix.append(" ").append(operator);
                       operator = (String)operatorStack.pop();
                    }
              }
              else
                 operatorStack.push(token);
           }
           else if ( (token.length() == 1) && isSpace(c) ) {
               }
           else {
             postfix.append(" ").append(token);
           }
         }
        while (!operatorStack.empty())
           postfix.append(" ").append((String)operatorStack.pop());

        return postfix.toString();
   }

public static int evaluate(String expr) {
         //   assert (isValid(expr));

           Stack stack = new Stack();
            int op1, op2, result = 0;
            String token;
            StringTokenizer tokenizer = new StringTokenizer(expr);

            while (tokenizer.hasMoreTokens()) {
                token = tokenizer.nextToken();
                char c = token.charAt(0);
                if (isOperator(c)) {
                    op2 = ((Integer) stack.pop()).intValue();
                    op1 = ((Integer) stack.pop()).intValue();
                    result = evalSingleOp(token.charAt(0), op1, op2);
                    stack.push(new Integer(result));
                }
                else
                    stack.push(new Integer(Integer.parseInt(token)));
            }

            result = ((Integer) stack.pop()).intValue();
            return result;
        }

   public static int evalSingleOp(char operation, int op1, int op2) {
            int result = 0;

            switch (operation) {
                case ADD :
                    result = op1 + op2;
                    break;
                case SUBTRACT :
                    result = op1 - op2;
                    break;
                case MULTIPLY :
                    result = op1 * op2;
                    break;
                case DIVIDE :
                    result = op1 / op2;
                case POWER :
                    result = (int) Math.pow(op1,op2);
            }

            return result;
        }



public static void main(String[ ] args)
{
   Scanner stdin = new Scanner(System.in);
   String expression;
   String answer, answer1;

  System.out.println("Please type an arithmetic expression made from");
  System.out.println("unsigned numbers and the operations + - * /.");
  System.out.println("The expression can be fully parenthesized or cannot be.");

  do
  {
     System.out.print("Your expression: ");
     expression = stdin.nextLine( );
     try
     {
        answer = convertToPostfix(expression);
        System.out.println("The result is " + answer);

        answer1 = evaluate(answer);
        System.out.println(" The result is" + answer1);



     }
     catch (Exception e)
     {
        System.out.println("Error." + e.toString( ));
     }
  }
  while (query(stdin, "Another string?"));

  System.out.println("All numbers are interesting.");
}


public static boolean query(Scanner input, String prompt)
{
  String answer;

  System.out.print(prompt + " [Y or N]: ");
  answer = input.nextLine( ).toUpperCase( );
  while (!answer.startsWith("Y") && !answer.startsWith("N"))
  {
     System.out.print("Invalid response. Please type Y or N: ");
     answer = input.nextLine( ).toUpperCase( );
  }

  return answer.startsWith("Y");
 }
 }

error : incompatible types: int cannot be converted to String answer1 = evaluate(answer);