Cours 3

I. Les boucles I.1 La boucle TANT QUE (fondamentale) I.1.1 En pseudo-langage : TANT QUE condition FAIRE instructions FIN TANT QUE répéter les instructions tant que la condition est vraie c'est-à-dire jusqu'à ce que la condition devienne fausse I.1.2 Exemple : SAISIR(n) TANT QUE n<0 FAIRE AFFICHER_ERREUR puis SAISIR(n) FIN TANT QUE
I.1.3 Caractéristiques : - nombre de tours inconnu a priori
- test au début ⇒ peut tourner 0 fois
- pb d'initialisation de l'expression booléenne
- pb de modification de l'expression booléenne
- comme pour le if, toujours mettre des { } I.1.4 Syntaxe : while ( expression_booléenne ) { instructions_tant_que_vraie } syntaxe ressemble au if mais test ≠ répétition II. Nouveau type primitif : nombre "réel" II.1 type entier = sous-ensemble de Z : [-231, +231-1]
II.2 type "réel" = sous-ensemble de D (et non Q ou R) ⇒ précision limitée ⇒ nombres à virgule flottante. min / max et nombre maximum de chiffres significatifs
exemple : bien que max=1022, 1234567 n'est pas représentable si 6 ch.sig.
ligne réelle (voir dessin) II.3 Java : type primitif sur 8 octets : double
II.4 Représentation binaire : 1|11|52 bits → signe | exposant (<10±308) | mantisse (16 ch.sig.)
beaucoup plus complexe : voir représentation des nombres réels et pour encore plus d'explications lire floating point numbers
somme d'inverses de puissances de deux différentes ⇒ 0.1 non exact et calculs non exacts. II.5 Valeurs littérales : première forme = ±chiffres.chiffres | ±chiffres. | ±.chiffres
deuxième forme = première formeE±entier | ±entierE±entier
exemples : 0.5 -4. .32 (=0,32) 1E-6 (=10-6) 2.5E12 (=2,5x10+12) II.6 Opérateurs II.6.1 unaires : + -
II.6.2 binaires : + - * / %
/ = division réelle ⇔ au moins un des deux nombres est réel
% = définition du modulo étendue aux réels : toujours la relation a = b × q + r mais avec q toujours entier II.7 Fonctions mathématiques (dans la classe Math) racine carrée = square root = sqrt
abs, sin, cos, tan, log, log10, exp, pow, ... voir syntaxe d'appel ci-dessous (III.1) II.8 Comparaisons - < et > : OK
- <=, >=, ==, != : INTERDIT ! (problèmes de précision)
- |x-y|<ε remplace x==y
- encore mieux en tenant compte de l'ordre de grandeur : |(x-y)/y|<ε ou |x/y - 1|<ε
II.9 Conversions - avec perte : int vE = (int)vR; (nouvelle expression entière, ce n'est pas la partie entière, c'est une troncature)
  Exemples : (int)3.14 → 3   (int)-3.14 → -3   Partie_entière(-3.14) → -4
- sans perte (car 31 bits < 52) : vR = (double)vE; (pour la division, nouvelle expression réelle)
- en String : vS = new String(vR); ou vS = "" + vR;
- possible String → double ou int (voir syntaxe au III.1 ci-dessous)


III. Membres de classe (≠ membres d'instance)

III.1 Méthodes de classe ne nécessitent pas d'instance pour être appelées ⇒ sont appelées directement sur la classe
Exemple : vR = Math.sqrt(vX); ou vR = Double.parseDouble( vChaine );
ne peuvent pas accéder aux attributs d'instance !
⇒ ne peuvent pas appeler de méthodes d'instance (qui nécessitent une instance) ;
par contre, une méthode d'instance peut appeler une méthode de classe III.2 Syntaxe : - On les reconnaît dans la javadoc car signature commence par static
- On les déclare en ajoutant static après public III.3 Attributs de classe - On désire compter le nombre de cercles.
- Si attribut d'instance aNbCercles, valeur dupliquée dans chaque cercle, et si le constructeur l'incrémente, vaut 1 dans tous les cercles !
- On a besoin d'un attribut partagé par tous les objets de la classe Cercle. III.4 Syntaxe : - On les reconnaît dans la javadoc car leur déclaration commence par static
- On les déclare en ajoutant static après private III.5 Initialisation des attributs statiques - Mais comment les initialiser avant même qu'un objet soit créé ?
- static { instructions } à mettre en tête de classe, un peu l'équivalent pour la classe du constructeur pour l'objet : exécuté automatiquement une seule fois au chargement de la classe III.6 Application : les constantes - Déjà vu : private final int MAX = 10;
- mais même valeur dupliquée dans tous les objets de la classe
- ⇒ constante de classe : public static final int MAX = 10; (aucun risque de modification)
- Les accès : MAX ou Classe.MAX mais objetDeLaClasse.MAX est possible IV. Paquetages : à lire (au programme des contrôles ...)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - non traité (voir TP3)
V. Tests unitaires avec JUnit :

V.1 Utilité : ne tester qu'à la fin le programme complet est difficile et souvent trop tard (et long à corriger)
V.2 Principe du Test Driven Development (TDD) : Tester chaque méthode séparément et même développer le test avant la méthode !
V.3 Exemple avant d'écrire la fonction abs() :
public void test() { assertTrue(abs(0)==0); assertTrue(abs(1)==1); assertTrue(abs(-2)==2); int vI=3; while (vI<100) assertTrue(abs(-vI)==abs(vI)); }
V.4 Passer UN test n'est pas sufisant ; passer vos tests n'est pas suffisant ; passer nos tests n'est peut-être pas suffisant ;
ne pas oublier la phrase de Dijkstra : «Tester un programme peut démontrer la présence de bugs, jamais leur absence.».
V.5 Dans BlueJ, existe un outil de création automatique de jeux de tests utilisant :
V.6 JUnit : à lire (pour les TP)

Lire le poly :
tout jusqu'à la section 2.3, sections 2.4.1, 2.5, 3.1, 4, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, 8.2.2.1, 13.3, et annexes 6 & 7 (à compléter)

--> Dernière mise à jour :