Calculatrice en java helpp

Bonjour à vous tous.Voilà je désire réaliser une calculatrice simple sans interface qui pourra gérer des fonctions simples telles que l'addition , soustraction etc etc , qui seront chacune définie commes des agents.Ensuite j'ai un découpeur d'expression qui permets de définir les ordres et reconnaissances d'expression "+,* ,- etc..).Et ensuite g une classe solveur qui permet de résoudre l'opération.Mais voilà je n'arrive pas à mettre de liaison dans mes classes , g des ptits bug s.Je vous transmets les classes que j'ai :
- le découpeur :

import java.util.Properties;
import java.io.FileInputStream;
import java.util.Vector;
import java.util.Enumeration;
import java.util.regex.*;

/**
 *Cette classe définit notamment la méthode permettant de découper une expression mathématique complexe
 *expressions plus simples/
 */
public class DecoupeurExpressions {
    private String _expression, _fichierRegles;
    private String _terminaux[], _decoupages[];
    private int _indiceVar;
    private Properties _prop;
    /**
     *Constructeur
     *@param String L'expression arithmétique à découper
     *@param String Le chemin vers le fichier contenant les règles de découpage (reglesDecoupage.txt)
     *@throws ExceptionChargementRegles si une erreur est survenue lors du chargement des règles
     */
    public DecoupeurExpressions(String e, String fr) throws ExceptionChargementRegles
    {
	this._expression = e;
	this._fichierRegles = fr;
	this.chargerRegles();
	this._indiceVar = 0;
    }


    /**
     *Charge les règles du fichier en mémoire
     *@throws ExceptionChargementRegles si une erreur est survenue lors du chargement des règles
     */
    private void chargerRegles() throws ExceptionChargementRegles
    {
	try{
	    _prop = new Properties();
	    FileInputStream in = new FileInputStream(_fichierRegles);
	    _prop.load(in);
	    in.close();       
	    _terminaux = _prop.getProperty("exprAtom").split("@");
	    _decoupages = _prop.getProperty("reglesDecoup").split("@");
	}
	catch(Exception e)
	    {
		e.printStackTrace();
		throw(new ExceptionChargementRegles());
	    }
    }

    /**
     *Teste si l'expression passée en argument est atomique
     *@return boolean true si c'est atomique
     */
    private boolean estAtomique(String exp)
    {
	for(int i = 0; i < _terminaux.length; i++)
	    {
		if(exp.split(_terminaux[i]).length == 0)
		    return true;
	    }
	return false;
    }


    /**
     *Test si tous les éléments du Vector sont atomiques
     *@return boolean true si tout est atomique
     */
    private boolean toutAtomique(Vector c){
	
	for(Enumeration e = c.elements(); e.hasMoreElements();)
	    {
		if(!estAtomique((String)e.nextElement()))
		    return false;
	    }
	return true;
    }

    /**
     *Cette méthode retourne un vecteur contenant l'ensemble des sous-expressions construites.
     *Ex : "SOL=(log(2)*5)/(3+1)" sera transformé en ["X0:log(2)","X1:(X0*5)","X2:(3+1)","SOL:X1/X2"]
     *@return Vector contenant des objets String représentant les sous-expressions construites.
     */
    public Vector decoupe()
    {
	Vector ret = new Vector();
	ret.add(_expression);
	while(!toutAtomique(ret))
	    {
		Vector ret2 = new Vector();
		for(Enumeration e = ret.elements(); e.hasMoreElements();)
		    {
			String exp = (String)e.nextElement();
			if(estAtomique(exp))
			{	
				//System.err.println("EST ATOMIQUE "+exp);
				ret2.add(exp);
			}
			else
			    {
				//System.err.println("NON ATOMIQUE2 "+exp);
				for(int i = 0; i < _decoupages.length; i++)
				    {
					Pattern p = Pattern.compile(_decoupages[i]);
					Matcher m = p.matcher(exp);

					if(m.find())
					    {

						String f = m.group();
						//System.err.println("ON AJOUTE LA SOUS-EXPRESSION "+"X"+_indiceVar+":"+f);
						ret2.add("X"+_indiceVar+":"+f);
						//System.err.println("DANS "+exp+" ON REMPLACE 1 fois "+formatRegex(f)+" par "+"X"+_indiceVar);
						exp = exp.replaceFirst(formatRegex(f),"X"+_indiceVar);
						_indiceVar++;
						break;
					    }
				    }
				ret2.add(exp);
			    }
		    }	
		ret = ret2;
	    }
	return ret;
    }
    


    /**
     *Affiche les éléments du vecteur
     *@param Vector un vecteur contenant des Strings
     */
    private void afficher(Vector v)
    {
	for(Enumeration e = v.elements(); e.hasMoreElements();)
	    {
		System.err.println("\t - "+(String)e.nextElement());
	    }
	    }

    /**
     *Fait précédé les caractères spéciaux des expressions régulières par deux \\
     */
    private String formatRegex(String r)
    {
		Vector v = new Vector();
		v.add("(");
		v.add(")");
		v.add("+");
		v.add("*");
		v.add("[");
		v.add("]");
		v.add("^");
	
		char t[] = r.toCharArray();
		String ret = "";
		for(int i = 0; i < t.length; i++)
		{
		if(v.contains(""+t[i]))
			ret+="\\"+t[i];
		else
			ret+=t[i];
		}
	return ret;
    }
	
	/**
     *Test si l'expression passée en argument de la fonction est une puissance atomique par exemple :
     *X1:1+3 ou SOL:(X2)^3 ou X3:X4^X6 ou SOL:(3^X5), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","1","^","3"], ["SOL","X2","^","3"], ["X3","X4","^","X6"], ["SOL","3","^","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas une puissance, une exception est levée
     */
    public String[] estUnePuissance(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("exp")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.indexOf("+"));
	    ret[2] = "+";
	    ret[3] = exp.substring(exp.indexOf("+")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("puissance"));	
	
	return ret;
    }



    /**
     *Test si l'expression passée en argument de la fonction est une addition atomique par exemple :
     *X1:1+3 ou SOL:(X2)+3 ou X3:X4+X6 ou SOL:(3+X5), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","1","+","3"], ["SOL","X2","+","3"], ["X3","X4","+","X6"], ["SOL","3","+","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas une addition, une exception est levée
     */
    public String[] estUneAddition(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("add")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.indexOf("+"));
	    ret[2] = "+";
	    ret[3] = exp.substring(exp.indexOf("+")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("addition"));	
	
	return ret;
    }
	

    /**
     *Test si l'expression passée en argument de la fonction est une soustraction atomique par exemple :
     *X1:1-3 ou SOL:(X2)-3 ou X3:X4-X6 ou SOL:(3-X5), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","1","-","3"], ["SOL","X2","-","3"], ["X3","X4","-","X6"], ["SOL","3","-","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas une soustraction, une exception est levée
     */
    public String[] estUneSoustraction(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("sous")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.indexOf("-"));
	    ret[2] = "-";
	    ret[3] = exp.substring(exp.indexOf("-")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("soustraction"));	
	
	return ret;
    }

    /**
     *Test si l'expression passée en argument de la fonction est une multiplication atomique par exemple :
     *X1:1*3 ou SOL:(X2)*3 ou X3:X4*X6 ou SOL:(3*X5), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","1","*","3"], ["SOL","X2","*","3"], ["X3","X4","*","X6"], ["SOL","3","*","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas une multiplication, une exception est levée
     */
    public String[] estUneMultiplication(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("mul")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.indexOf("*"));
	    ret[2] = "*";
	    ret[3] = exp.substring(exp.indexOf("*")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("multiplication"));	
	return ret;
    }

    /**
     *Test si l'expression passée en argument de la fonction est une division atomique par exemple :
     *X1:1/3 ou SOL:(X2)/3 ou X3:X4/X6 ou SOL:(3/X5), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","1","/","3"], ["SOL","X2","/","3"], ["X3","X4","/","X6"], ["SOL","3","/","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas une division, une exception est levée
     */
    public String[] estUneDivision(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("div")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.indexOf("/"));
	    ret[2] = "/";
	    ret[3] = exp.substring(exp.indexOf("/")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("division"));	
	return ret;
    }

    /**
     *Test si l'expression passée en argument de la fonction est un modulo atomique par exemple :
     *X1:1%3 ou SOL:(X2)%3 ou X3:X4%X6 ou SOL:(3%X5), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","1","%","3"], ["SOL","X2","%","3"], ["X3","X4","%","X6"], ["SOL","3","%","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas un modulo, une exception est levée
     */
    public String[] estUnModulo(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("mod")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.indexOf("%"));
	    ret[2] = "%";
	    ret[3] = exp.substring(exp.indexOf("%")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("modulo"));	
	return ret;
    }

    /**
     *Test si l'expression passée en argument de la fonction est une simple valeur de variable atomique par exemple :
     *X1:3 ou SOL:(X2) ou X3:X4 ou SOL:X5, etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","3"], ["SOL","X2"], ["X3","X4"], ["SOL","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas une affectation de valeur, une exception est levée
     */
    public String[] estUneValeur(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("val")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = exp.substring(exp.indexOf(":")+1,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("égalité"));	
	return ret;
    }

    /**
     *Test si l'expression passée en argument de la fonction est un log atomique par exemple :
     *X1:log(3) ou SOL:log(X2) ou X3:log(X4) ou SOL:log((X5)), etc.
     *@param String L'expression à tester
     *@return String[] Un tableau contenant dans chaque cas un élément de l'expression : ["X1","log","3"], ["SOL","log","X2"], ["X3","log","X4"], ["SOL","log","X5"], etc.
     *@throws ExceptionMauvaiseOperation Si l'expression n'est pas un log, une exception est levée
     */
    public String[] estUnLog(String s) throws ExceptionMauvaiseOperation
    {
	String[] ret = new String[4];
	if (s.matches(_prop.getProperty("log")))
	{	
	    String exp = s.replaceAll("\\(","").replaceAll("\\)","");
	    ret[0] = exp.substring(0,exp.indexOf(":"));
	    ret[1] = "log";
	    ret[2] = exp.substring(exp.indexOf("log")+3,exp.length());
	}
	else
	    throw(new ExceptionMauvaiseOperation("log"));	
	return ret;
    }
	
	public static void main(String argv[])
	{	
	try{
	String t[] ={"SOL:2+3*4","SOL:2+3","SOL:2*4/5","SOL:2*(3+4)","SOL:(log(2)*5)/(3+1)","SOL:(2+4)*2/5","SOL:2^(3+4)^2","SOL:2/5*4+5*8","SOL:2-5+(6-1*4)^2","SOL:(((2+3)*(1+log(4)))/(3+6/2))*2"};
	for(int i =0;i < t.length; i++){
	DecoupeurExpressions de = new DecoupeurExpressions(t[i],"reglesDecoupage.txt");
	System.err.println("Resultat de "+t[i]);

	Vector v = de.decoupe();
		de.afficher(v);
	System.err.println("****************");
	}
	}catch(Exception e)
	{
	e.printStackTrace();
	}
	}
}

- tabealu noir : permet de stocker l'expression

import java.util.Vector;


/**
 *Cette classe définie l'objet TableauNoir qui n'est rien d'autre qu'un Vecteur. Vous disposez donc de l'ensemble des méthodes de java.util.Vector pour modifier et manipuler les données du tableau noir.
 */
class TableauNoir extends Vector
{

    /**
     *Constructeur qui initialise le tableau noir à vide
     */
    public TableauNoir()
    {
	super();
    }

    /**
     *Constructeur qui initialise le tableau noir avec un vecteur déjà défini
     *@param Vector Un vecteur contenant un ensemble d'instructions.
     */
    public TableauNoir(Vector v)
    {
	super(v);
    }
}

- résolveur

public class Resolveur
{
    public static void main(String[]args)
    {
        String exp ;
        DecoupeurExpressions d = new DecoupeurExpressions(String exp, String fr);
        TableauNoir Tn = new TableauNoir(d.decoupe(exp));
    }
}

- voici ici par exemple l'agent addition ou ca bloque

import java.util.Enumeration;
/**
 * Write a description of class AgentAddi here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class AgentAddi
{
    private double a;
    private double b;    
    
    public AgentAddi()
    {
        this.a=a;
        this.b=b;
    }
    
    public void additionner()
    { 
       String exp;
       if(estUneAddition(String exp)==true)
       { 
          try{
            estUneAddition(String exp);
            a=new Double((String)ret.elementAt(1)).double Value();
            b=new Double((String)ret.elementAt(3)).double Value();
            c=a+b;
            System.out.println("X1:"+ c);
             }
          catch(Mauvaise Operation)
             {}
        }
        else{
            wait()
            }
     }
}

Merci de bien vouloir m'aider.Dans l'attente.