expressao matematica que calcule todas as operacoes

ola pessoal, estou com um codigo que esta funcionando, ele dev funcionar assim, calcular as expressoes  mas todas entre parenteses, respeitando a regra  e matematica,


 me ajudem ,helppppppppppppppppp

[CODE]

import javax.swing.JOptionPane;

public class Calculadora {
   
    private String equacao;

    public static void main(String[] args) {
       Calculadora calc = new Calculadora(); 
       Parentheses_check check = new Parentheses_check();
      
       calc.setEquacao(JOptionPane.showInputDialog("Expressão Numerica:")); 
   
       if(check.parentheses_valid(calc.getEquacao())) {
           System.out.println("Resultado: " + calc.eval(calc.getEquacao()));  
       } else {
           System.out.println("A expressão "+ calc.getEquacao() + "não é válida!");
       }
    }
   
   
    public static int eval(String expr) {
        int resultado = 0;
        char charI = expr.charAt(0);               
        if(charI == '(') {
                int indiceChaveFinal = expr.lastIndexOf(")");
                if(indiceChaveFinal == expr.length()-1) {
                    resultado = eval(expr.substring(1, expr.length()-1));
                } else {
                    char operador = expr.charAt(indiceChaveFinal+1);
 
                    if(operador == '*'){
                        resultado = eval(expr.substring(1, indiceChaveFinal)) * eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }
                    if(operador == '/'){
                        resultado = eval(expr.substring(1, indiceChaveFinal)) / eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }
                    if(operador == '+'){
                       resultado = eval(expr.substring(1, indiceChaveFinal)) + eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }
                    if(operador == '-'){
                        resultado = eval(expr.substring(1, indiceChaveFinal)) - eval(expr.substring(indiceChaveFinal + 2, expr.length()));
                    }                        
                }          
        } else {
                int indiceOperador = expr.indexOf("+");
                int indiceOperador1 = expr.indexOf("-");
                int indiceOperador2 = expr.indexOf("*");
                int indiceOperador3 = expr.indexOf("/");
                if(indiceOperador == -1 && indiceOperador1 == -1 && indiceOperador2 == -1 && indiceOperador3 == -1 ) {
                    resultado = Integer.parseInt(expr);
                } else {
                     if(indiceOperador2 != -1) {
                         resultado = eval(expr.substring(0, indiceOperador2)) * eval(expr.substring(indiceOperador2 + 1, expr.length()));
                   }
                     if(indiceOperador3 != -1) {
                         resultado = eval(expr.substring(0, indiceOperador3)) / eval(expr.substring(indiceOperador3 + 1, expr.length()));
                   }
                    if(indiceOperador != -1) {
                        resultado = eval(expr.substring(0, indiceOperador)) + eval(expr.substring(indiceOperador + 1, expr.length()));
                   }
                     if(indiceOperador1 != -1) {
                         resultado = eval(expr.substring(0, indiceOperador1)) - eval(expr.substring(indiceOperador1 + 1, expr.length()));
                   }
                }
               
        }
        return resultado;
   }

    public String getEquacao() { 
        return this.equacao; 
    } 
    public void setEquacao(String str) { 
        this.equacao = str;
    }   
      
 }
[CODE]


[CODE]

import java.util.Stack;

public class Parentheses_check
   {

   public static boolean is_open_parenthesis( char c )
      {
      if ( c=='(' || c=='[' || c=='{' )
         return true;
      else
         return false;
      }

   public static boolean is_closed_parenthesis( char c )
      {
      if ( c==')' || c==']' || c=='}' )
         return true;
      else
         return false;
      }

   private static boolean parentheses_match( char open, char closed )
      {
      if ( open=='(' && closed==')' )
         return true;
      else if ( open=='[' && closed==']' )
         return true;
      else if ( open=='{' && closed=='}' )
         return true;
      else
         return false;
      }

   public static boolean parentheses_valid( String exp )
      {
      Stack       s = new Stack();
      int         i;
      char        current_char;
      Character   c;
      char        c1;
      boolean     ret=true;

      for ( i=0; i < exp.length(); i++ )
         {

         current_char=exp.charAt( i );

         if ( is_open_parenthesis( current_char ) )
            {
            c=new Character( current_char );
            s.push( c );
            }
         else if ( is_closed_parenthesis( current_char ) )
            {
            if ( s.isEmpty() )
               {
               ret=false;
               break;
               }
            else
               {
               c=(Character)s.pop();
               c1=c.charValue();
               if ( !parentheses_match( c1, current_char ) )
                  {
                  ret=false;
                  break;
                  }
               }
            }
         }

      if ( !s.isEmpty() )
         ret=false;

      return ret;
      }
   }

[CODE]