Duvida com Algoritmo!

package CalculadoraPolonesa;

public class Calculadora {

    private Fila fila;
    private Pilha pilha;

    public Calculadora() {
        fila = new Fila();
        pilha = new Pilha();
    }

    /**
     * Testa a prioridade dos Operadores.
     *
     * @param Object object
     * @return inteiro
     */
    private int ObterPrioridade(Object object) {
        int retorno = 0;
        String pri1 = "+-";
        String pri2 = "*/";
        if ("(".equals(object.toString())) {
            retorno = 1;
        } else if (pri1.indexOf(object.toString()) >= 0) {
            retorno = 2;
        } else if (pri2.indexOf(object.toString()) >= 0) {
            retorno = 3;
        } else if ("^".equals(object.toString())) {
            retorno = 4;
        }
        return retorno;
    }

    /**
     * Testa se é um Numero.
     *
     * @param String digit
     * @return True or False
     */
    public static boolean isADigit(String digit) {

        return digit.matches("^[0-9]{1,3}$");

    }

    /**
     * Testa se é Um Operador.
     *
     * @param String ch
     * @return True or False
     */
    private boolean operador(String ch) {

        return ch.matches("[+|\\-|*|/|^]");

    }

    /**
     * Converte a expressao de forma Infixa para Poxfixa
     *
     * @param String expInfixa
     */
    private void ConverterPosFixa(String expInfixa) {
        String item;
        expInfixa.trim();
        String[] caracter = expInfixa.split("");
        int prioridade = 0;

        /*
         * Varre todos os elementos da expressao de entrada e, para cada
         * elemento, verifica se e operador ou parenteses adiciona a pilha. Se
         * for operando adicona a fila.
         */
        for (int i = 1; i <= expInfixa.length(); i++) {


            if ((isADigit(caracter[i])) && (!caracter[i].matches("[(|)]"))) {

                fila.enqueue(caracter[i]);

            } else if (operador(caracter[i])) {
                prioridade = ObterPrioridade(caracter[i]);
                while ((pilha.getLength() != 0) && (ObterPrioridade((pilha.peek())) >= prioridade)) {

                    fila.enqueue(pilha.pop().toString());

                }

                // Insere o objeto no topo da pilha
                pilha.push(caracter[i]);
            } else if ("(".equals(caracter[i])) {
                // Insere o objeto no topo da pilha
                pilha.push(caracter[i]);
            } else if (")".equals(caracter[i])) {
                item = pilha.pop().toString();

                fila.enqueue(item);

                while (!item.equals("(") && !pilha.isEmpty()) {
                // Recupera e remove o objeto do topo da pilha
                    item = pilha.pop().toString();

                }
            }
        }
        /**
         * Desimpilha todos Objetos e insere na Fila.
         */
        while (!pilha.isEmpty()) {

            fila.enqueue(pilha.pop().toString());

        }

    }

    /**
     * Avalia uma expressao na forma infixa, mas antes de avaliar, converte-a
     * para forma posfixa.
     *
     * @param String expInfixa
     * @return resultado da expressao
     * @throws Exception
     */
    public String AvaliarExpressao(String expInfixa) throws Exception {

        ConverterPosFixa(expInfixa);

        while (!fila.vazia()) {


            if (isADigit(fila.topoFila().toString())) {
                pilha.push(fila.equeue().toString());
            } else {
                if (operador(fila.topoFila().toString())) {
                    double y = Double.parseDouble(pilha.pop().toString());
                    double x = Double.parseDouble(pilha.pop().toString());
                    switch (fila.equeue().toString()) {
                        case "+":
                            pilha.push((x + y));
                            break;
                        case "-":
                            pilha.push((x - y));
                            break;
                        case "*":
                            pilha.push((x * y));
                            break;
                        case "/":
                            pilha.push((x / y));
                            break;
                        case "^":
                            pilha.push((Math.pow(x, y)));
                            break;
                    }
                }
            }
        }
        return pilha.pop().toString();
    }
}