Bonjour =E0 tous
Petite question simple (je suis novice)
je cherche =E0 cr=E9er une class Element qui permette ce genre de
hi=E9rarchie :
+
/ \
/ \
* -
/ \ / \
A B C D
Element pourra donc =EAtre entier (class Valeur) ou caract=E8res */+-
(class Operande). Je pense qu'il faut utiliser extends pour =E7a.
Le programme devra permettre afficher et r=E9soudre une =E9quation (les
=E9l=E9ments sont pass=E9s en param=E8tres).
dans cet exemple : (A*B)+(C-D) param=E8tres : A,*,B,+,C,-,D
Quelqu'un peut me donner une piste? Je tourne en rond depuis un moment
sans savoir comment faire.
Merci.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Raphael Tagliani
Si tu utilises la notation préfixée, ou polonaise, tu peux réécrire ton équation comme des appels de méthodes.
Voici une explication qui vient de mon cours de compilation (scala, un langage compatible java, qui ajoute des fonctionnalités). C'est tout à fait applicable à java, à part que tu ne peux pas utiliser */+- pour opérateurs.
[cite] 4.1 Numbers are objects Since numbers are objects, they also have methods. And in fact, an arithmetic expression like the following: 1 + 2 * 3 / x consists exclusively of method calls, because it is equivalent to the following expression, as we saw in the previous section: 1.+(2.*(3./(x))) [/cite]
Pour des explications plus avancées et plein d'exemples qui reproduisent ce que tu veux faire (même en plus compliqué): http://www.scala-lang.org/docu/files/ScalaTutorial.pdf http://www.scala-lang.org/index.html
Bonjour à tous Petite question simple (je suis novice) je cherche à créer une class Element qui permette ce genre de hiérarchie : + / / * - / / A B C D
Element pourra donc être entier (class Valeur) ou caractères */+- (class Operande). Je pense qu'il faut utiliser extends pour ça. Le programme devra permettre afficher et résoudre une équation (les éléments sont passés en paramètres). dans cet exemple : (A*B)+(C-D) paramètres : A,*,B,+,C,-,D Quelqu'un peut me donner une piste? Je tourne en rond depuis un moment sans savoir comment faire. Merci.
Si tu utilises la notation préfixée, ou polonaise, tu peux réécrire ton
équation comme des appels de méthodes.
Voici une explication qui vient de mon cours de compilation (scala, un
langage compatible java, qui ajoute des fonctionnalités). C'est tout à
fait applicable à java, à part que tu ne peux pas utiliser */+- pour
opérateurs.
[cite]
4.1 Numbers are objects
Since numbers are objects, they also have methods. And in fact, an
arithmetic expression
like the following:
1 + 2 * 3 / x
consists exclusively of method calls, because it is equivalent to the
following expression,
as we saw in the previous section:
1.+(2.*(3./(x)))
[/cite]
Pour des explications plus avancées et plein d'exemples qui reproduisent
ce que tu veux faire (même en plus compliqué):
http://www.scala-lang.org/docu/files/ScalaTutorial.pdf
http://www.scala-lang.org/index.html
Bonjour à tous
Petite question simple (je suis novice)
je cherche à créer une class Element qui permette ce genre de
hiérarchie :
+
/
/
* -
/ /
A B C D
Element pourra donc être entier (class Valeur) ou caractères */+-
(class Operande). Je pense qu'il faut utiliser extends pour ça.
Le programme devra permettre afficher et résoudre une équation (les
éléments sont passés en paramètres).
dans cet exemple : (A*B)+(C-D) paramètres : A,*,B,+,C,-,D
Quelqu'un peut me donner une piste? Je tourne en rond depuis un moment
sans savoir comment faire.
Merci.
Si tu utilises la notation préfixée, ou polonaise, tu peux réécrire ton équation comme des appels de méthodes.
Voici une explication qui vient de mon cours de compilation (scala, un langage compatible java, qui ajoute des fonctionnalités). C'est tout à fait applicable à java, à part que tu ne peux pas utiliser */+- pour opérateurs.
[cite] 4.1 Numbers are objects Since numbers are objects, they also have methods. And in fact, an arithmetic expression like the following: 1 + 2 * 3 / x consists exclusively of method calls, because it is equivalent to the following expression, as we saw in the previous section: 1.+(2.*(3./(x))) [/cite]
Pour des explications plus avancées et plein d'exemples qui reproduisent ce que tu veux faire (même en plus compliqué): http://www.scala-lang.org/docu/files/ScalaTutorial.pdf http://www.scala-lang.org/index.html
Bonjour à tous Petite question simple (je suis novice) je cherche à créer une class Element qui permette ce genre de hiérarchie : + / / * - / / A B C D
Element pourra donc être entier (class Valeur) ou caractères */+- (class Operande). Je pense qu'il faut utiliser extends pour ça. Le programme devra permettre afficher et résoudre une équation (les éléments sont passés en paramètres). dans cet exemple : (A*B)+(C-D) paramètres : A,*,B,+,C,-,D Quelqu'un peut me donner une piste? Je tourne en rond depuis un moment sans savoir comment faire. Merci.
lyland
On 12 fév, 00:16, Raphael Tagliani wrote:
Si tu utilises la notation préfixée, ou polonaise, tu peux réécri re ton équation comme des appels de méthodes.
Hello Raphael. J'en suis à découvrir les bases de Java. Pour cette raison, je préf ère apprendre avec des exemples plus basiques que cette extension de Java. Je pensais plus à une classe Element, et deux classes fille, Operande et Valeur. Mais j'ai encore du mal a bien conceptualiser ça. Merci en tout cas :)
On 12 fév, 00:16, Raphael Tagliani <raphael.tagli...@gmail.com> wrote:
Si tu utilises la notation préfixée, ou polonaise, tu peux réécri re ton
équation comme des appels de méthodes.
Hello Raphael.
J'en suis à découvrir les bases de Java. Pour cette raison, je préf ère
apprendre avec des exemples plus basiques que cette extension de Java.
Je pensais plus à une classe Element, et deux classes fille, Operande
et Valeur. Mais j'ai encore du mal a bien conceptualiser ça.
Merci en tout cas :)
Si tu utilises la notation préfixée, ou polonaise, tu peux réécri re ton équation comme des appels de méthodes.
Hello Raphael. J'en suis à découvrir les bases de Java. Pour cette raison, je préf ère apprendre avec des exemples plus basiques que cette extension de Java. Je pensais plus à une classe Element, et deux classes fille, Operande et Valeur. Mais j'ai encore du mal a bien conceptualiser ça. Merci en tout cas :)
Sylvain
lyland wrote on 12/02/2007 00:57:
J'en suis à découvrir les bases de Java. Pour cette raison, je préfère apprendre avec des exemples plus basiques que cette extension de Java. Je pensais plus à une classe Element, et deux classes fille, Operande et Valeur. Mais j'ai encore du mal a bien conceptualiser ça.
ton exemple n'est pas difficile à implémenter mais est difficile à définir: ce n'est pas ce qu'il fait qui pose problème mais la façon dont on veut lui dire de le faire, c'est à dire la façon dont on pourra écrire les expressions à évaluer; entre l'approche surcharge d'opérateurs des Cpépéistes (non dispo en Java) et une approche ultra verbieuse, les choix sont larges. dès lors, les réponses sont multiples et toutes fortement subjectives.
pour construire ton arbre, il faut des noeuds qui s'évaluent, soit comme une constante (les valeurs finales) soit comme une expression (un opérande); un opérande est lui une opération entre de tels noeuds, une relation qui heureusement ne tourne pas en rond.
a) quelque chose pouvant être évaluer:
interface Evaluable { abstract public int evaluate(); }
abstract class Operande implements Evaluable { protected Evaluable left, right; public Operande(Evaluable lft, Evaluable rght){ left = lft; right = rght; } }
une classe implémentant Evaluable devra fournir un moyen d'évaluer sa valeur. une classe dérivée de Operande aussi, la classe reste abstraite car le moyen de réaliser l'opération d'évaluation est inconnu (un gros switch '+', '-', '*' ne serait pas une solution). le résultat de l'évaluation est ici de type 'int', on modifiera cela besoin.
b) quelque chose qui s'évalue:
une constante est le cas le plus simple:
class Constant implements Evaluable { protected int value; public Constant(int aValue){ value = aValue; } public int evaluate(){ return value; } }
quelque chose de mutable peut être utile également:
class Value extends Constant { public Value(int aValue){ super(aValue); } public void setValue(int aNewValue){ value = aNewValue; } }
c) quelque chose qui fait une opération
chaque class implémente un opérateur particulier:
class Sum extends Operande { public Sum(Evaluable lft, Evaluable rght){ super(lft, rght); } public int evaluate(){ return left.evaluate() + right.evaluate(); } }
class Diff extends Operande { public Diff(Evaluable lft, Evaluable rght){ super(lft, rght); } public int evaluate(){ return left.evaluate() - right.evaluate(); } }
class Mul extends Operande { public Mul(Evaluable lft, Evaluable rght){ super(lft, rght); } public int evaluate(){ return left.evaluate() * right.evaluate(); } }
d) l'assemblage de l'expression
c'est là où les choix arbitraires précédent se concrétisent, dans ce cas on écrirait quelque chose comme:
Value a = new Value(1); Value b = new Value(2); Value c = new Value(3); Value d = new Value(4);
et pour suivre ton parenthésage (A*B)+(C-D):
Evaluable expression = new Sum( new Mul( a, b ), new Diff( c, d ));
int result = expression.evaluate();
// les params a,b,c,d peuvent être changés et l'expression recalculée
a.setValue(5); result = expression.evaluate();
Sylvain.
lyland wrote on 12/02/2007 00:57:
J'en suis à découvrir les bases de Java. Pour cette raison, je préfère
apprendre avec des exemples plus basiques que cette extension de Java.
Je pensais plus à une classe Element, et deux classes fille, Operande
et Valeur. Mais j'ai encore du mal a bien conceptualiser ça.
ton exemple n'est pas difficile à implémenter mais est difficile à
définir: ce n'est pas ce qu'il fait qui pose problème mais la façon dont
on veut lui dire de le faire, c'est à dire la façon dont on pourra
écrire les expressions à évaluer; entre l'approche surcharge
d'opérateurs des Cpépéistes (non dispo en Java) et une approche ultra
verbieuse, les choix sont larges. dès lors, les réponses sont multiples
et toutes fortement subjectives.
pour construire ton arbre, il faut des noeuds qui s'évaluent, soit comme
une constante (les valeurs finales) soit comme une expression (un
opérande); un opérande est lui une opération entre de tels noeuds, une
relation qui heureusement ne tourne pas en rond.
a) quelque chose pouvant être évaluer:
interface Evaluable {
abstract public int evaluate();
}
abstract class Operande implements Evaluable {
protected Evaluable left, right;
public Operande(Evaluable lft, Evaluable rght){
left = lft;
right = rght;
}
}
une classe implémentant Evaluable devra fournir un moyen d'évaluer sa
valeur. une classe dérivée de Operande aussi, la classe reste abstraite
car le moyen de réaliser l'opération d'évaluation est inconnu (un gros
switch '+', '-', '*' ne serait pas une solution).
le résultat de l'évaluation est ici de type 'int', on modifiera cela besoin.
b) quelque chose qui s'évalue:
une constante est le cas le plus simple:
class Constant implements Evaluable {
protected int value;
public Constant(int aValue){
value = aValue;
}
public int evaluate(){
return value;
}
}
quelque chose de mutable peut être utile également:
class Value extends Constant {
public Value(int aValue){
super(aValue);
}
public void setValue(int aNewValue){
value = aNewValue;
}
}
c) quelque chose qui fait une opération
chaque class implémente un opérateur particulier:
class Sum extends Operande {
public Sum(Evaluable lft, Evaluable rght){
super(lft, rght);
}
public int evaluate(){
return left.evaluate() + right.evaluate();
}
}
class Diff extends Operande {
public Diff(Evaluable lft, Evaluable rght){
super(lft, rght);
}
public int evaluate(){
return left.evaluate() - right.evaluate();
}
}
class Mul extends Operande {
public Mul(Evaluable lft, Evaluable rght){
super(lft, rght);
}
public int evaluate(){
return left.evaluate() * right.evaluate();
}
}
d) l'assemblage de l'expression
c'est là où les choix arbitraires précédent se concrétisent, dans ce cas
on écrirait quelque chose comme:
Value a = new Value(1);
Value b = new Value(2);
Value c = new Value(3);
Value d = new Value(4);
et pour suivre ton parenthésage (A*B)+(C-D):
Evaluable expression = new Sum( new Mul( a, b ), new Diff( c, d ));
int result = expression.evaluate();
// les params a,b,c,d peuvent être changés et l'expression recalculée
J'en suis à découvrir les bases de Java. Pour cette raison, je préfère apprendre avec des exemples plus basiques que cette extension de Java. Je pensais plus à une classe Element, et deux classes fille, Operande et Valeur. Mais j'ai encore du mal a bien conceptualiser ça.
ton exemple n'est pas difficile à implémenter mais est difficile à définir: ce n'est pas ce qu'il fait qui pose problème mais la façon dont on veut lui dire de le faire, c'est à dire la façon dont on pourra écrire les expressions à évaluer; entre l'approche surcharge d'opérateurs des Cpépéistes (non dispo en Java) et une approche ultra verbieuse, les choix sont larges. dès lors, les réponses sont multiples et toutes fortement subjectives.
pour construire ton arbre, il faut des noeuds qui s'évaluent, soit comme une constante (les valeurs finales) soit comme une expression (un opérande); un opérande est lui une opération entre de tels noeuds, une relation qui heureusement ne tourne pas en rond.
a) quelque chose pouvant être évaluer:
interface Evaluable { abstract public int evaluate(); }
abstract class Operande implements Evaluable { protected Evaluable left, right; public Operande(Evaluable lft, Evaluable rght){ left = lft; right = rght; } }
une classe implémentant Evaluable devra fournir un moyen d'évaluer sa valeur. une classe dérivée de Operande aussi, la classe reste abstraite car le moyen de réaliser l'opération d'évaluation est inconnu (un gros switch '+', '-', '*' ne serait pas une solution). le résultat de l'évaluation est ici de type 'int', on modifiera cela besoin.
b) quelque chose qui s'évalue:
une constante est le cas le plus simple:
class Constant implements Evaluable { protected int value; public Constant(int aValue){ value = aValue; } public int evaluate(){ return value; } }
quelque chose de mutable peut être utile également:
class Value extends Constant { public Value(int aValue){ super(aValue); } public void setValue(int aNewValue){ value = aNewValue; } }
c) quelque chose qui fait une opération
chaque class implémente un opérateur particulier:
class Sum extends Operande { public Sum(Evaluable lft, Evaluable rght){ super(lft, rght); } public int evaluate(){ return left.evaluate() + right.evaluate(); } }
class Diff extends Operande { public Diff(Evaluable lft, Evaluable rght){ super(lft, rght); } public int evaluate(){ return left.evaluate() - right.evaluate(); } }
class Mul extends Operande { public Mul(Evaluable lft, Evaluable rght){ super(lft, rght); } public int evaluate(){ return left.evaluate() * right.evaluate(); } }
d) l'assemblage de l'expression
c'est là où les choix arbitraires précédent se concrétisent, dans ce cas on écrirait quelque chose comme:
Value a = new Value(1); Value b = new Value(2); Value c = new Value(3); Value d = new Value(4);
et pour suivre ton parenthésage (A*B)+(C-D):
Evaluable expression = new Sum( new Mul( a, b ), new Diff( c, d ));
int result = expression.evaluate();
// les params a,b,c,d peuvent être changés et l'expression recalculée
a.setValue(5); result = expression.evaluate();
Sylvain.
lyland
Plein de pistes dans ta réponse :)
A bien y reflechir, ce serait un truc de ce type :
Element I_______I I_______I I+combine():ElementxElementxElement I_______I / / IOperateur I IValeur I I_________I I_______I I I I-int Valeur I_________I I_______I I I I+GetV()I I I I+SetV()I I I I______I I+Combine():ElementxElement I+SetOperande() I+GetResultat I_________I
Vous voyez le style ?
Plein de pistes dans ta réponse :)
A bien y reflechir, ce serait un truc de ce type :
Element
I_______I
I_______I
I+combine():ElementxElementxElement
I_______I
/
/
IOperateur I IValeur I
I_________I I_______I
I I I-int Valeur
I_________I I_______I
I I I+GetV()I
I I I+SetV()I
I I I______I
I+Combine():ElementxElement
I+SetOperande()
I+GetResultat
I_________I
A bien y reflechir, ce serait un truc de ce type :
Element I_______I I_______I I+combine():ElementxElementxElement I_______I / / IOperateur I IValeur I I_________I I_______I I I I-int Valeur I_________I I_______I I I I+GetV()I I I I+SetV()I I I I______I I+Combine():ElementxElement I+SetOperande() I+GetResultat I_________I
Vous voyez le style ?
lyland
On 12 fév, 16:50, "lyland" wrote:
Plein de pistes dans ta réponse :)
A bien y reflechir, ce serait un truc de ce type :
Element I_______I I_______I I+combine():ElementxElementxElement I_______I / / IOperateur I IValeur I I_________I I_______I I I I-int Valeur I_________I I_______I I I I+GetV()I I I I+SetV()I I I I______I I+Combine():ElementxElement I+SetOperande() I+GetResultat I_________I
On 12 fév, 16:50, "lyland" <lylan...@free.fr> wrote:
Plein de pistes dans ta réponse :)
A bien y reflechir, ce serait un truc de ce type :
Element
I_______I
I_______I
I+combine():ElementxElementxElement
I_______I
/
/
IOperateur I IValeur I
I_________I I_______I
I I I-int Valeur
I_________I I_______I
I I I+GetV()I
I I I+SetV()I
I I I______I
I+Combine():ElementxElement
I+SetOperande()
I+GetResultat
I_________I
A bien y reflechir, ce serait un truc de ce type :
Element I_______I I_______I I+combine():ElementxElementxElement I_______I / / IOperateur I IValeur I I_________I I_______I I I I-int Valeur I_________I I_______I I I I+GetV()I I I I+SetV()I I I I______I I+Combine():ElementxElement I+SetOperande() I+GetResultat I_________I
tu veux dire setOperande(Element left, Element right) ou setOperande(type_d_operateur) ???
il est plus simple de transmettre ces éléments par le constructeur. je ne suis pas convaincu qu'ils doivent être mutable, on préférera regénérer une expression complète si besoin.
par ailleurs, ce n'est pas générique, certaines opérateurs sont unaires (exemple plus bas).
GetResultat()
une valeur immédiate (fixe ou mutable), un opérateur unaire (not, inverse, factoriel, opposé, etc), un opérateur binaire (+,-,*,...) doivent tous s'évaluer de la même façon, ou l'arbre sera délibérément compliqué à évaluer (test systématique sur le type de noeud); il est bcp plus pertinent d'utiliser un polymorphisme généralisé.
Valeur, methodes GetV() SetV
ça pourquoi pas.
Vous programeriez ça comment, en java ?
je ne programmerais pas exactement "ça" ...
Sylvain.
lyland wrote on 12/02/2007 16:54:
En gros Elements, methode Combine():ElementxElementxElement
"Combine" est vague, "ElementxElementxElement" est mystérieux.
je ne devine pas ce à quoi tu penses ici.
tu veux dire setOperande(Element left, Element right)
ou setOperande(type_d_operateur) ???
il est plus simple de transmettre ces éléments par le constructeur.
je ne suis pas convaincu qu'ils doivent être mutable, on préférera
regénérer une expression complète si besoin.
par ailleurs, ce n'est pas générique, certaines opérateurs sont unaires
(exemple plus bas).
GetResultat()
une valeur immédiate (fixe ou mutable), un opérateur unaire (not,
inverse, factoriel, opposé, etc), un opérateur binaire (+,-,*,...)
doivent tous s'évaluer de la même façon, ou l'arbre sera délibérément
compliqué à évaluer (test systématique sur le type de noeud); il est bcp
plus pertinent d'utiliser un polymorphisme généralisé.
tu veux dire setOperande(Element left, Element right) ou setOperande(type_d_operateur) ???
il est plus simple de transmettre ces éléments par le constructeur. je ne suis pas convaincu qu'ils doivent être mutable, on préférera regénérer une expression complète si besoin.
par ailleurs, ce n'est pas générique, certaines opérateurs sont unaires (exemple plus bas).
GetResultat()
une valeur immédiate (fixe ou mutable), un opérateur unaire (not, inverse, factoriel, opposé, etc), un opérateur binaire (+,-,*,...) doivent tous s'évaluer de la même façon, ou l'arbre sera délibérément compliqué à évaluer (test systématique sur le type de noeud); il est bcp plus pertinent d'utiliser un polymorphisme généralisé.
Valeur, methodes GetV() SetV
ça pourquoi pas.
Vous programeriez ça comment, en java ?
je ne programmerais pas exactement "ça" ...
Sylvain.
lyland
En gros Elements, methode Combine():ElementxElementxElement
"Combine" est vague, "ElementxElementxElement" est mystérieux. je ne devine pas ce à quoi tu penses ici.
Ah! Désolé, c'est de l'ulm. en java, ca devrait se programmer de ce type :
public Element Combine(Element a, Element b, Element c) { Element r; switch b { case "*": r=a*c; break; case "+": r=a+c; break; etc ... } return(r); }
En fait, en t'expliquant ça, je crois que j'ai touché du doigt ce qui me bloquait. J'essaierais ce soir :)
Merci.
En gros Elements, methode Combine():ElementxElementxElement
"Combine" est vague, "ElementxElementxElement" est mystérieux.
je ne devine pas ce à quoi tu penses ici.
Ah! Désolé, c'est de l'ulm.
en java, ca devrait se programmer de ce type :
public Element Combine(Element a, Element b, Element c)
{
Element r;
switch b
{
case "*": r=a*c; break;
case "+": r=a+c; break;
etc ...
}
return(r);
}
En fait, en t'expliquant ça, je crois que j'ai touché du doigt ce qui
me bloquait.
J'essaierais ce soir :)
En gros Elements, methode Combine():ElementxElementxElement
"Combine" est vague, "ElementxElementxElement" est mystérieux. je ne devine pas ce à quoi tu penses ici.
Ah! Désolé, c'est de l'ulm. en java, ca devrait se programmer de ce type :
public Element Combine(Element a, Element b, Element c) { Element r; switch b { case "*": r=a*c; break; case "+": r=a+c; break; etc ... } return(r); }
En fait, en t'expliquant ça, je crois que j'ai touché du doigt ce qui me bloquait. J'essaierais ce soir :)
Merci.
Sylvain
lyland wrote on 13/02/2007 15:56:
en java, ca devrait se programmer de ce type :
switch b { }
retour à ma 1ière réponse, "un gros switch ne serait pas une solution"; j'aurais du dire "serait la plus mauvaise des solutions", puisque c'en est une malgré tout.
Sylvain.
lyland wrote on 13/02/2007 15:56:
en java, ca devrait se programmer de ce type :
switch b
{
}
retour à ma 1ière réponse, "un gros switch ne serait pas une solution";
j'aurais du dire "serait la plus mauvaise des solutions", puisque c'en
est une malgré tout.
retour à ma 1ière réponse, "un gros switch ne serait pas une solution"; j'aurais du dire "serait la plus mauvaise des solutions", puisque c'en est une malgré tout.
