Les Classes "concrètes" : Addition , Soustraction , Multiplication , Division , Inverse , Entier   et  TestExprOO

/** vision Objet des expressions entières...
 * 
 * @see ExpressionSimple , ExpressionComposee
 * @author dazy
 */
public abstract class Expression {

  /** Schéma de méthode imposé pour l'évaluation des expressions
  */
  public abstract int eval();
  
  /** Schéma de méthode imposé pour l'affichage des expressions
 */
  public abstract String toString();

  /** affichage Postfixe sans parenthèses des expressions
 */
  public abstract String affichagePostFixe();
  
  /** affichage PreFixe fonctionnel des expressions
 */
  public abstract String affichagePreFixe();
  
} /* end class Expression */ 

/** Expression Binaire :  contient 2 sous expressions
 * 
 * @see OtherClasses
 * @author dazy
 */
public abstract class ExpressionBinaire extends Expression {
  /** 2 sous-expressions e1 , e2
 */
  public Expression e1 , e2;
  /** un operateur
 */


  ExpressionBinaire(Expression e1 , Expression e2){
	  this.e1=e1;
	  this.e2=e2;
  }

   /** eval()
 */
 abstract public int eval();  
  
  /** toString()
 */
  abstract public String toString();
 /** affichage PostFixe sans parenthèse des expressions
 */
  public abstract String affichagePostFixe();
  
  /** affichage PreFixe fonctionnel des expressions
 */
  public abstract String affichagePreFixe();
  

} /* end class ExpressionBinaire */ 

/** Expression Composée :  contient 2 sous expressions
 * 
 * @see OtherClasses
 * @author dazy
 */
public class Addition extends ExpressionBinaire {

  Addition(Expression e1 , Expression e2){
	  super(e1,e2);
  }

   /** eval()
 */
  public int eval() {
	  return e1.eval() + e2.eval();
  }  
  
  /** toString()
 */
  public String toString() {
	  return "(" +  e1.toString() + " + " + e2.toString() + ")";
  }
  /** affichage PostFixe sans parenthèse des expressions
  * le moins unaire est représenté par _
  *
 */
  public String affichagePostFixe() {
	  return e1.affichagePostFixe() + e2.affichagePostFixe() + " + ";
  }
  /** affichage PreFixe fonctionnel des expressions
  *
 */
  public String affichagePreFixe() {
	  return "add(" + e1.affichagePreFixe() + " , " + e2.affichagePreFixe() + ")";
  }
} /* end class Addition */ 

/** Expression Composée :  contient 2 sous expressions et un opérateur.
 * 
 * @see OtherClasses
 * @author dazy
 */
public class Soustraction extends ExpressionBinaire {

  Soustraction(Expression e1 , Expression e2){
	  super(e1,e2);
  }

   /** eval()
 */
  public int eval() {
	  return e1.eval() - e2.eval();
  }  
  
  /** toString()
 */
  public String toString() {
	  return "(" +  e1.toString() + " - " + e2.toString() +")";
  }
  /** affichage PostFixe sans parenthèse des expressions
  * le moins unaire est représenté par _
  *
 */
  public String affichagePostFixe() {
	  return e1.affichagePostFixe() + e2.affichagePostFixe() + " - ";
  }
  /** affichage PreFixe fonctionnel des expressions
  *
 */
  public String affichagePreFixe() {
	  return "sous(" + e1.affichagePreFixe() + " , "  + e2.affichagePreFixe() + ")";
  }

} /* end class Soustraction */ 

/** Expression Composée :  contient 2 sous expressions et un opérateur.
 * 
 * @see OtherClasses
 * @author dazy
 */
public class Multiplication extends ExpressionBinaire {

  Multiplication(Expression e1 , Expression e2){
	  super(e1,e2);
  }

   /** eval()
 */
  public int eval() {
	  return e1.eval() * e2.eval();
  }  
  
  /** toString()
 */
  public String toString() {
	  return "(" + e1.toString() + " * " + e2.toString() + ")";
  }
  /** affichage PostFixe sans parenthèse des expressions
  * le moins unaire est représenté par _
  *
 */
  public String affichagePostFixe() {
	  return e1.affichagePostFixe() + e2.affichagePostFixe() + " * ";
  }
  /** affichage PreFixe fonctionnel des expressions
  *
 */
  public String affichagePreFixe() {
	  return "mult(" + e1.affichagePreFixe() + " , "  + e2.affichagePreFixe() + ")";
  }

} /* end class Multiplication */ 

/** Expression Composée :  contient 2 sous expressions 
 * 
 * @author dazy
 */
public class Division extends ExpressionBinaire {

  Division(Expression e1 , Expression e2){
	  super(e1,e2);
  }

   /** eval()
 */
  public int eval() {
	  return e1.eval() / e2.eval();
  }  
  
  /** toString()
 */
  public String toString() {
	  return "(" + e1.toString() + " / " + e2.toString() + ")";
  }
  /** affichage PostFixe sans parenthèse des expressions
  * le moins unaire est représenté par _
  *
 */
  public String affichagePostFixe() {
	  return e1.affichagePostFixe() + e2.affichagePostFixe() + " / ";
  }
  /** affichage PreFixe fonctionnel des expressions
  *
 */
  public String affichagePreFixe() {
	  return "div(" + e1.affichagePreFixe() + " , "  + e2.affichagePreFixe() + ")";
  }

} /* end class Division */ 

/** Expression Unaire :  contient 1 sous expression
 * 
 * @see OtherClasses
 * @author dazy
 */
public abstract class ExpressionUnaire extends Expression {
  /** 1 sous-expression e
 */
  public Expression e ;

  ExpressionUnaire(Expression e){
	  this.e=e;
  }

   /** eval()
 */
 abstract public int eval();  
  
  /** toString()
 */
  abstract public String toString();
 /** affichage PostFixe sans parenthèse des expressions
 */
  public abstract String affichagePostFixe();
  /** affichage PreFixe fonctionnel des expressions
 */
  public abstract String affichagePreFixe();
  

} /* end class ExpressionUnaire */ 

/** Expression Composée :  contient 2 sous expressions 
 * 
 * @author dazy
 */
public class Inverse extends ExpressionUnaire {

  Inverse(Expression e){
	  super(e);
  }

   /** eval()
 */
  public int eval() {
	  return -e.eval();
  }  
  
  /** toString()
 */
  public String toString() {
	  return "( -" + e.toString() + ")";
  }
  /** affichage PostFixe sans parenthèse des expressions
  * le moins unaire est représenté par _
  *
 */
  public String affichagePostFixe() {
	  return e.affichagePostFixe() + " _ ";
  }
  /** affichage PreFixe fonctionnel des expressions
  *
 */
  public String affichagePreFixe() {
	  return "inv(" + e.affichagePreFixe() + ")";
  }

} /* end class Inverse */ 


/** Expression Simple ou constante
 * 
 * @see Expression
 * @author dazy
 */
public abstract class ExpressionConstante extends Expression {

 /** eval()
 * 
 * @return int
 */
  public abstract int eval();
  
  /** toString()
 * 
 * @return String
 */
  public abstract String toString();
  /** affichage PostFixe sans parenthèse des expressions
 */
  public abstract String affichagePostFixe();

  /** affichage PreFixe fonctionnel des expressions
 */
  public abstract String affichagePreFixe();
  

} /* end class ExpressionConstante */ 


/** Entier
 * 
 * @see Expression
 * @author dazy
 */
public class Entier extends ExpressionConstante {

  /** une expression Simple est une constante entière : n
 */
  public int n;

  //Constructeur
  public Entier(int n){
	  this.n=n;
  }

  /** eval()
 * 
 * @return int
 */
  public int eval() {
    return n;
  } 
  
  /** toString()
 * 
 * @return String
 */
  public String toString() {
    return "" + n;
  }
  /** affichage PostFixe d'une constante n'est pas différent de toString()
  *
 */
  public String affichagePostFixe() {
    return "" + n + " ";
  }
  /** affichage PreFixe fonctionnel des expressions
  *
 */
  public String affichagePreFixe() {
    return "" + n;
  }

} /* end class Entier */ 

 


/** 
 *
 * @author  dazy
 * @version 
 */
public class TestExprOO {

  /**
  * @param args the command line arguments
  */
  public static void main (String args[]) {
    /** expression 1+2*(-5)-3 */
    Expression e = new Addition(
		                new Entier(1), 
                           new Soustraction(
                           new Multiplication(
                              new Entier(2) , 
                              new Inverse(new Entier(5))) , 
                           new Entier(3)));
    System.out.println(e.toString() + " = " + e.eval());
    System.out.println(e.affichagePostFixe() + " = " + e.eval());
    System.out.println(e.affichagePreFixe() + " = " + e.eval());
  }

}
/* c'est tout */