Rodando o programa há um erro que não sei resolver...SUPER URGENTE

Alguns problemas foram resolvidos aki no fórum, mas agora quando vou rodar o programa da um erro do qual não sei o que pode ser…
O programa criado como entrada é o seguinte…
2 8 8 + +
( ( 8 * 2 ) + ( 7 + 9 ) )
( 9 + 3 + 4 * 2 / 12 - 3 )

Por favor se puderem me ajudar ficarei super agradecido, faz parte de um projeto que tenho que entregar na facul, mas encontrei alguns obstáculos…

obrigado.

[code]import java.io.;
import java.nio.
;
import java.util.*;

public class LeTokensArquivo {
public static void main(String[]args) {

    //Abrindo arquivo
    File arq = new File("F:\Project-02\entrada.txt");
    File arq2 = new File("F:\Project-02\saida.txt");
    String[] operadores = {"+", "-", "*", "/", "r", "e"};
    PilhaS ps = new PilhaS(50);
    Pilha p = new Pilha(50);
    StringTokenizer st;
    String temp = null, temp2, operador, valida, res;
    Double resultado, op2, op1;
    try {
        //cria buffer de leitura
        BufferedReader br = new BufferedReader(new FileReader(arq));
        BufferedWriter bw = new BufferedWriter(new FileWriter(arq2));
        String s;
        //lê as linhas do arquivo e imprime-as na tela
        s = br.readLine(); // Ler linha.
        
        while(s != null) {
            st = new StringTokenizer(s);
            while(st.hasMoreTokens()) //Verifica se existe algum token que ainda não foi separado.
                temp = (st.nextToken()); // "pega" o próximo token.
                if(temp.equals("(")){
                    while(st.hasMoreTokens()){
                        temp = st.nextToken();
                        if(temp.equals(")")){
                            op1 = Double.valueOf(ps.desempilhar());
                            operador = ps.desempilhar();
                            op2 = Double.valueOf(ps.desempilhar());
                            temp2 = ps.desempilhar();
                            resultado = calculadora.infixa(ps, p);
                            PrintWriter saida = new PrintWriter(bw);
                            saida.println(resultado);
                        }
                        else{
                            ps.empilhar(temp);
                        }
                    }
                }
                else{
                    p.empilhar(Double.valueOf(temp));
                    while(st.hasMoreTokens()){
                        temp = (st.nextToken());
                        for(int i = 0; i < operadores.length; i++){
                            if(temp.equals(operadores[i])){
                                while(st.hasMoreTokens()){
                                    ps.empilhar(temp);
                                    temp = st.nextToken();
                                }
                                resultado = calculadora.posfixa(ps, p);
                                PrintWriter saida = new PrintWriter(bw);
                                saida.println(resultado);
                            }
                            else{
                                p.empilhar(Double.valueOf(temp));
                            }
                        }
                    }
                }   
            s = br.readLine();
        }
        //fecha o buffer de leitura que também fecha o arquivo de leitura.
        br.close();
        bw.close();
        
    }
    catch(FileNotFoundException el) {
        //caso o arquivo não exista
        System.out.println("Arquivo não existe" + arq);
    }
    catch(IOException e2) {
        //caso seja detectado algum outro erro de IO
        e2.printStackTrace();
    }
}

}[/code]

[code]public class calculadora
{
public static Double posfixa(PilhaS ps, Pilha p)
{
PilhaS ps2 = new PilhaS(50);
Double op1, op2, resultado;
String op, temp;

    while(!ps.pilhaVazia()){
        temp = ps.desempilhar();
        ps2.empilhar(temp);
    }
    op1 = p.desempilhar();
    op = ps2.desempilhar();
    if(op.equals("r")){
        resultado = poperacao(op, op1, p);
    }
    else{
        op2 = p.desempilhar();
        resultado = poperacao(op, op1, op2, p);
    }
    do{
        if(p.pilhaVazia()){
            op = ps2.desempilhar();
            op2 = p.desempilhar();
            resultado = poperacao(op, resultado, op2, p);
        }
        else{
            return resultado;
        }
    }while(

public static Double poperacao(String operador, Double op1, Pilha pilha){ //Converter os parametros para o objeto Double
    return poperacao(operador, op1, null, p);
}                  //Pegar resultado e fazer a próxima operação.

public static Double poperacao(String operador, Double op1, Double op2, Pilha pilha)
{
    Double exp = new Double(1), resultado = new Double(0);
    double pot = 0;
    String []op = {"+","-","*","/","p","r","0"};
    for(int i = 0; i < op.length; i++)
    {
        if(operador.equals(op[i]))
        {
                switch(i)
                {
                    case 0:
                        resultado = op1 + op2;
                        pilha.empilhar(resultado);
                        break;
                    case 1:
                        resultado = op1 - op2;
                        pilha.empilhar(resultado);
                        break;
                    case 2:
                        resultado = op1 * op2;
                        pilha.empilhar(resultado);
                        break;
                    case 3:
                        resultado = op1 / op2;
                        pilha.empilhar(resultado);
                        break;
                    case 4:
                        for(int j = 0; j < op2; j++){
                            pot = pot * op1;}
                        resultado = pot;
                        pilha.empilhar(resultado);
                        break;
                    case 5:
                        resultado = Math.sqrt(op1);
                        pilha.empilhar(resultado);
                        break;

                  }
             }
       }
     return resultado;
 }

// Usando "D"ouble pode-se receber um valor nulo.
/*public static Double operacao(String operador, Double op1){
return operacao(operador, op1, null); */
// usar .equals quando usar classe.
public static Double infixa()
{
Double op1;
String operador;
String sair;
Double op2;
op1 = EntradaDados.real(“Digite o 1º operando”);

    do{
    operador = EntradaDados.string("Digite o operador");
    
    if(operador.equals("r"))
    {
        System.out.print(operacao(operador,op1));
    }
    op2 = EntradaDados.real("Digite o 2º operando");

    
        
    do{
     sair = EntradaDados.string("Deseja Sair(s/n)");   
     }while(!(sair.equals("n") || sair.equals("s")));
     op1 = operacao(operador,op1,op2);
    }while(sair.equals("n"));
    return op1;

}

 public static Double operacao(String operador, Double op1){
    return operacao(operador, op1, null);
}




public static Double operacao(String operador, Double op1, Double op2)
{
    Double exp = new Double(1), resultado = new Double(0);
   
    String []op = { "+", "-", "*",  "/", "e", "r"};

        for(int i = 0; i < op.length; i++) // o int só é usado dentro do "for", quando sair do "for" o int será descartado.
        {
            if(operador.equals(op[i]))
            {
                    switch(i)
                    {
                        case 0:
                            resultado = op1 + op2;
                            break;
                        case 1:
                            resultado = op1 - op2;
                            break;
                        case 2:
                            resultado = op1 * op2;
                            break;
                        case 3:
                            resultado = op1 / op2;
                            break;
                        case 4:
                            for(int j = 0; j < op2; j++)
                            {
                                exp = exp * op1;
                            }
                            resultado = exp;
                            break;
                        case 5:
                            resultado = Math.sqrt(op1);
                            break;

                      }
                 }
           }
     return resultado;
 }

}
[/code]

[code]import javax.swing.*;

public class EntradaDados {

public static int inteiro(String msg) {
  
  String s;
  int num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null, msg, "Entrada de dados", 
                    JOptionPane.QUESTION_MESSAGE);            
    try {
      num = Integer.parseInt(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um inteiro",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static int inteiro() {
  
  String s;
  int num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null,"Digite um número inteiro","Entrada de dados",
                    JOptionPane.QUESTION_MESSAGE);           
    try {
      num = Integer.parseInt(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um inteiro",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static double real(String msg) {
  
  String s;
  double num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null, msg, "Entrada de dados",
                    JOptionPane.QUESTION_MESSAGE);            
    try {
      num = Double.parseDouble(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um número real",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static double real() {
  
  String s;
  double num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null, "Digite um ponto flutuante", "Entrada de dados",
                    JOptionPane.QUESTION_MESSAGE);             
    try {
      num = Double.parseDouble(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um número real",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static String string(String msg) {
  
    String s;
  
    s = JOptionPane.showInputDialog(null, msg, "Entrada de dados", 
                    JOptionPane.QUESTION_MESSAGE);               
    return s;
  }
  
  public static String string() {
  
    String s;
  
    s = JOptionPane.showInputDialog(null, "Digite uma cadeia de caracteres", "Entrada de dados", 
                    JOptionPane.QUESTION_MESSAGE);           
    return s;
  }  

}
[/code]

[code]public class PilhaS
{
private String p[];
private int topo = -1;

public PilhaS(int tamanho)
{
    p = new String[tamanho];
}

public boolean pilhaVazia()
{
    if(topo == -1)
    {
        System.out.println("Pilha Vazia");
        return true;
    }
    
    else
    {
        return false;
    }
}
public boolean pilhaCheia()
{
    if(topo == p.length - 1)
    {
        System.out.println("Pilha Cheia");
        return true;
    }
    else
    {
        return false;
    }
}
public boolean empilhar(String elemento)
{
    if(!pilhaCheia())
    {
        topo++;
        p[topo] = elemento;
        return true;
    }
    else
    {
        return false;
    }
}
public String desempilhar()
{
    if(pilhaVazia())
    {
        System.out.println("Não há elementos para desempilhar");
        return String.valueOf(-1);
    }
    else
    {
        return String.valueOf(p[topo--]);
    }
}
public String mostrarTopo()
{
    return String.valueOf(p[topo]);
}
public int tamanho()
{
    return p.length;
}

}[/code]

[code]public class Pilha
{
private double p[];
private int topo = -1;

public Pilha(int tamanho)
{
    p = new double[tamanho];
}

public boolean pilhaVazia()
{
    if(topo == -1)
    {
        System.out.println("Pilha Vazia");
        return true;
    }
    
    else
    {
        return false;
    }
}
public boolean pilhaCheia()
{
    if(topo == p.length - 1)
    {
        System.out.println("Pilha Cheia");
        return true;
    }
    else
    {
        return false;
    }
}
public boolean empilhar(Double elemento)
{
    if(!pilhaCheia())
    {
        topo++;
        p[topo] = elemento;
        return true;
    }
    else
    {
        return false;
    }
}
public double desempilhar()
{
    if(pilhaVazia())
    {
        System.out.println("Não há elementos para desempilhar");
        return -1;
    }
    else
    {
        return p[topo--];
    }
}
public double mostrarTopo()
{
    return p[topo];
}
public int tamanho()
{
    return p.length;
}

}[/code]

Agradecido Gerson

passe o erro que esta dando quando vc tenta compilar, pr apodermos analisar, pq assim fica mto codigo pra entender e procurar falhas.

Valeu!

[quote=gsenac]Não consigo compilar meu programa, não sei solucionar o erro que nele ocorre, espero que possam me ajudar, vou postar o código aki e as classes que possui suas dependências, o erro que ocorre é na calculadora, método posfixo, quando vou passar os parâmetros para um método auxiliar.

Eu acho que o erro está na forma que declarei a minha classe e o modo que estou utilizando, mas mesmo assim não sei como solucionar.

[code]import java.io.;
import java.nio.
;
import java.util.*;

public class LeTokensArquivo {
public static void main(String[]args) {

    //Abrindo arquivo
    File arq = new File("F:\Project-02\entrada.txt");
    File arq2 = new File("F:\Project-02\saida.txt");
    String[] operadores = {"+", "-", "*", "/", "r", "e"};
    PilhaS ps = new PilhaS(50);
    Pilha p = new Pilha(50);
    StringTokenizer st;
    String temp = null, temp2, operador, valida, res;
    Double resultado, op2, op1;
    try {
        //cria buffer de leitura
        BufferedReader br = new BufferedReader(new FileReader(arq));
        BufferedWriter bw = new BufferedWriter(new FileWriter(arq2));
        String s;
        //lê as linhas do arquivo e imprime-as na tela
        s = br.readLine(); // Ler linha.
        
        while(s != null) {
            st = new StringTokenizer(s);
            while(st.hasMoreTokens()) //Verifica se existe algum token que ainda não foi separado.
                temp = (st.nextToken()); // "pega" o próximo token.
                if(temp.equals("(")){
                    while(st.hasMoreTokens()){
                        temp = st.nextToken();
                        if(temp.equals(")")){
                            op1 = Double.valueOf(ps.desempilhar());
                            operador = ps.desempilhar();
                            op2 = Double.valueOf(ps.desempilhar());
                            temp2 = ps.desempilhar();
                            resultado = calculadora.infixa(ps, p);
                            PrintWriter saida = new PrintWriter(bw);
                            saida.println(resultado);
                        }
                        else{
                            ps.empilhar(temp);
                        }
                    }
                }
                else{
                    p.empilhar(Double.valueOf(temp));
                    while(st.hasMoreTokens()){
                        temp = (st.nextToken());
                        for(int i = 0; i < operadores.length; i++){
                            if(temp.equals(operadores[i])){
                                while(st.hasMoreTokens()){
                                    ps.empilhar(temp);
                                    temp = st.nextToken();
                                }
                                resultado = calculadora.posfixa(ps, p);
                                PrintWriter saida = new PrintWriter(bw);
                                saida.println(resultado);
                            }
                            else{
                                p.empilhar(Double.valueOf(temp));
                            }
                        }
                    }
                }   
            s = br.readLine();
        }
        //fecha o buffer de leitura que também fecha o arquivo de leitura.
        br.close();
        bw.close();
        
    }
    catch(FileNotFoundException el) {
        //caso o arquivo não exista
        System.out.println("Arquivo não existe" + arq);
    }
    catch(IOException e2) {
        //caso seja detectado algum outro erro de IO
        e2.printStackTrace();
    }
}

}
[/code]

[code]public class calculadora
{
public static Double posfixa(PilhaS ps, Pilha p)
{
PilhaS ps2 = new PilhaS(50);
Double op1, op2, resultado;
String op, temp;

    while(!ps.pilhaVazia()){
        temp = ps.desempilhar();
        ps2.empilhar(temp);
    }
    op1 = p.desempilhar();
    op = ps2.desempilhar();
    if(op.equals("r")){
        resultado = poperacao(op, op1, p);
    }
    else{
        op2 = p.desempilhar();
        resultado = poperacao(op, op1, op2, p);
    }
    do{
        if(p.pilhaVazia()){
            op = ps2.desempilhar();
            op2 = p.desempilhar();
            resultado = poperacao(op, resultado, op2, p);
        }
        else{
            return resultado;
        }
    }while(!p.pilhaVazia());
    return resultado;
}

public static Double poperacao(String operador, Double op1, Pilha pilha){ //Converter os parametros para o objeto Double
    return poperacao(operador, op1, null, pilha);
}                  //Pegar resultado e fazer a próxima operação.

public static Double poperacao(String operador, Double op1, Double op2, Pilha pilha)
{
    Double exp = new Double(1), resultado = new Double(0);
    double pot = 0;
    String []op = {"+","-","*","/","p","r","0"};
    for(int i = 0; i < op.length; i++)
    {
        if(operador.equals(op[i]))
        {
                switch(i)
                {
                    case 0:
                        resultado = op1 + op2;
                        pilha.empilhar(resultado);
                        break;
                    case 1:
                        resultado = op1 - op2;
                        pilha.empilhar(resultado);
                        break;
                    case 2:
                        resultado = op1 * op2;
                        pilha.empilhar(resultado);
                        break;
                    case 3:
                        resultado = op1 / op2;
                        pilha.empilhar(resultado);
                        break;
                    case 4:
                        for(int j = 0; j < op2; j++){
                            pot = pot * op1;}
                        resultado = pot;
                        pilha.empilhar(resultado);
                        break;
                    case 5:
                        resultado = Math.sqrt(op1);
                        pilha.empilhar(resultado);
                        break;

                  }
             }
       }
     return resultado;
 }

// Usando "D"ouble pode-se receber um valor nulo.
/*public static Double operacao(String operador, Double op1){
return operacao(operador, op1, null); */
// usar .equals quando usar classe.
public static Double infixa(PilhaS ps, Pilha p)
{
String operador;
Double op1, op2, resultado;
op1 = p.desempilhar();

    do{
    operador = ps.desempilhar();
    
    if(operador.equals("r"))
    {
        resultado = operacao(operador,op1);
    }
    op2 = p.desempilhar();
    
    resultado = operacao(operador,op1,op2);
    }while(!p.pilhaVazia());
    return resultado;

}

 public static Double operacao(String operador, Double op1){
    return operacao(operador, op1, null);
}




public static Double operacao(String operador, Double op1, Double op2)
{
    Double exp = new Double(1), resultado = new Double(0);
   
    String []op = { "+", "-", "*",  "/", "e", "r"};

        for(int i = 0; i < op.length; i++) // o int só é usado dentro do "for", quando sair do "for" o int será descartado.
        {
            if(operador.equals(op[i]))
            {
                    switch(i)
                    {
                        case 0:
                            resultado = op1 + op2;
                            break;
                        case 1:
                            resultado = op1 - op2;
                            break;
                        case 2:
                            resultado = op1 * op2;
                            break;
                        case 3:
                            resultado = op1 / op2;
                            break;
                        case 4:
                            for(int j = 0; j < op2; j++)
                            {
                                exp = exp * op1;
                            }
                            resultado = exp;
                            break;
                        case 5:
                            resultado = Math.sqrt(op1);
                            break;

                      }
                 }
           }
     return resultado;
 }

}
[/code]

[code]import javax.swing.*;

public class EntradaDados {

public static int inteiro(String msg) {
  
  String s;
  int num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null, msg, "Entrada de dados", 
                    JOptionPane.QUESTION_MESSAGE);            
    try {
      num = Integer.parseInt(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um inteiro",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static int inteiro() {
  
  String s;
  int num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null,"Digite um número inteiro","Entrada de dados",
                    JOptionPane.QUESTION_MESSAGE);           
    try {
      num = Integer.parseInt(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um inteiro",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static double real(String msg) {
  
  String s;
  double num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null, msg, "Entrada de dados",
                    JOptionPane.QUESTION_MESSAGE);            
    try {
      num = Double.parseDouble(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um número real",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static double real() {
  
  String s;
  double num = 0;
  boolean continua = false;
  
  do {
    continua = false;
    s = JOptionPane.showInputDialog(null, "Digite um ponto flutuante", "Entrada de dados",
                    JOptionPane.QUESTION_MESSAGE);             
    try {
      num = Double.parseDouble(s);
    }
    catch(NumberFormatException e) {
      JOptionPane.showMessageDialog(null, "valor digitado:" + 
                                    e.getMessage() + "não é um número real",
                                    "Erro!!",
                                    JOptionPane.WARNING_MESSAGE);
      continua = true;
    }
  }
  while(continua);
  return num;
}
  
  public static String string(String msg) {
  
    String s;
  
    s = JOptionPane.showInputDialog(null, msg, "Entrada de dados", 
                    JOptionPane.QUESTION_MESSAGE);               
    return s;
  }
  
  public static String string() {
  
    String s;
  
    s = JOptionPane.showInputDialog(null, "Digite uma cadeia de caracteres", "Entrada de dados", 
                    JOptionPane.QUESTION_MESSAGE);           
    return s;
  }  

}
[/code]

[code]public class PilhaS
{
private String p[];
private int topo = -1;

public PilhaS(int tamanho)
{
    p = new String[tamanho];
}

public boolean pilhaVazia()
{
    if(topo == -1)
    {
        System.out.println("Pilha Vazia");
        return true;
    }
    
    else
    {
        return false;
    }
}
public boolean pilhaCheia()
{
    if(topo == p.length - 1)
    {
        System.out.println("Pilha Cheia");
        return true;
    }
    else
    {
        return false;
    }
}
public boolean empilhar(String elemento)
{
    if(!pilhaCheia())
    {
        topo++;
        p[topo] = elemento;
        return true;
    }
    else
    {
        return false;
    }
}
public String desempilhar()
{
    if(pilhaVazia())
    {
        System.out.println("Não há elementos para desempilhar");
        return String.valueOf(-1);
    }
    else
    {
        return String.valueOf(p[topo--]);
    }
}
public String mostrarTopo()
{
    return String.valueOf(p[topo]);
}
public int tamanho()
{
    return p.length;
}

}[/code]

[code]public class Pilha
{
private double p[];
private int topo = -1;

public Pilha(int tamanho)
{
    p = new double[tamanho];
}

public boolean pilhaVazia()
{
    if(topo == -1)
    {
        System.out.println("Pilha Vazia");
        return true;
    }
    
    else
    {
        return false;
    }
}
public boolean pilhaCheia()
{
    if(topo == p.length - 1)
    {
        System.out.println("Pilha Cheia");
        return true;
    }
    else
    {
        return false;
    }
}
public boolean empilhar(Double elemento)
{
    if(!pilhaCheia())
    {
        topo++;
        p[topo] = elemento;
        return true;
    }
    else
    {
        return false;
    }
}
public double desempilhar()
{
    if(pilhaVazia())
    {
        System.out.println("Não há elementos para desempilhar");
        return -1;
    }
    else
    {
        return p[topo--];
    }
}
public double mostrarTopo()
{
    return p[topo];
}
public int tamanho()
{
    return p.length;
}

}[/code]

Agradecido Gerson[/quote]