Développons en Java

Développons en Java
Jean Michel DOUDOUX

Table des matières
Développons en Java.............................................................................................................................................................1
Préambule..............................................................................................................................................................................2
A propos de ce document.........................................................................................................................................2
Remerciements.........................................................................................................................................................4
Notes de licence.......................................................................................................................................................4
Marques déposées....................................................................................................................................................4
Historique des versions............................................................................................................................................4
Partie 1 : les bases du langage Java....................................................................................................................................6
1. Présentation.......................................................................................................................................................................7
1.1. Les caractéristiques...........................................................................................................................................7
1.2. Bref historique de Java......................................................................................................................................8
1.3. Les différentes éditions et versions de Java......................................................................................................9
1.3.1. Java 1.0....................................................................................................................................................9
1.3.2. Java 1.1..................................................................................................................................................10
1.3.3. Java 1.2 (nom de code Playground)......................................................................................................10
1.3.4. J2SE 1.3 (nom de code Kestrel)............................................................................................................10
1.3.5. J2SE 1.4 (nom de code Merlin)............................................................................................................11
1.3.6. J2SE 5.0 (nom de code Tiger)...............................................................................................................11
1.3.7. Java SE 6 (nom de code Mustang)........................................................................................................12
1.3.8. Les futures versions de Java..................................................................................................................15
1.3.9. Le résumé des différentes versions.......................................................................................................15
1.3.10. Les extensions du JDK........................................................................................................................15
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................15
1.5. Les différences entre Java et JavaScript..........................................................................................................17
1.6. L'installation du JDK.......................................................................................................................................17
1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x......................................................17
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................20
1.6.3. La configuration des variables système sous Windows 9x...................................................................21
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................21
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................22
1.6.6. L'installation de la version 1.5 du JDK de Sun sous Windows.............................................................23
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................24
2. Les techniques de base de programmation en Java....................................................................................................27
2.1. La compilation d'un code source.....................................................................................................................27
2.2. L'exécution d'un programme et d'une applet...................................................................................................27
2.2.1. L'exécution d'un programme.................................................................................................................27
2.2.2. L'exécution d'une applet........................................................................................................................28
3. La syntaxe et les éléments de bases de Java.................................................................................................................29
3.1. Les règles de base............................................................................................................................................29
3.2. Les identificateurs...........................................................................................................................................29
3.3. Les commentaires............................................................................................................................................30
3.4. La déclaration et l'utilisation de variables.......................................................................................................30
3.4.1. La déclaration de variables...................................................................................................................30
3.4.2. Les types élémentaires..........................................................................................................................31
3.4.3. Le format des types élémentaires..........................................................................................................32
3.4.4. L'initialisation des variables..................................................................................................................33
3.4.5. L'affectation..........................................................................................................................................33
3.4.6. Les comparaisons..................................................................................................................................34
3.5. Les opérations arithmétiques...........................................................................................................................34
3.5.1. L'arithmétique entière...........................................................................................................................35
3.5.2. L'arithmétique en virgule flottante........................................................................................................35
3.5.3. L'incrémentation et la décrémentation..................................................................................................36
3.6. La priorité des opérateurs................................................................................................................................37
3.7. Les structures de contrôles..............................................................................................................................37
Développons en Java

Table des matières
3. La syntaxe et les éléments de bases de Java
3.7.1. Les boucles............................................................................................................................................37
3.7.2. Les branchements conditionnels...........................................................................................................39
3.7.3. Les débranchements..............................................................................................................................39
3.8. Les tableaux.....................................................................................................................................................39
3.8.1. La déclaration des tableaux...................................................................................................................40
3.8.2. L'initialisation explicite d'un tableau....................................................................................................40
3.8.3. Le parcours d'un tableau.......................................................................................................................41
3.9. Les conversions de types.................................................................................................................................41
3.9.1. La conversion d'un entier int en chaîne de caractère String..................................................................42
3.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................42
3.9.3. La conversion d'un entier int en entier long..........................................................................................42
3.10. La manipulation des chaînes de caractères...................................................................................................42
3.10.1. Les caractères spéciaux dans les chaines............................................................................................43
3.10.2. L'addition de chaines...........................................................................................................................43
3.10.3. La comparaison de deux chaines........................................................................................................44
3.10.4. La détermination de la longueur d'une chaine....................................................................................44
3.10.5. La modification de la casse d'une chaine............................................................................................44
4. La programmation orientée objet.................................................................................................................................45
4.1. Le concept de classe........................................................................................................................................45
4.1.1. La syntaxe de déclaration d'une classe..................................................................................................45
4.2. Les objets.........................................................................................................................................................46
4.2.1. La création d'un objet : instancier une classe........................................................................................46
4.2.2. La durée de vie d'un objet.....................................................................................................................48
4.2.3. La création d'objets identiques..............................................................................................................48
4.2.4. Les références et la comparaison d'objets.............................................................................................48
4.2.5. L'objet null............................................................................................................................................49
4.2.6. Les variables de classes.........................................................................................................................49
4.2.7. La variable this......................................................................................................................................49
4.2.8. L'opérateur instanceof...........................................................................................................................50
4.3. Les modificateurs d'accès................................................................................................................................51
4.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................51
4.3.2. Le mot clé static....................................................................................................................................51
4.3.3. Le mot clé final.....................................................................................................................................52
4.3.4. Le mot clé abstract................................................................................................................................53
4.3.5. Le mot clé synchronized.......................................................................................................................53
4.3.6. Le mot clé volatile.................................................................................................................................53
4.3.7. Le mot clé native...................................................................................................................................54
4.4. Les propriétés ou attributs...............................................................................................................................54
4.4.1. Les variables d'instances.......................................................................................................................54
4.4.2. Les variables de classes.........................................................................................................................54
4.4.3. Les constantes.......................................................................................................................................54
4.5. Les méthodes...................................................................................................................................................55
4.5.1. La syntaxe de la déclaration..................................................................................................................55
4.5.2. La transmission de paramètres..............................................................................................................56
4.5.3. L'émission de messages........................................................................................................................57
4.5.4. L'enchainement de références à des variables et à des méthodes.........................................................57
4.5.5. La surcharge de méthodes.....................................................................................................................57
4.5.6. Les constructeurs...................................................................................................................................58
4.5.7. Le destructeur........................................................................................................................................59
4.5.8. Les accesseurs.......................................................................................................................................59
4.6. L'héritage.........................................................................................................................................................59
4.6.1. Le principe de l'héritage........................................................................................................................59
4.6.2. La mise en oeuvre de l'héritage.............................................................................................................60
4.6.3. L'accès aux propriétés héritées..............................................................................................................60
4.6.4. La redéfinition d'une méthode héritée...................................................................................................60
4.6.5. Le polymorphisme................................................................................................................................60
4.6.6. Le transtypage induit par l'héritage facilite le polymorphisme.............................................................61
Développons en Java

Table des matières
4. La programmation orientée objet
4.6.7. Les interfaces et l'héritage multiple......................................................................................................61
4.6.8. Des conseils sur l'héritage.....................................................................................................................63
4.7. Les packages...................................................................................................................................................63
4.7.1. La définition d'un package....................................................................................................................63
4.7.2. L'utilisation d'un package......................................................................................................................63
4.7.3. La collision de classes...........................................................................................................................64
4.7.4. Les packages et l'environnement système.............................................................................................64
4.8. Les classes internes.........................................................................................................................................64
4.8.1. Les classes internes non statiques.........................................................................................................67
4.8.2. Les classes internes locales...................................................................................................................71
4.8.3. Les classes internes anonymes..............................................................................................................73
4.8.4. Les classes internes statiques................................................................................................................74
4.9. La gestion dynamique des objets....................................................................................................................75
5. Les packages de bases.....................................................................................................................................................76
5.1. Liste des packages selon la version du JDK...................................................................................................76
5.2. Le package java.lang.......................................................................................................................................82
5.2.1. La classe Object....................................................................................................................................82
5.2.1.1. La méthode getClass()................................................................................................................83
5.2.1.2. La méthode toString().................................................................................................................83
5.2.1.3. La méthode equals()....................................................................................................................83
5.2.1.4. La méthode finalize()..................................................................................................................83
5.2.1.5. La méthode clone().....................................................................................................................84
5.2.2. La classe String.....................................................................................................................................84
5.2.3. La classe StringBuffer...........................................................................................................................86
5.2.4. Les wrappers.........................................................................................................................................87
5.2.5. La classe System...................................................................................................................................88
5.2.5.1. L'utilisation des flux d'entrée/sortie standard..............................................................................88
5.2.5.2. Les variables d'environnement et les propriétés du système......................................................90
5.2.6. Les classes Runtime et Process.............................................................................................................92
5.3. Présentation rapide du package awt java.........................................................................................................95
5.4. Présentation rapide du package java.io...........................................................................................................95
5.5. Le package java.util.........................................................................................................................................95
5.5.1. La classe StringTokenizer.....................................................................................................................95
5.5.2. La classe Random.................................................................................................................................96
5.5.3. Les classes Date et Calendar.................................................................................................................96
5.5.4. La classe SimpleDateFormat................................................................................................................97
5.5.5. La classe Vector..................................................................................................................................103
5.5.6. La classe Hashtable.............................................................................................................................104
5.5.7. L'interface Enumeration......................................................................................................................104
5.5.8. La manipulation d'archives zip...........................................................................................................105
5.5.9. Les expressions régulières..................................................................................................................108
5.5.9.1. Les motifs.................................................................................................................................109
5.5.9.2. La classe Pattern.......................................................................................................................110
5.5.9.3. La classe Matcher.....................................................................................................................111
5.5.10. La classe Formatter...........................................................................................................................113
5.5.11. La classe Scanner..............................................................................................................................114
5.6. Présentation rapide du package java.net.......................................................................................................115
5.7. Présentation rapide du package java.applet...................................................................................................115
6. Les fonctions mathématiques.......................................................................................................................................116
6.1. Les variables de classe..................................................................................................................................116
6.2. Les fonctions trigonométriques.....................................................................................................................116
6.3. Les fonctions de comparaisons.....................................................................................................................117
6.4. Les arrondis...................................................................................................................................................117
6.4.1. La méthode round(n)...........................................................................................................................117
6.4.2. La méthode rint(double)......................................................................................................................118
6.4.3. La méthode floor(double)...................................................................................................................118
Développons en Java

Table des matières
6. Les fonctions mathématiques
6.4.4. La méthode ceil(double).....................................................................................................................118
6.4.5. La méthode abs(x)...............................................................................................................................119
6.5. La méthode IEEEremainder(double, double)................................................................................................119
6.6. Les Exponentielles et puissances..................................................................................................................120
6.6.1. La méthode pow(double, double).......................................................................................................120
6.6.2. La méthode sqrt(double).....................................................................................................................120
6.6.3. La méthode exp(double).....................................................................................................................120
6.6.4. La méthode log(double)......................................................................................................................120
6.7. La génération de nombres aléatoires.............................................................................................................121
6.7.1. La méthode random()..........................................................................................................................121
7. La gestion des exceptions.............................................................................................................................................122
7.1. Les mots clés try, catch et finally..................................................................................................................123
7.2. La classe Throwable......................................................................................................................................124
7.3. Les classes Exception, RunTimeException et Error.....................................................................................125
7.4. Les exceptions personnalisées.......................................................................................................................125
8. Le multitâche.................................................................................................................................................................127
8.1. L'interface Runnable.....................................................................................................................................127
8.2. La classe Thread............................................................................................................................................128
8.3. La création et l'exécution d'un thread............................................................................................................130
8.3.1. La dérivation de la classe Thread........................................................................................................130
8.3.2. Implémentation de l'interface Runnable.............................................................................................131
8.3.3. Modification de la priorité d'un thread................................................................................................132
8.4. La classe ThreadGroup..................................................................................................................................133
8.5. Thread en tâche de fond (démon)..................................................................................................................133
8.6. Exclusion mutuelle........................................................................................................................................134
8.6.1. Sécurisation d'une méthode.................................................................................................................134
8.6.2. Sécurisation d'un bloc.........................................................................................................................134
8.6.3. Sécurisation de variables de classes....................................................................................................135
8.6.4. La synchronisation : les méthodes wait() et notify()...........................................................................135
9. JDK 1.5 (nom de code Tiger).......................................................................................................................................136
9.1. Les nouveautés du langage Java version 1.5.................................................................................................136
9.2. Autoboxing / unboxing..................................................................................................................................136
9.3. Static import..................................................................................................................................................137
9.4. Les méta données (Meta Data)......................................................................................................................138
9.5. Les arguments variables (varargs).................................................................................................................138
9.6. Les generics...................................................................................................................................................140
9.7. Amélioration des boucles pour les collections..............................................................................................143
9.8. Les énumérations (type enum)......................................................................................................................145
Partie 2 : Développement des interfaces graphiques.....................................................................................................149
10. Le graphisme...............................................................................................................................................................150
10.1. Les opérations sur le contexte graphique....................................................................................................150
10.1.1. Le tracé de formes géométriques......................................................................................................150
10.1.2. Le tracé de texte................................................................................................................................151
10.1.3. L'utilisation des fontes......................................................................................................................151
10.1.4. La gestion de la couleur....................................................................................................................152
10.1.5. Le chevauchement de figures graphiques.........................................................................................152
10.1.6. L'effacement d'une aire.....................................................................................................................152
10.1.7. La copier une aire rectangulaire........................................................................................................152
11. Les éléments d'interfaces graphiques de l'AWT......................................................................................................153
11.1. Les composants graphiques.........................................................................................................................154
11.1.1. Les étiquettes.....................................................................................................................................154
11.1.2. Les boutons.......................................................................................................................................155
Développons en Java