IN101 : résumés de cours

1)   Cours 1.1   Cours 1.2   TP 1  
2)   Cours 2.1   Cours 2.2   TP 2  
3)   Cours 3   TD 3   TP 3  
4)   Cours 4   TD 4   TP 4  
5)   Cours 5   TD 5   TP 5  
6)   Cours 6   TD 6   TP 6  
7)   Cours 7   TD 7   TP 7  
8)   (Cours 8)     TP 8  

 

 

Cours 1.1

I. Présentation de l'unité I.1. Enseignant responsable et coordonnées : Denis BUREAU (5356, D.Bureau) aussi responsable du bloc informatique du Tronc Commun I.2. Autres intervenants : coordonnées Vous devez savoir qui est votre intervenant. Venir me voir sans délai en cas de problème. I.3. Séquencement (8 séquences IN101 + projet PR102) [+ Enseignement de la programmation dans le Tronc Commun, dont la I1]
[+ Séquencement de l'unité]
Ce premier cours de la séquence 1 = introduction ; le prochain rentre dans le vif du sujet ==> beaucoup plus dense. I.4. Évaluation : QCM+mini-écrit (1), QCM+écrit (2), écrit final (3)
I.5. Objectifs - bases de la programmation en langage de haut-niveau
- approche objet
- solution en français à un problème (à découper en sous-problèmes)
- langage Java et quelques bibliothèques
- pas seulement fonctionner, aussi "bien" programmé
- expérience pratique et opérationnelle
 I.6. Approche pédagogique - hypothèse de départ : personne ne sait programmer en java
- les objets d'abord, apprentissage incrémental (pas tout d'une notion) ne peut fonctionner qu'avec votre participation active (par exemple, lire compléments de cours sur la page web) - cours, td, tp, travail personnel, post-assistance (5356/mail/PC), projet Après un TP, ne pas accepter de ne pas comprendre qqch de dit ou d'écrit ! - page web (retenir http://www.esiee.fr/~bureaud/unites.htm) + polycopié + livre
- polycopié = aide-mémoire, autre présentation (utile, mais pas la même progression pédagogique)
- livre très pédagogique, non indispensable, couvre beaucoup plus de choses (3ème ou 4ème édition seulement, english is better). I.7. Votre rôle - cours : ne pas faire de bruit, prendre des notes (je n'écris pas tout), poser des questions, relire (notes, résumé, poly), noter des questions
- td : cours relu, apporter notes de cours, ne pas attendre de correction/essayer, poser des questions, terminer seul les exercices et les essayer sur machine
- tp : cours relu, apporter notes de cours et TD, ne pas regarder une solution, partager le clavier, poser des questions, terminer seul les exercices, demander de l'aide
 I.8. Environnement technique : PC, Linux, JDK1.6, BlueJ (presque tous les labos) chez soi : Windows ou MacOS OK, tout gratuit II. Introduction à la programmation II.1 Informatique (différents "métiers") : Utilisateur, utilisateur avancé, technico-commercial, technicien/dépanneur, programmeur*, concepteur*/analyste, chercheur/théoricien
Lire le premier chapitre de ce poly.
II.2. Performances du matériel - micro-processeur : 1GHz (4) ==> 1ns
- mémoire RAM : 1Go (8), 10ns ==> 10x plus lent, (+ cache, - multi-processeurs, + multi-accès ...)
- disque dur : 1To (1/4), 10ms ==> 1 million x plus lent (==> charger, traiter, sauvegarder)
[+ Description d'un ordinateur] II.3. Langages de programmation II.3.1. Il y en a beaucoup (400 au DOD en 1980) et on en invente presque toutes les semaines !
II.3.2. Niveaux : machine (binaire, 0/1), assemblage (ex: 68k, macro), haut-niveau (X=Y+Z+1)
II.3.3. Traducteurs (assembleur, compilateur, interpréteur)
II.3.4. "Philosophies" : impératif ou déclaratif (rare), fonctionnel, script, structuré ou non (rare), Orienté Objet ou non (classique)
II.3.5. Exemples : C, C++, Java, lisp/scheme, camL, prolog, shell, perl, php, python, ruby, javascript, tcl/tk (outils en électronique), objective-C (iPhone), pascal/delphi, basic/visual (bureautique), ...
II.3.6. Historique (C, C++, Java)
II.3.6.a. C : 1972, Bell Labs AT&T, pour écrire Unix/Linux, ANSI-C 1983, ISO-C 1990 puis 1999, bas niveau, non OO, compilé.
II.3.6.b. C++ : 1983, ", C O.O., compatible ANSI-C, ISO-C++ 1998 puis 2003, mieux mais bas niveau existe toujours, compilé.
II.3.6.c. Java : 1995, Sun MicroSystems, O.O., Java non OO = C++ non OO = C, pas de bas niveau
- inventé pour internet, multiples versions, processeur virtuel = JVM
- source compilé en bytecode, puis interprêté
- avantages = indépendance matérielle, code très petit
- inconvénients = lenteur (realtive, 20x, <2x, temps réel, militaire), JVM très grosse, lente à démarrer (pas un problème pour les serveurs)
 II.3.6.d. Les éditions : SE (Standard), EE (Enterprise), ME (Micro), Card (cartes à puce)
II.3.6.e. Les versions de SE : 1.0 .. 1.4.2 | 1.5 1.6 v7? (open source) - grosses modifications du langage entre 1.4.2 et 1.5
- JRE = Java Runtime Environment (=JVM, utilisation seulement) ≠ ⊂ JDK = Java Development Kit (aussi développement)
- nombre de classes = 200 (v1) à 3700 (v6) II.3.7. Pourquoi Java ?
- langage adapté à l'apprentissage (plus propre, moins permissif, signalement d'erreur, graphique, bibliothèque énorme)
- non OO identique à C/C++ (mais C reste indispensable sur certains kits et pour certaines applications)
- demandé dans les offres d'emploi (> C/C++, standard pour développements web=JEE)
- Java et C ==> se mettre à C++ (3ème langage moins difficile que 2ème) [+ lire chapitre 2]   [+ lire popularité des langages] II.4. Algorithme (on effleure, voir cours en I2/I3/I4info) II.4.1. Définition - méthode systématique pour résoudre un problème en un temps fini
- différence avec les maths ?
- analogie culinaire : ingrédients, étapes, solutions multiples
- plusieurs algorithmes pour résoudre le même problème ==> choix, coût : performance/mémoire/matériel/lisibilité II.4.2. [Compromis espace/temps]
II.4.3. Exemple de la multiplication (par un nombre à plusieurs chiffres)
II.4.3.a. Algorithme classique
II.4.3.b. Algorithme "à la Russe" (lire v1)
II.4.3.c. Exemple 45x19 (lire)
II.4.3.d. Avantages (opérations binaires)
II.4.3.e. Optimisation (moins d'opérations si plus petit nombre à gauche ==> échange)
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - non traité :
 II.4.3.f. Spécification (lire v2)
II.4.3.g. Traduction en Java (pour les curieux) Lire le poly :
pages situées avant le chapitre 1 et annexes 6 & 7
 

Cours 1.2

I. Introduction à la P.O.O. I.1 Programmation "classique" (risques, maintenance) (voir dessin) §
I.2 P.O.O. (voir dessin) §
I.3 Encapsulation (protection autour de la classe et non de l'objet, données privées, services publics) II. Classes et objets II.1 Classe (modèle, description textuelle, statique, emporte-pièce)
II.2 Objet (exemplaire, en mémoire, dynamique, morceau de pâte)
II.3 Exemple: classe Cercle (x, y, rayon), objets c1 et c2 (voir dessin) § Attributs (état), méthodes (comportement), membres II.4 Vocabulaire : instance, instancier, variable d'instance III. Attributs et types de données (Java fortement typé) III.1 Nombre entier, 4 octets, min/max (-2^31..+2^31-1)
Lire ce document (chapitres 1 & 2) sur la représentation des entiers et les débordements arithmétiques.
III.2 Valeur logique (booléenne), vrai ou faux (pas 0 ou 1), conditions/comparaisons
III.3 Mot ou phrase (chaîne de caractères)
III.4 Initialisation des attributs (par défaut selon le type, automatiquement) IV. Méthodes et paramètres IV.1 Méthode (définition, utilité, duplication de code)
IV.1.1 possède: type (1 des 4) + nom + paramètres = signature, instructions = corps
IV.1.2 même nom, mais signatures différentes (surcharge) IV.2 3 sortes IV.2.1 fonction (retourne valeur, type de donnée, appelé sur un objet)
IV.2.2 procédure (ne retourne rien, type Néant, appelé sur un objet)
IV.2.3 constructeur (très spécial, pas de type, pas d'objet, automatique) : initialisation des attributs IV.3 Paramètres (type, nom, absence, ordre)
IV.4 Variable locale ({entre}, type, nom, ni attribut ni paramètre, non initialisée, ni publique ni privée) V. Syntaxe V.1 Généralités V.1.1 Différence min/maj (importante)
V.1.2 Espacement (significatif entre 2 mots/indifférent sinon, un ou plusieurs, [ESPACE]/[TABULATION]/[ENTREE] )
V.1.3 Indentation (décalages/alignements reflètent la structure)
V.1.4 Présentation/style : guide de style
V.1.5 vérifiée à la compilation, => erreurs => BIEN LIRE LES MESSAGES D'ERREUR
Attention ! L'erreur se trouve souvent à la fin de la ligne du dessus. V.1.6 différentes des erreurs à l'exécution (exceptions)
 V.2 Nommage (Obligations et Conventions "obligatoires") V.2.1 O: Identificateur (lettres, chiffres, _, sans chiffre initial, sauf mot réservé)
V.2.2 C: UneClasse => O: fichier UneClasse.java (UneClasse.class)
V.2.3 C: aNomAttribut, verbeMethode(), pNomParametre, vNomVariableLocale
V.2.4 O: exception: le constructeur (= nom de la classe), contradiction ? V.3 Types de données V.3.1 Entier : int (+-/non nul/chiffres, défaut: 0)
V.3.2 Booléen : boolean (false/true, défaut: false)
V.3.3 Chaîne : String ("des mots", défaut: "") **

Lire le poly :
pages situées avant le chapitre 1, sections 1 à 2.2 et annexes 6 & 7

 

TP 1

Projet shapes. (sujet)
 

Cours 2.1

I. Commentaires et documentation
I.1 // jusqu'à la fin de la ligne (ignoré par compilateur)
I.2 /** jusqu'à */ (multiligne, ignoré par compilateur mais JavaDoc)
I.3 Conseils: /** ... */ AVANT chaque classe et AVANT chaque méthode I.3.1 Classe : @author et @version
I.3.2 Méthode : @param et @return
I.3.3 Lire ce guide I.4 /* jusqu'à */ (multi-lignes ou intra-ligne, ignoré par compilateur, attention ! pas d'imbrication, à conserver pour déboguer)
I.5 Dans BlueJ : bouton implémentation (→ source java) / interface (→ javadoc) II. Déclarations II.1 Classe : public class NomClasse { attributs(o.i.), constructeurs(o.i.), autres méthodes(o.i.) } (o.i.) = ordre indifférent
II.2 Attribut : private Type aNomAttribut; protège de l'extérieur de la classe ==> un autre objet de la même classe peut y accéder II.3 Fonction :
public Type nomFonction( paramètres_formels ) { instructions; return expression; }
II.4 Procédure : public void nomProcedure( paramètres_formels ) { instructions; }
II.5 Constructeur : public NomClasse( paramètres_formels ) { instructions; } - rôle = initialiser les attributs ==> naturel : autant de paramètres que d'attributs ==> instructions dans l'ordre des attributs
- mais surcharge ==> plusieurs constructeurs ==> plusieurs moyens d'initialiser un objet (exemple: "origine" ==> 0,0)
 II.6 Paramètres : final Type pNom1, final Type pNom2 ou rien entre les parenthèses de la signature d'une méthode final souvent oublié, mais évite certaines erreurs car le compilateur peut vérifier que le paramètre n'est jamais modifié II.7 Variable locale : Type vNom; en tête du coprs d'une méthode ou juste avant d'en avoir besoin
II.8 Initialisation : Type vNom = valeurInitiale; Impossible pour les paramètres et ne pas utiliser pour les attributs (rôle du constructeur) II.9 Différence déclaration / définition II.9.1 Classe : toujours définition
II.9.2 Méthode : déclaration = juste signature
II.9.3 Variable = définition = initialisation II.10 Durée de vie / visibilité II.10.1 Attribut : durée de vie de l'objet / interne à la classe
II.10.2 Paramètre (formel) : pendant l'exécution de la méthode / interne à la méthode
II.10.3 Variable locale : depuis sa déclaration jusqu'à la fin du bloc / interne au bloc III. Instructions simples III.1 une instruction (se termine par un ;), { des instructions } = un bloc = une instruction composée
III.2 affectation (ou assignation ou ←) non symétrique : vNom= expression; initialisation ≠ déclaration + affectation III.3 retour de résultat (fonction uniquement) : return expression; instruction ≠ expression (notamment opérations) → voir plus loin la définition d'une expression III.4 Fin de méthode (procédure uniquement) : return; (facultatif)
III.5 Affichage (non graphique ==> terminal,console / linux,dos,BlueJ) : System.out.println( uneString ); III.5.1 concaténation de String : "une" + " " + "phrase" → "une phrase"
III.5.2 concaténation d'un type primitif : "Resultat=" + vRes → "Resultat=12" si vRes vaut 12
III.5.3 println ≠ print IV. Objets et références IV.1 création d'un nouvel objet : vC2= new Cercle(); ou vC2= new Cercle( paramètres_effectifs ); (appel automatique du constructeur) si Cercle vC2; auparavant (voir dessin) §
référence, pointeur, adresse / reference type = type objet / référence spéciale = null IV.2 classe **(cf co1.2-V.3.3) spéciale : ne nécessite pas d'appel de constructeur String  vM; puis vM= "mot"; remplace   vM= new String("mot"); ← paramètre effectif
très utilisée, beaucoup de méthodes (exemple: length()), opérateur + IV.3 accès à un attribut (dans la même classe) : vC2.aNomAttribut (sur l'objet c2) ou this.aNomAttribut
this = référence spéciale, à l'objet courant (objet sur lequel a été appelée la méthode)
 IV.4 appel de méthode : vC2.move( paramètres_effectifs ); ou vS= vC2.surface(); (sur l'objet vC2) this.move( paramètres_effectifs ); ou vS= this.surface(); (this = l'objet courant)
l'appel de procédure est un exemple d'instruction et l'appel de fonction est un exemple d'expression IV.5 appels successifs : this.aChaine.length() ou this.getChaine().length() V. Recopies V.1 Type primitif int vE1=12;  int vE2;  vE2=vE1;  vE1=vE1*2;  S.o.p(vE2);? (voir dessin) §
 V.2 Type objet Circle vC1=new Circle(0,0,12);  Circle vC2;  vC2=vC1;  vC1.doubleSize();  S.o.p(vC2.getDiameter())? (voir dessins, clonage) §
 V.3 Passage de paramètre ("par recopie") V.3.1 type primitif ==> recopie de valeur ==> aucun danger void fois2( int pN ) { pN = pN*2; S.o.p(pN); pN=0; }
ailleurs : int vI=12; fois2(vI); S.o.p(vI); V.3.2 type objet ==gt; recopie de référence ==gt; aucun danger pour la référence mais pour l'objet ! void fois2( Circle pC ) { pC.doubleSize(); S.o.p(pC.getDiameter()); pC=null;}
ailleurs : Circle vC=new Circle(0,0,12); fois2(vC); S.o.p(vC.getDiameter()); V.4 Suppression d'objet V.4.1 vC2 = null; ne supprime pas. S'il n'y a pas d'autres références, marque pour suppression.
V.4.2 Garbage Collector = ramasse-miettes, compteur de références, tâche de fond Lire le poly :
tout jusqu'à la section 2.2, sections 4, 5.2.0, 7.1, 7.2, 8.1, et annexes 6 & 7
 

Cours 2.2

I. Composition I.1 Exemple du véhicule : x, y, chassis, roueAv, roueAr (voir dessin1 et dessin2) §
I.2 Relation entre objets ==> diagramme d'objets [**] (voir dessin) §
I.3 ==> diagramme de classes [**] (voir dessin) §
I.4 Recopie, clonage simple (voir dessins) §
I.5 Appel de constructeurs dans un constructeur : un constructeur peut en appeler un autre sur le même objet par this( paramètres ); en première instruction du constructeur [**] Télécharger le viewer PowerPoint si nécessaire. II. Méthodes particulières II.1 Accesseurs (ou fonctions d'accès ou getters) : public typeAttribut getNomAttribut()
  { return this.aNomAttribut; }
protection ==> ne peut être modifié II.2 Modificateurs (ou procédures de modification ou setters) : public void setNomAttribut( typeAttribut pNomParamètre )
  { this.aNomAttribut= pNomParamètre; }
protection ==> tests de cohérence, maintenabilité II.3 Fonctions d'état (accesseurs particuliers, booléens) : public boolean isAdjective()
  { ... return valeurBooléenne; } III. Expressions III.1 Expression référence
1.1) valeur littérale : null et this
1.2) variable : vC1 ou pV1 ou aV1
1.3) new NomClasse()
1.4) appel de fonction : getRoueAv() III.2 Expression arithmétique (entière)
2.1) valeur littérale : -123 ou +45 ou 67
2.2) variable : (locale, attribut, paramètre)
2.3) constante : (locale, attribut, paramètre) déclarée comme suit :
- final int CONSTANTE_LOCALE = 10;
- private final int ATTRIBUT_CONSTANT = 10;
- final int pNomParametre
==> reste constant pendant la méthode 2.4) appel de fonction : getDiameter()
2.5) OP1(expression_arithmétique) : - ou +
2.6) expression_arithmétique OP2 expression_arithmétique : + - * / %
[division entière : / → quotient, % → reste] III.3 Expression booléenne
3.1) valeur littérale : true ou false
3.2) variable : (locale, attribut, paramètre)
3.3) constante : (locale, attribut, paramètre) déclarée comme suit :
- locale : inutile
- private final boolean ATTRIBUT_CONSTANT = true; : rarement utile
- final boolean pNomParametre
==> reste constant pendant la méthode 3.4) appel de fonction : isVisible()
3.5) résultat d'une comparaison avec : < > <= >= == !=
3.6) OP1(expression_booléenne) : ! → NON
3.7) expression_booléenne OP2 expression_booléenne : && → ET ou || → OU
3.8) évaluation paresseuse : s'arrête dès qu'on peut déterminer le résultat (faux avec ET, vrai avec OU) ==> non commutatif (mais même résultat) III.4 Priorité des opérateurs : voir ce tableau IV. Tests IV.1 SI ALORS : if ( expression booléenne ) { instructions si vraie } parenthèses obligatoires même si simplement (ok), certaines instructions écrites ne sont jamais exécutées IV.2 SI ALORS SINON : if ( expression booléenne ) { instructions si vraie } else { instructions si fausse }
IV.3 une instruction sans {} ==> danger ! (en cas d'ajout ou d'imbrication)
IV.4 if successifs non indépendants if (a<0) S.o.p("neg");   if (a>0) S.o.p("pos");   if (a==0) S.o.p("nul");
- amélioration 1 : ajouter 2 else   - amélioration 2 : supprimer le 3ème if V. Récursivité V.1 Une définition : découper un problème en une multitude de sous-problèmes similaires plus simples. Souvent une manière très naturelle de résoudre un problème complexe. Exemple des tours de Hanoï . V.2 Exemple : On suppose savoir faire {AfficherUne *} {AfficherLes N *} = {AfficherUne *} PUIS {AfficherLes N-1 *}
et ainsi de suite jusqu'au cas terminal : N vaut 1. Dans ce cas, inutile de rappeler {AfficherLes 0 *} ! V.3 En java, une méthode peut s'appeler elle-même sans aucune déclaration particulière.
V.4 Élégant mais pas le plus efficace ni en temps ni en mémoire. Répéter des instructions efficacement ==> boucle (voir cours suivant)
V.5 Exercice : écrire la fonction factorielle en utilisant la récursivité. Aide : règle de récurrence n! = n × (n-1)! et cas terminal n≤1 → 1 Lire le poly :
tout jusqu'à la section 2.2, sections 2.3, 3.1, 4, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, et annexes 6 & 7
 

TP 2

Mini-projet de découverte. Projet Picture. Composition, récursivité, génération de javadoc. (sujet)
 

Cours 3

Lire la page division entière (voir cours 2.2 ci-dessus)

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 de la factorielle : SAISIR(n)   f←n   TANT QUE n>2 FAIRE n←n-1   f←f×n FIN TANT QUE   AFFICHE(f)
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 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 ⇒ 5.1 non exact et calculs non exacts. II.5 Valeurs littérales : première forme = ±chiffres. | ±.chiffres | ±chiffres.chiffres
deuxième forme = ±entierE±entier | première formeE±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<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 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);
ne peuvent pas accéder aux attributs d'instance !
⇒ ne peuvent pas appeler de méthodes d'instance
(par contre une méthode non statique peut appeler une méthode statique) 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 toutes les classes
- ⇒ constante de classe : public static final int MAX = 10; (aucun risque) IV. Paquetages : A lire

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

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)

 

TP 3

Tests unitaires. Factorielle (3 versions pour maîtriser les grands nombres). Racine carrée (2 versions pour maîtriser la précision). Équations de droites (5 versions pour maîtriser les cas particuliers). (sujet)
Si le bouton [Exécuter les tests] n'apparaît pas dans BlueJ, menu Outils / Préférences, onglet Divers, cocher la case "Montrer les outils de test" puis OK.
 

Cours 4

I. L'héritage (caractéristique des LOO)
I.1 Relation : - héritage = "est une sorte de"
- différence avec "est composé de" (exemple de mauvais héritage : Vehicule = sorte de Rectangle avec 2 Cercles en plus)
(doit avoir un sens ==> technique de conception, pas de programmation) I.2 Exemple : moyen_de_Transport/Avion
a) diagramme des classes
b) objets en mémoire
c) code java (extends) I.3 Vocabulaire (une classe fille / sous-classe / classe dérivée, hérite / dérive / étend, d'une classe mère / super-classe)
I.4 Héritage unique entre classes (contrairement à C++, compensé par le mécanisme d' Interface) mais transitivité
I.5 Ce qui est hérité (règle: la sous-classe hérite de la super-classe les attributs et les méthodes)
I.6 Exemples d'utilisation et conversion (cast) : a) Avion     a1 = new Avion();       a1.vole();     a1.roule();
b) Transport t1 = new Transport();   t1.roule();    t1.vole();
c) Transport t2 = new Avion();       t2.roule();    t2.vole();
   Avion     a2 = (Avion)t2;         a2.vole();     a2.roule();
d) Avion     a3 = (Avion)t1;
e) Résumé : a1 = t1;   a1 = (Avion)t1;   t1 = a1;
 Légende : erreur de compilation ou erreur à l'exécution ==> exception I.7 Résumé - TypeMère réfMère = (TypeMère)réfFille  ≡  TypeMère réfMère = réfFille  car réfFille est_une_sorte_de TypeMère
- TypeDérivé réfFille = (TypeDérivé)réfMère;
- compilation: type statique/déclaré, exécution: type dynamique/constaté I.8 Redéfinition et polymorphisme
a) Redéfinir dans la sous-classe une méthode de la super-classe
La redéfinition (sous-classe donc classe différente, même nom, paramètres identiques, type retourné compatible ==> identique ou sous-classe )
est différente de (contraire à)
la surcharge (même classe, même nom, paramètres différents, peu importe le type retourné)
b) Exemple : Dans Transport : void freine() { S.o.p( "Appuyer sur le frein" ); }
Dans Avion     : void freine() { S.o.p( "Inverser les reacteurs" ); }
t1.freine();   a1.freine();
t1 = a1;       t1.freine();   (liaison dynamique) c) @Override (uniquement si non private et mêmes nom et paramètres)
d) Si la méthode freine() de la classe Avion a besoin d'appeler la méthode freine() de la classe Transport pour éviter la duplication de code, il faut écrire super.freine(); et non pas simplement freine(); équivalent à this.freine(); qui provoquerait une récursion infinie. I.9 Les constructeurs, super()
a) Situation habituelle :
public Transport( int pRo1, boolean pCo1 ) { this.aNbRoues=pRo1; this.aEstComplet=pCo1; }
- 1ère version : public Avion( int pRo2, boolean pCo2, int pRe2 ) { this.aNbRoues=pRo2; this.aEstComplet=pCo2; this.aNbReacteurs=pRe2; }
- 2ème version : public Avion( int pRo2, boolean pCo2, int pRe2 ) { super( pRo2, pCo2 ); this.aNbReacteurs=pRe2; }
super(...); doit forcément être la 1ère instruction du constructeur. b) Situation par défaut (à ne pas utiliser) :
public Transport() { }
public Avion()     { super(); } c) Hors héritage : un constructeur d'une classe peut en appeler un autre de la même classe pour éviter de la duplication de code par : this(); ou this(paramètres);
(forcément 1ère instruction, comme pour super();) ⇒
Règle générale : Tout appel de constructeur ne peut être écrit que comme première instruction d'un autre constructeur. d) Exception à la règle I.4) :
La sous-classe hérite de la super-classe les attributs et les méthodes sauf les constructeurs.
Raison évidente : le constructeur doit porter le même nom que la classe ! e) Contrainte (pour mémoire) : - si ∃ dans Transport un constructeur avec paramètre(s), alors constructeur obligatoire dans toutes les sous-classes
- si ∃ dans Transport un constructeur sans paramètre, alors constructeur non obligatoire dans les sous-classes I.10 Protection
a) problème: hérité ≠ accessible. Résolu dans les constructeurs, mais ... Exemple, dans Avion :
void vole() { if (aEstComplet) S.o.p( "peut atterrir" );
else S.o.p( "doit bruler du carburant avant d'atterrir" ); } b) 3 solutions pour les attributs :
Solution 1 : public boolean aEstComplet;
Inconvénient : n'importe quelle classe peut accéder/modifier cet attribut. ⇒ NON Solution 2 : protected boolean aEstComplet;
Avantage : la classe et ses sous-classes peuvent y accéder.
Inconvénient : toutes les classes du même paquetage peuvent aussi y accéder. ⇒ NON Solution 3 : private boolean aEstComplet;
public boolean isComplet() { return this.aEstComplet; }
Avantage : sécurité maximale, accès ≠ modification.
Inconvénient : on doit définir un accesseur, et éventuellement un modificateur. ⇒ OUI c) 2 solutions pour les méthodes : Solution 1 : public boolean estComplet()
Inconvénient : n'importe quelle classe peut appeler cette méthode, ce qui est souvent souhaité ⇒ OUI Solution 2 : protected boolean estComplet()
Avantage : la classe et ses sous-classes peuvent appeler cette méthode, mais aucune classe hors du paquetage. ⇒ OUI (exception à la règle du I.4: sauf les méthodes privées)
 d) 4ème niveau de protection : (package-private) = aucun mot java
protection mot-clé java  la classe courante   autre classe
du paquetage 		  sous-classe
dans un autre paquetage 		  reste du monde 
privé private Oui NonNonNon
paquetage   OuiOui NonNon
protégé protected OuiOuiOui Non
public public OuiOui OuiOui
II. La classe Object
II.1 mère de toutes les classes
a) héritage direct
class Transport extends Object (par défaut) b) héritage indirect
class Avion extends Transport II.2 @Override public String toString()
a) existe dans Object, retourne "@abcdef"
b) déjà redéfinie dans toutes les classes du JDK
c) à redéfinir dans toute nouvelle classe (si on veut pouvoir l'afficher)
d) appelée automatiquement à chaque conversion en String et notamment dans un System.out.println( ); II.3 @Override public boolean equals( Object pO )
a) existe dans Object, compare les références
b) déjà redéfinie dans toutes les classes du JDK
c) à redéfinir dans toute nouvelle classe (si on veut pouvoir faire des comparaisons)
d) signature OBLIGATOIRE (pas equals( Avion pA ) sinon ce n'est pas une redéfinition)
e) propriétés :
1) x.equals(null) retourne faux
2) x.equals(x) retourne vrai (réflexivité)
3) x.equals(y)==y.equals(x) (symétrie) ==> x et y de même classe
f) cas particulier des String : Attention à == ! II.4 @Override public void finalize() peut être redéfinie
(appelée automatiquement par le GC avant la destruction de l'objet)
a) existe dans Object, ne fait rien { }
b) déjà redéfinie dans les classes du JDK qui le nécessitent
c) à redéfinir si nécessaire dans une nouvelle classe
II.5 final Class getClass() NE peut être redéfinie (voir aussi l'opérateur instanceof, est_une_instance_de ou peut_etre_converti_en). Exemples :
t2.getClass() == a2.getClass() ≡ t2.getClass() == Avion.class
t2 instanceof Avion && t2 instanceof Transport && t2 instanceof Object  == true
null instanceof AnyClass retourne toujours false
anyNonNullReference instanceof Object retourne toujours true
II.6 Il existe plusieurs autres méthodes (non étudiées dans cette unité)
par exemple clone() ou hashCode()
 II.7 Exemple de hiériarchie de classes : 
        Object <|-- ...
                |-- ... <|-- JComponent <|-- JTextComponent
                |-- ...                  |--- JEditorPane (editeur de texte)
                                         |--- JTextArea (zone multilignes)
                                         |--- JTextField (zone monoligne)

Lire le poly :
tout jusqu'à la section 2.4.1, sections 2.5, 3.1, 3.2.2, 3.6, 4, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, 8.2.2.1, 9.1 à 9.5, 13.3, et annexes 6 & 7

 

TD 4

Points et points colorés. Héritage, redéfinition, toString(), equals(). Comptage du nombre d'instances.
(sujet)
 

TP 4

DBShape. Héritage, redéfinition, equals(). Comptage du nombre d'instances et Garbage Collector. Paquetages.
(sujet)
 

Cours 5

I. Types primitifs I.1 Déjà vus : boolean, int, long, double
I.2 "Nouveaux" : I.2.A float (réel/32 bits) : 6 chiffres significatifs, constantes littérales = 3.14F
I.2.B short (entier/16 bits, signé)
I.2.C byte (entier/8 bits, signé)
I.2.D char : - chaque caractère est codé par un entier sur 16 bits (et non plus 7 ou 8)
- C/C++: même nom, mais 8 bits, signé, ASCII
- JAVA: 16 bits, non signé, Unicode
- mais Unicode ⊃ ASCII (128 premiers caractères)
0 < contrôles < * < espace < * < chiffres < * < majuscules < * < minuscules < * ≤ 127 < ascii_étendu ≤ 255
- constantes littérales 'a' ou '\t' ( 1 ≠ '1' ≠ "1" )
- pas d'opérateurs sauf conversion ←→ int
- String s = "Bonjour"; char c = s.charAt(0); => c vaut 'B'
I.3 Résumé :
types primitifs = boolean + types "numériques"
types "numériques" = char + types entiers + types réels
types entiers = byte, short, int, long
types réels = float, double I.4 Conversions (entre types primitifs)
I.4.A) Syntaxe : (type_primitif_souhaité)expression_d'un_autre_type_primitif
I.4.B) impossible : boolean ←→ autre_type
I.4.C) sans perte :
I.4.D) avec perte : les autres (y compris si même nombre d'octets ; pourquoi ?)
II. Tableaux II.1 Utilité - regroupement de données homogènes (et pour données hétérogènes ?)
- manipulation en une seule entité (notamment passage de paramètre)
- possibilité de faire des boucles (comment afficher tous les attributs d'un objet ?) II.2 Définition - tableau de taille fixe : à la compilation (C/C++) ou à l'exécution (Java)
- regroupement de données de même type, accessibles par leur rang, dont la taille est fixée à l'exécution, mais une fois pour toutes II.3 Nouveau type - éléments de type T => tableau de type T[]
- considéré comme une classe => hérite d'Object => un tableau est un objet => référence
- attribut public length = taille du tableau = nombre de cases ≠ nombre d'éléments utiles (et ne pas confondre avec la méthode length() de la classe String) II.4 Déclaration - type var; => T[] aTab;
- T est n'importe quel type, primitif ou objet, y compris tableau
- déclaré mais pas créé => 0 cases mémoire II.5 Création (=>allocation mémoire) - aTab = new T[taille];
- taille est une expression entière positive (pas long), sinon NegativeArraySizeException
- pour les variables locales, souvent en une seule fois : T[] vTab = new T[taille]; II.6 Accès à une valeur (lecture/écriture) - par le rang, appelé indice
- expression entière (pas long) entre 0 et aTab.length-1, sinon ArrayIndexOutOfBoundsException ! (gros avantage sur C/C++)
- 1ère valeur = aTab[0], ou aTab[2*i-1] = -x/2; II.7 Initialisation - type primitif : typePrimitif var = expression;, exemple: double r = 3.14;
- type objet : Classe var = new Classe( valeurs );, exemples: Point p = new Point(2,4);
- classe particulière : String s = new String( "Bonjour" ); peut être abrégée en String s = "Bonjour";
- Tableau (syntaxe particulière) : int[] t = new int[] {10,20,30}; peut être abrégée en int[] t = {10,20,30}; uniquement dans une initialisation
- Exemple : int[] nbJours = {31, 28, 31, ..., 30, 31}; remplace les 13 lignes
int[] nbJours = new int[12];
nbJours[0] = 31; nbJours[1] = 28; ... nbJours[11] = 31; II.8 Saisie/affichage : rien de prévu => à redéfinir soi-même ! (nbJours.toString() retourne "[I@abcdef")
II.9 fonctionnements non souhaités : = ne recopie pas les valeurs
== ne compare pas les valeurs
final ne protège pas les valeurs II.10 java.util.Arrays (equals, toString, fill, sort, binarySearch) - méthodes statiques => un paramètre de plus !
- void fill(tab,val) remplit toutes les valeurs de tab avec val
- String toString(tab) retourne "[10, 20, 30]"
- boolean equals(tab1,tab2) compare les tailles et les valeurs des 2 tableaux
- void sort(tab) trie les valeurs de tab
- int binarySearch(tab,val) retourne l'indice de val trouvée dans tab II.11 Cas particulier : caractères - String ≠ char[] tc;
- mais String s = new String(tc); et tc = s.toCharArray();
- car String ne peut être modifiée alors que char[] si ! II.12 Multi-dimensionnels
II.12.a Un élément de tableau peut être de n'importe quel type, donc aussi un tableau ! Un tableau de tableau donne un tableau bi-dimensionnel.
II.12.b int[][] bidim = new int[3][2]; ==> nouveau type ( int[][] ) et 2 indices.
bidim[ligne][colonne] pour accéder à une case.
int[][] peut être vu comme un tableau de int[] (puisque X[] est un tableau de X)
Attention ! new int[3][2] ne signifie pas un tableau de 2 int[3] mais un tableau de 3 int[2] !
II.12.c initialisation possible : int[][] bidim = { {11, 12}, {21, 22}, {31, 32} };
II.12.d Un tableau peut avoir plus de 2 dimensions, et même plus de 5 ! Exemple :
    Pixel[][][][][][][] journee = new Pixel[20][10][30][25][3][1920][1080];
                                             ^   ^   ^   ^  ^     ^     ^
                            plages par journée   ^   ^   ^  ^     ^     ^
                                   spots par plage   ^   ^  ^     ^     ^
                                     secondes par spot   ^  ^     ^     ^
                                        images par seconde  ^     ^     ^
                                     plans couleurs par image     ^     ^
                                                    lignes par plan     ^
                                                       colonnes par ligne
 et pourquoi pas par an, par chaîne, etc ...
II.12.e Arrays.deepToString( tab ) et Arrays.deepEquals( tab1, tab2 ) III. Boucles
III.1 Déjà vue : la boucle TANT QUE
while ( expression booléenne ) { instructions à répéter}
III.2 Nouvelle : la boucle POUR
III.2.A) Équivalente à la boucle while (intérêt syntaxique) :
initialisation; while ( condition de continuation ) { instructions à répéter; progression; }
initialisation: type_entier variable = expression_entière par exemple: int i=0
condition de continuation: comparaison sur la variable par exemple: i <= 15
progression: modification de la variable par exemple: i = i + 1
 III.2.B) Syntaxe :
for ( initialisation; condition de continuation; progression ) { instructions }
par exemple: for ( int i=0; i<=15; i=i+1 ) { instructions }
Attention ! Seul cas en Java où le caractère ; ne termine pas une instruction.
III.2.C) Opérateurs souvent utilisés
i++ est équivalent à i=i+1 et non à i+1
i-- est équivalent à i=i-1 et non à i-1
i+=4 est équivalent à i=i+4 et non à i+4
i-=3 est équivalent à i=i-3 et non à i-3
i*=2 est équivalent à i=i*2 et non à i*2
III.2.D) Imbrication : 2 for, 2 compteurs (1 lent, 1 rapide), notamment pour les tableaux bi-dimensionnels
 III.3 Nouvelle : la boucle FAIRE TANT QUE
- "contraire" de la boucle Répéter jusqu'à que l'on trouve dans d'autres langages
- intérêt : instructions toujours exécutées au moins une fois avant le test de continuation
III.4 Caractéristiques et choix de boucles
III.4.A) while :
while ( expression booléenne ) { instructions à répéter }
- 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
III.4.B) do while :
do { instructions à répéter } while ( expression booléenne );
- nombre de tours inconnu a priori
- test à la fin, tourne au moins une fois
- les 2 pbs de la boucle while peuvent souvent être évités
- équivalente à :
instructions à répéter while ( expression booléenne ) { instructions à répéter }
III.4.C) for :
for ( instruction d'initialisation ; condition de continuation ; instruction de progression ) { instructions à répéter }
- nombre de tours calculable a priori
- test au début, peut tourner 0 fois
- les 2 pbs de la boucle while sont traités
- il est fortement conseillé d'inclure la déclaration de variable dans l'instruction d'initialisation pour que la variable reste locale
- équivalente à :
instruction d'initialisation; while ( condition de continuation ) { instructions à répéter instruction de progression; }
 III.4.D) Critères de choix : 2 questions successives
- première question à se poser :
le nb de tours peut-il être connu à l'avance ?
- si OUI, c'est une boucle for
- si NON, seconde question à se poser :
l'instruction dans la boucle doit-elle être exécutée au moins une fois ?
- si OUI, c'est une boucle do while
- si NON, c'est une boucle while

IV. Développer sans BlueJ (et sans IDE)
IV.1 Édition de texte (nedit, emacs, nano, vi, vim, notepad, kwrite, kate, ultraedit, ...)
nedit UneClasse.java & IV.2 Compilation
javac UneClasse.java   ou   javac *.java
 IV.3 Exécution
java UneClasse   ou   java UneClasse mot1 mot2
mais quelle méthode est lancée ? (sinon NoSuchMethodError) IV.4 Signature obligatoire pour cette méthode : 
    public static void main( String[] pArgs ) { instructions }
    ^^3^^^ ^^4^^^ ^2^^ ^1^^  ^^^5^^^^ ^^6^^     ^^^^^7^^^^^^
 - 1: le nom est imposé (veut dire "principal")
- 2: car c'est une procédure (qui ne retourne rien)
- 3: car elle est appelée en dehors de la classe (par le système d'exploitation)
- 4: car il serait ennuyeux que le système d'exploitation doive d'abord créer un objet avant de pouvoir appeler cette procédure
- 5: un et un seul paramètre obligatoire (aucun=interdit, 2 ou plus=interdit) et forcément du type tableau de String
la taille est facilement disponible et pArgs[0] contient le premier argument après java NomClasse (alors que c'est argv[1] en C ou C++)
- 6: seule liberté : le choix du nom du paramètre (mais presque tout le monde utilise args !)
- 7: Si le corps est vide, le programme ne fera rien. S'il se termine par System.exit( valeur ); , la valeur sera retournée au système d'exploitation comme code d'erreur. IV.5 Documentation
publique (pour les utilisateurs de la classe) : javadoc *.java -author -version -drépertoire
privée (pour les programmeurs, maintenance de la classe) : javadoc *.java -author -version -drépertoire -private -linksource
 V. Style d'écriture des programmes en Java : recommandations à respecter (rappels)

Lire le poly :
tout jusqu'à la section 2.4.1, sections 2.5, 3.1, 3.2.2, 3.6, 4, 5.1, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, 8.2.2, 9.1 à 9.5, 13.3, et annexes 6 & 7

 

TP 5

Moyenne. Crible d'Ératosthène. Groupes. (sujet du TP)
 

Cours 6

I. Abstraction
I.1 Classe abstraite
I.1.a DBShape s = new DBShape( ); s.draw( ); --> drawSpec( ) "bidon"
I.1.b interdire l'instanciation, mais laisser en commun ce qui doit l'être; classe prévue pour être dérivée
I.1.c constructeurs : utiles pour initialiser les attributs communs; appelés par super(...);
I.1.d syntaxe: abstract (public abstract class NomClasse ...) I.2 Méthode abstraite
I.2.a interdire l'exécution ==> pas de corps, évite les corps "bidon" (drawSpec( ) )
I.2.b redéfinition obligatoire dans toutes les sous-classes (sinon elles seront abstraites) ==> ne concerne pas les constructeurs, private interdit, @Override .
Garantit une cohérence, un contrat avec les sous-classes, y compris les futures ==> extensibilité.
I.2.c syntaxe: abstract et ; au lieu de {} (public abstract void nomMethode( ) ; )
I.2.d Si dans une classe il existe une méthode abstraite (non redéfinie), cette classe est abstraite (==> abstract) car objet.methode() doit toujours pouvoir marcher si objet a pu être instancié
I.2.e draw() peut quand-même appeler drawSpec() grâce à la liaison dynamique ==> utilisation de classes non encore écrites ==> garantie d'extensibilité
I.2.f Il est évident qu'une classe non abstraite peut hériter d'une classe abstraite, mais il est aussi possible qu'une classe abstraite hérite d'une classe non abstraite.
I.2.g Dans le JDK : implémentations partielles I.3 Interface (pour compenser l'absence d'héritage multiple)
I.3.a et si 100% des méthodes étaient abstraites ? et aucune variable d'instance ?
I.3.b 100% des méthodes public abstract ==> 2 mots inutiles, et pas de constructeurs
I.3.c 100% des attributs public static final ==> 3 mots inutiles
I.3.d 100% des méthodes à redéfinir ==> pas de @Override
I.3.e syntaxe: interface au lieu de abstract class , implements au lieu de extends , une classe peut implémenter plusieurs interfaces (séparées par des virgules) ==> implémenter toutes les méthodes de toutes les interfaces !
I.3.f exemple d'interfaces: Drawable ==> draw()
Comparable ==> compareTo()
DBShape implements Comparable, Drawable
Circle extends DBShape
Rosace implements Drawable
I.3.g exemple d'objet: Drawable obj = new Circle(); obj.draw(); plutôt que Circle obj = new Circle();
I.3.h classe anonyme: 1) bouton.addActionListener( this ); ==> la classe courante contient actionPerformed()
2) bouton.addActionListener( myButtonListener ); ==> myButtonListener est une instance d'une classe contenant actionPerformed()
3) bouton.addActionListener( new ActionListener() { public void actionPerformed() { instructions } } ); ==> rien de plus ! (classe anonyme) I.3.i héritage d'interfaces: si interface SousI extends SuperI , on devra implémenter toutes les méthodes de SousI et SuperI
héritage multiple ! ==> interface sousI extends superI1, superI2
I.3.j véritable type ==> l'opérateur instanceof fonctionne; comme pour une super-classe (abstraite ou non) : réfObjet instanceof ClasseOuInterface
II. Exceptions
II.1 Résumé de cours
II.2 Essayer la classe de démonstration et la comprendre
II.3 Hiérarchie des exceptions du paquetage java.lang
II.4 Tutoriel (en anglais)
Lire le poly :
tout jusqu'à la section 2.4.1, 2.4.2, sections 2.5, 3.1, 3.2, 3.2.2, 3.3, 3.6, 4, 5.1, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, 8.2.2, 9.1 à 9.5, 9.6, 9.7, 10, 13.3, et annexes 6 & 7
 

TD 6

Comptes bancaires (Abstraction, exceptions).
(sujet)
 

TP 6

DBShape. Abstraction. Exceptions.
(sujet)
 

Cours 7

version définitive à venir ...

Lire ce résumé de cours

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

 

TP 7

DBShape. Collections. Filtrage. Scanner. (sujet)
 

Cours 8

I. Fichiers de texte
I.1 Lecture simple
I.1.a Importation
Il faut importer import java.io.File; et import java.util.Scanner;.
Mais il faudra probablement importer au moins une classe d'exception, la plus générale étant import java.io.IOException;. I.1.b Déclaration de variable
Pour utiliser un fichier de texte (stocké en général sur un disque dur) dans un programme, il faut déclarer une variable d'un type particulier qui "repésentera" ce fichier au sein du programme :
Scanner sr; (sr est le nom de la variable) I.1.c Ouverture
1) Instruction
La déclaration précédente ne fait que déclarer une variable, sans l'initialiser. L'ouverture d'un fichier consiste à associer un fichier sur disque à une variable du programme :
sr = new Scanner( new File( nom_fichier ) );
où nom_fichier est une chaîne de caractères (constante ou variable) contenant le chemin d'accès (absolu ou relatif) au fichier disque.
2) Rappels sur les chemins d'accès (sous Linux)
  • absolus : /chemin ou ~/chemin
  • relatifs : chemin ou ./chemin ou ../chemin
  • chemin : fichier ou répertoire/fichier ou répertoire/sous-répertoire/fichier ou ...
3) Conséquences
Tant que le fichier est ouvert en lecture, les accès en écriture sont refusés à tout autre programme. I.1.d Test d'ouverture
L'ouverture a pu mal se passer dans plusieurs cas, notamment :
  • si le fichier n'existe pas
  • si l'utilisateur n'a pas les droits de lecture sur ce fichier (ou les droits de traverser un répertoire du chemin d'accès)
Il faut donc tester si l'ouverture s'est bien passée avant de commencer à lire dans un fichier supposé ouvert; en Java, cela consiste à traiter une exception, en l'occurence :
FileNotFoundException ou plus généralement IOException. I.1.e Opérations de lecture
  • mot = sr.next(); (pour lire un seul mot; suppose String mot;)
  • ligne = sr.nextLine(); (pour lire une ligne; suppose String ligne;)
    Attention ! Le(s) caractère(s) de fin de ligne ne fait(font) pas partie de la String ligne .
  • e = sr.nextInt(); (pour lire un entier; suppose int e;)
    (de même pour les byte, short, long, float, double, et boolean, mais pas pour les char !)
  • Remarque : La lecture des mots peut être influencée par sr.useDelimiter(String) qui précise les séparateurs de mots à utiliser, et la lecture des nombres peut être influencée par sr.useRadix(int) qui précise la base à utiliser et par sr.useLocale(Locale) qui précise la "localisation" à utiliser.
I.1.f Test de fin de fichier
Après de nombreuses opérations de lecture dans un fichier de texte, il se peut qu'il n'y ait plus rien à lire ! On dit alors qu'on a atteint la fin de fichier.
Selon les systèmes, lire au-delà de cette limite peut soit provoquer une erreur, soit simplement retourner toujours la même donnée.
Il faut donc tester la fin de fichier AVANT chaque lecture (eh oui, le fichier peut être vide !) :
  • while ( sr.hasNext() ) {
      String mot = sr.next();
      traitement du mot lu
    }
  • while ( sr.hasNextLine() ) {
      String ligne = sr.nextLine();
      traitement de la ligne lue
    }
  • while ( sr.hasNextInt() ) {
      int e = sr.nextInt();
      traitement de l'entier lu
    }
  • Remarque : de même pour les byte, short, long, float, double, et boolean, mais pas pour les char !.
I.1.g Fermeture
Comme expliqué au paragraphe "ouverture", le fichier est plus ou moins inaccessible aux autres programmes tant que le fichier reste ouvert.
Il faut donc le fermer le plus tôt possible, c'est-à-dire dès qu'on n'en a plus besoin par l'instruction :
sr.close();
Il est souvent judicieux de placer ces instructions dans une clause finally, en les faisant précéder d'un test tel que : if ( sr != null ) I.1.h Exemples
Soit un fichier contenant :
123  456
+789
 

On peut envisager au moins 3 manières de le lire (les virgules montrent à l'affichage la séparation entre les lectures) :

  1. mot par mot (mot=sr.next();), on obtient : "123","456","+789"
  2. ligne par ligne (ligne=sr.nextLine();), on obtient : "123  456","+789"
  3. terme par terme (e=sr.nextInt();), on obtient : 123,456,789
I.2 Écriture simple
I.2.a Importation
Une seule classe à importer (plus les éventuelles classes d'exception) : import java.io.PrintWriter; I.2.b Déclaration de variable
PrintWriter pw; (pw est le nom de la variable) I.2.c Ouverture
1) Instruction
pw = new PrintWriter( nom_fichier );
où nom_fichier est une chaîne de caractères (constante ou variable) contenant le chemin d'accès (absolu ou relatif) au fichier disque.
2) Conséquences
Tant que le fichier est ouvert en écriture, les accès en lecture et en écriture sont refusés à tout autre programme.
L'écriture commence par le début du fichier en écrasant toutes les données déjà présentes si le fichier existait. I.2.d Test d'ouverture
L'ouverture a pu mal se passer dans plusieurs cas, notamment :
  • si le fichier existe déjà et que l'utilisateur n'a pas les droits de modification sur ce fichier
  • si l'utilisateur n'a pas les droits de modification sur le répertoire contenant le fichier
  • éventuellement selon les systèmes, s'il n'y a plus assez de place sur le disque ou si le quota est insuffisant
Il faut donc tester si l'ouverture s'est bien passée avant de commencer à écrire dans un fichier supposé ouvert; en Java, cela consiste à traiter une exception, en l'occurence :
IOException. I.2.e Opérations d'écriture
  • pw.print( ligne ); (pour écrire une ligne, suppose String ligne; et ligne initialisée)
    Attention ! Pour passer à la ligne suivante, il faut remplacer l'instruction ci-dessus par
    pw.println( ligne );
  • Remarque : Des sorties formattées (presque comme en C) peuvent être obtenues par
    pw.printf( format, arguments );
I.2.f Fermeture
Comme expliqué au paragraphe "ouverture", le fichier est inaccessible aux autres programmes tant que le fichier reste ouvert.
Il faut donc le fermer le plus tôt possible, c'est-à-dire dès qu'on n'en a plus besoin par l'instruction :
pw.close();
Il est souvent judicieux de placer ces instructions dans une clause finally, en les faisant précéder d'un test tel que : if ( pw != null ) I.3 Autres possibilités des fichiers de texte
 II. Applettes
II.1 Concept
  • pas une application indépendante, mais dépend d'une page html
  • s'exécute automatiquement au chargement de la page
  • CORE : indépendant du système d'exploitation
  • restrictions de sécurité : heureusement !
  • il existe appletviewer
II.2 Classe (java.applet.Applet, javax.swing.JApplet)
extends JApplet extends Applet extends Panel => this.add( composant graphique );
II.3 Fichier html : exemple
Obligatoire pour le lancement, BlueJ le crée automatiquement
II.4 Méthodes
  • L'indispensable : init()
  • Les autres méthodes du cycle de vie : start(), stop(), et destroy()
  • Récupération des paramètres : getParameter( stringNomParametre ) Attention : peut être nul !
II.5 Classes anonymes :
SuperClasseAbstraite obj = new SuperClasseAbstraite() { méthodes à redéfinir }; OU
UneInterface obj = new UneInterface() { méthodes à implémenter } II.6 Gestion d'évènements :
  • interface ActionListener => méthode void actionPerformed( ActionEvent pAE ); par exemple pour réagir aux clics sur des boutons
  • package java.awt.event
  • 3 ways to addActionListener() :
    1. bouton1.addActionListener(this); et bouton2.addActionListener(this); et définir dans la classe courante
      public void actionPerformed( ActionEvent pAE ) {
      if (pAE.getActionCommand().equals(texteBouton1)) action1;
      else if (pAE.getActionCommand().equals(texteBouton2)) action2;
      else ... }
    2. bouton1.addActionListener(bouton1Listener); et bouton2.addActionListener(bouton2Listener); et définir 2 classes Bouton1Listener et Bouton2Listener contenant chacune :
      public void actionPerformed( ActionEvent pAE ) { action; }
    3. bouton1.addActionListener( new ActionListener(){ public void actionPerformed( ActionEvent pAE ) { action1; } } );
      et idem pour bouton2
  • interface MouseListener => addMouseListener(...) et méthodes mouseClicked( MouseEvent pME ), mouseEntered( MouseEvent pME ), mouseExited( MouseEvent pME ), mousePressed( MouseEvent pME ), et mouseReleased( MouseEvent pME ).
  • interface KeyListener => addKeyListener(...) et méthodes keyPressed( KeyEvent pKE ), keyReleased( KeyEvent pKE ), et keyTyped( KeyEvent pKE ).
  • interface WindowListener => addWindowListener(...) et méthodes windowClosing( WindowEvent pWE ), et beaucoup d'autres ...
  • Les objets des classes ActionEvent, MouseEvent, KeyEvent et WindowEvent contiennent beaucoup d'informations sur l'évènement concerné.
  • Pour ne pas avoir à tout récrire, étendre les classes abstraites MouseAdapter, KeyAdapter et WindowAdapter.
II.7 Les gestionnaires de disposition
this.setLayout( new XLayout() ); où X peut être Border, Grid, Flow, Card, GridBag, Group, Box, etc... Lire le poly :
tout jusqu'à la section 2.2, sections 3.1, 4, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, et annexes 6 & 7 (à compléter)
 

TP 8

Numérotation d'un fichier de texte. Applette de calcul de moyenne. (sujet)

--> Dernière mise à jour :