Les interfaces

Figure 02 : Le diagramme de classe de la classe Date

implémente l’interface Convertible et l’interface
Comparable

4 Application : Calculer la valeur d’une fonction

mathématique

4.1 Description

Dans cet exercice on vous demande de définir un ensemble de

classes pour représenter des fonctions à une variable formée avec
des constantes, des occurrences de la variable x, les quatre
opérations arithmétiques +, –, ×, / et des appels de quelques
fonctions usuelles comme sin, cos exp, log, etc.
Par exemple :
12 x + sin(3x – 5)
Dans un programme, une expression comme
celle-là peut être efficacement représentée par
une structure arborescente, organisée comme le

203/281
Programmation orientée objet

montre la figure ci-contre, faite des feuilles (les constantes et les

variables), de nœuds à deux « descendants » (les opérateurs
binaires) et de nœuds à un descendant (les fonctions à une
variable).
Les classes qu’il faut définir sont destinées à représenter les
nœuds d’un tel arbre. Il y en a donc plusieurs sortes :
▪ Un nœud représentant une constante qui porte un nombre,
la valeur de la constante,
▪ Un nœud représentant une occurrence de la variable x ne
porte aucune autre information,
▪ Un nœud représentant une opération arithmétique telle
qu’une addition, une soustraction, une multiplication ou
une division. Ce nœud est besoin de deux informations (les
opérandes de l’expression).
▪ Un nœud représentant l’appel d’une fonction usuelle porte
comme information l’expression qui est son argument.

Question 01 :
Expression : On définit l’interface représentant ce qu’ont en
commun toutes les expressions nœuds (c’est-à-dire toutes les
sortes de nœuds de notre structure arborescente) : elle est
composée d’une seule méthode : public double valeur(double
x); qui renvoie la valeur de l’expression pour une valeur de x
donnée. Bien entendu, toutes les classes concrètes de cette
hiérarchie doivent fournir une définition de la méthode valeur.

204/281
Les interfaces

Elles doivent fournir aussi une redéfinition intéressante de la

méthode String toString().

Question 02: Fonction constante : f(x)=a

Constante : est une classe concrète dont chaque instance
représente une occurrence d’une constante. Cette classe est
caractérisée par un attribut constant : la valeur de la constante.
• Pour tester cette classe, on peut utiliser le code suivant qui
permet de calculer la valeur de la fonction f(x)=2 pour x=1
et x=2:
public static void main(String[] args) {
Expression f = new Constante(2) ;
// calcul de la valeur de f(x)=2
int x=1 ;
Double res01= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res01);
X=2 ;
Double res02= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res02);
}
Code de la fonction main permet de calcule la valeur de f(x)=2 pour
x=1 et x=2.

Question 03: Fonction f(x)=x

Variable : est une classe concrète dont chaque instance
représente une occurrence de la variable x. Cette classe n’a
besoin d’aucun attribut.
• Pour tester cette classe, on peut utiliser le code suivant qui
permet de calculer la valeur de la fonction f(x)=x pour x=1
et x=2:

205/281
Programmation orientée objet

public static void main(String[] args) {

Expression f = new Variable() ;
// calcul de la valeur de f(x)=x
int x=1 ;
Double res01= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res01);
X=2 ;
Double res02= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res02);
}
Code de la fonction main permet de calcule la valeur de f(x)=x pour
x=1 et x=2.

Question 04: Fonction avec operateurs f(x)= x + const

Addition, Soustraction, Multiplication, Division : sont des
classes concrètes qui représentent les opérations binaires. C’est
ici qu’on trouve une définition pertinente de la méthode valeur
promise dans l’interface Expression.
• Pour tester cette classe, on peut utiliser le code suivant qui
permet de calculer la valeur de la fonction f(x)=x+3 pour
x=1 et x=2.
public static void main(String[] args) {
Expression f = new Addition ( new Variable(),
new Constante(3));
// calcul de la valeur de f(x)=x
int x=1 ;
double res01= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res01);
x=2 ;
double res02= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res02);
}
Code de la fonction main permet de calcule la valeur de f(x)=x pour
x=1 et x=2.

Du même principe on peut calculer les valeurs des fonctions

f(x)=x-3

206/281
Les interfaces

Expression f = new Soustraction ( new Variable(),

new Constante(3));
f(x)=x*3
Expression f = new Multiplication ( new
Variable(), new Constante(3));
f(x)=2*x+3
Expression f = new Addition ( new
Multiplication(new Constante(2),new Variable()),
new Constante(3));

Question 05:
Amélioration de la fonction avec operateurs f(x)= x + const
OperationBinaire : est une classe abstraite rassemblant ce
qu’ont en commun tous les opérateurs à deux opérandes. Elle a
donc deux membres d’instance, de type Expression, représentant
les deux opérandes, et le constructeur qui va avec.
OperationUnaire : est une classe abstraite rassemblant ce qu’ont
en commun tous les opérateurs à un opérande. Elle doit avoir un
membre d’instance, de type Expression, représentant l’opérande
en question.
• Pour tester cette classe, on peut utiliser le même code du
question 04.

Question 06:
Fonction avec les fonctions usuelles sin, cos, ….
f(x)= new Sin( new Variable())
Sin, Cos, Log, Exp, etc. sont des classes concrètes qui

207/281
Programmation orientée objet

représentent les fonctions standard. Ici on doit trouver une

définition pertinente de la méthode valeur promise dans
l’interface Expression.
• Pour tester cette classe, on peut utiliser le code suivant qui
permet de calculer la valeur de la fonction f(x)= Sin(x) pour
x=PI/2 et x=PI/3
public static void main(String[] args) {
Expression f = new Sin ( new Variable());
//calcul de la valeur de f(x) pour quelques
valeurs de x
System.out.println("f(" + x + ") = " + f.valeur(x));
double x=Math.PI /2 ;
double res01= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res01);
x= Math.PI /2 ;
double res02= f.valeur(x) ;
System.out.println("f(" + x + ") = " + res02);
}
Code de la fonction main permet de calcule la valeur de f(x)=Sin(x)
pour x=PI/2 et x=PI/3.

Exercice 07:
On ne demande pas de résoudre le problème (difficile) de la «
lecture » d’un tel arbre, c’est-à-dire de sa construction à partir
d’un texte, par exemple lu à la console. En revanche, on demande
de montrer que notre structure est bien adaptée au calcul de la
valeur de l’expression pour une valeur donnée de la variable x.
Pour cela, on exécutera un programme d’essai comme celui-ci :
public static void main(String[] args) {
/* codage de la fonction f(x) = 2 * sin(x) + 3 *
cos(x) */
Expression f = new Addition(new Multiplication(new
Constante(2), new Sin(new Variable())), new

208/281
Les interfaces
Multiplication(new Constante(3), new Cos(new
Variable())));

/* calcul de la valeur de f(x) pour quelques

valeurs de x */
double[] tab = { 0, 0.5, 1, 1.5, 2, 2.5 };
for (int i = 0; i < tab.length; i++) {
double x = tab[i];
System.out.println("f(" + x + ") = " +
f.valeur(x));
}
}
Code de la fonction main permet de calcule la valeur de
f(x)=2*Sin(x)+3*cos(x) pour une liste de valeur de x.

L’exécution de ce programme produit l’affichage suivant :

f(0.0) = 3.0
f(0.5) = 3.5915987628795243
f(1.0) = 3.3038488872202123
f(1.5) = 2.2072015782112175
f(2.0) = 0.5701543440099361
f(2.5) = -1.2064865584328883
Résultat du code précèdent

4.2 Éléments de correction

Question 01:
L’interface Expression comporte une seule méthode valeur
public interface Expression {
public double valeur(double x);
}
Code de l’interface Expression

Question 02:
La classe Constante est caractérisée par un attribut de type entier
et implémente l’interface Expression, donc elle redéfinit la
méthode valeur.

209/281