20XX-XX.livre.developpons-en-java.java2016-11-07

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....................................................................................................................................................5
Historique des versions............................................................................................................................................5
Partie 1 : Les bases du langage Java...................................................................................................................................8
1. Présentation de Java.........................................................................................................................................................9
1.1. Les caractéristiques...........................................................................................................................................9
1.2. Un bref historique de Java...............................................................................................................................10
1.3. Les différentes éditions et versions de Java....................................................................................................11
1.3.1. Les évolutions des plates-formes Java..................................................................................................12
1.3.2. Les différentes versions de Java............................................................................................................13
1.3.3. Java 1.0..................................................................................................................................................13
1.3.4. Java 1.1..................................................................................................................................................14
1.3.5. Java 1.2 (nom de code Playground)......................................................................................................14
1.3.6. J2SE 1.3 (nom de code Kestrel)............................................................................................................14
1.3.7. J2SE 1.4 (nom de code Merlin)............................................................................................................15
1.3.8. J2SE 5.0 (nom de code Tiger)...............................................................................................................15
1.3.9. Java SE 6 (nom de code Mustang)........................................................................................................16
1.3.9.1. Les évolutions de Java 6.............................................................................................................16
1.3.9.2. Java 6 update...............................................................................................................................19
1.3.10. Java SE 7.............................................................................................................................................26
1.3.10.1. Les JSR de Java 7.....................................................................................................................28
1.3.10.2. Java 7 update.............................................................................................................................29
1.3.11. Les futures versions de Java................................................................................................................30
1.3.12. Le résumé des différentes versions.....................................................................................................31
1.3.13. Le support des différentes versions.....................................................................................................31
1.3.14. Les extensions du JDK........................................................................................................................31
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................32
1.5. Les différences entre Java et JavaScript..........................................................................................................33
1.6. L'installation du JDK.......................................................................................................................................34
1.6.1. L'installation de la version 1.3 du JDK de Sun sous Windows 9x........................................................34
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................36
1.6.3. La configuration des variables système sous Windows 9x...................................................................37
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................38
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................38
1.6.6. L'installation de la version 1.5 du JDK de Sun sous Windows.............................................................39
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................40
2. Les notions et techniques de base en Java....................................................................................................................44
2.1. Les concepts de base.......................................................................................................................................44
2.1.1. La compilation et l'exécution................................................................................................................44
2.1.2. Les packages.........................................................................................................................................47
2.1.3. Le déploiement sous la forme d'un jar..................................................................................................49
2.1.4. Le classpath...........................................................................................................................................50
2.1.4.1. La définition du classpath pour exécuter une application...........................................................52
2.1.4.2. La définition du classpath pour exécuter une application avec la variable CLASSPATH.........54
2.1.4.3. La définition du classpath pour exécuter une application utilisant une ou plusieurs
bibliothèques.............................................................................................................................54
2.1.4.4. La définition du classpath pour exécuter une application packagée en jar.................................55
2.2. L'exécution d'une applet..................................................................................................................................57
Développons en Java

Table des matières
3. La syntaxe et les éléments de bases de Java.................................................................................................................58
3.1. Les règles de base............................................................................................................................................58
3.2. Les identificateurs...........................................................................................................................................58
3.3. Les commentaires............................................................................................................................................59
3.4. La déclaration et l'utilisation de variables.......................................................................................................59
3.4.1. La déclaration de variables...................................................................................................................59
3.4.2. Les types élémentaires..........................................................................................................................60
3.4.3. Le format des types élémentaires..........................................................................................................61
3.4.4. L'initialisation des variables..................................................................................................................62
3.4.5. L'affectation..........................................................................................................................................62
3.4.6. Les comparaisons..................................................................................................................................63
3.5. Les opérations arithmétiques...........................................................................................................................63
3.5.1. L'arithmétique entière...........................................................................................................................63
3.5.2. L'arithmétique en virgule flottante........................................................................................................64
3.5.3. L'incrémentation et la décrémentation..................................................................................................65
3.6. La priorité des opérateurs................................................................................................................................65
3.7. Les structures de contrôles..............................................................................................................................66
3.7.1. Les boucles............................................................................................................................................66
3.7.2. Les branchements conditionnels...........................................................................................................67
3.7.3. Les débranchements..............................................................................................................................68
3.8. Les tableaux.....................................................................................................................................................68
3.8.1. La déclaration des tableaux...................................................................................................................68
3.8.2. L'initialisation explicite d'un tableau....................................................................................................69
3.8.3. Le parcours d'un tableau.......................................................................................................................69
3.9. Les conversions de types.................................................................................................................................70
3.9.1. La conversion d'un entier int en chaîne de caractère String..................................................................70
3.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................71
3.9.3. La conversion d'un entier int en entier long..........................................................................................71
3.10. La manipulation des chaînes de caractères...................................................................................................71
3.10.1. Les caractères spéciaux dans les chaines............................................................................................72
3.10.2. L'addition de chaînes de caractères.....................................................................................................72
3.10.3. La comparaison de deux chaines........................................................................................................72
3.10.4. La détermination de la longueur d'une chaine....................................................................................73
3.10.5. La modification de la casse d'une chaine............................................................................................73
4. La programmation orientée objet.................................................................................................................................74
4.1. Le concept de classe........................................................................................................................................74
4.1.1. La syntaxe de déclaration d'une classe..................................................................................................74
4.2. Les objets.........................................................................................................................................................75
4.2.1. La création d'un objet : instancier une classe........................................................................................75
4.2.2. La durée de vie d'un objet.....................................................................................................................77
4.2.3. La création d'objets identiques..............................................................................................................77
4.2.4. Les références et la comparaison d'objets.............................................................................................77
4.2.5. L'objet null............................................................................................................................................78
4.2.6. Les variables de classes.........................................................................................................................78
4.2.7. La variable this......................................................................................................................................78
4.2.8. L'opérateur instanceof...........................................................................................................................79
4.3. Les modificateurs d'accès................................................................................................................................79
4.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................80
4.3.2. Le mot clé static....................................................................................................................................80
4.3.3. Le mot clé final.....................................................................................................................................81
4.3.4. Le mot clé abstract................................................................................................................................82
4.3.5. Le mot clé synchronized.......................................................................................................................82
4.3.6. Le mot clé volatile.................................................................................................................................82
4.3.7. Le mot clé native...................................................................................................................................83
4.4. Les propriétés ou attributs...............................................................................................................................83
4.4.1. Les variables d'instances.......................................................................................................................83
4.4.2. Les variables de classes.........................................................................................................................83
4.4.3. Les constantes.......................................................................................................................................83
Développons en Java

Table des matières
4. La programmation orientée objet
4.5. Les méthodes...................................................................................................................................................83
4.5.1. La syntaxe de la déclaration..................................................................................................................84
4.5.2. La transmission de paramètres..............................................................................................................85
4.5.3. L'émission de messages........................................................................................................................85
4.5.4. L'enchainement de références à des variables et à des méthodes.........................................................86
4.5.5. La surcharge de méthodes.....................................................................................................................86
4.5.6. Les constructeurs...................................................................................................................................87
4.5.7. Le destructeur........................................................................................................................................87
4.5.8. Les accesseurs.......................................................................................................................................88
4.6. L'héritage.........................................................................................................................................................88
4.6.1. Le principe de l'héritage........................................................................................................................88
4.6.2. La mise en oeuvre de l'héritage.............................................................................................................89
4.6.3. L'accès aux propriétés héritées..............................................................................................................89
4.6.4. La redéfinition d'une méthode héritée...................................................................................................89
4.6.5. Le polymorphisme................................................................................................................................89
4.6.6. Le transtypage induit par l'héritage facilite le polymorphisme.............................................................89
4.6.7. Les interfaces et l'héritage multiple......................................................................................................90
4.6.8. Des conseils sur l'héritage.....................................................................................................................91
4.7. Les packages...................................................................................................................................................92
4.7.1. La définition d'un package....................................................................................................................92
4.7.2. L'utilisation d'un package......................................................................................................................92
4.7.3. La collision de classes...........................................................................................................................93
4.7.4. Les packages et l'environnement système.............................................................................................93
4.8. Les classes internes.........................................................................................................................................93
4.8.1. Les classes internes non statiques.........................................................................................................95
4.8.2. Les classes internes locales...................................................................................................................99
4.8.3. Les classes internes anonymes............................................................................................................102
4.8.4. Les classes internes statiques..............................................................................................................102
4.9. La gestion dynamique des objets..................................................................................................................104
5. Les packages de bases...................................................................................................................................................105
5.1. Les packages selon la version du JDK..........................................................................................................105
5.2. Le package java.lang.....................................................................................................................................111
5.2.1. La classe Object..................................................................................................................................112
5.2.1.1. La méthode getClass()..............................................................................................................112
5.2.1.2. La méthode toString()...............................................................................................................112
5.2.1.3. La méthode equals()..................................................................................................................112
5.2.1.4. La méthode finalize()................................................................................................................112
5.2.1.5. La méthode clone()...................................................................................................................113
5.2.2. La classe String...................................................................................................................................113
5.2.3. La classe StringBuffer.........................................................................................................................115
5.2.4. Les wrappers.......................................................................................................................................116
5.2.5. La classe System.................................................................................................................................117
5.2.5.1. L'utilisation des flux d'entrée/sortie standard............................................................................117
5.2.5.2. Les variables d'environnement et les propriétés du système....................................................119
5.2.6. Les classes Runtime et Process...........................................................................................................121
5.3. La présentation rapide du package awt java..................................................................................................123
5.4. La présentation rapide du package java.io....................................................................................................124
5.5. Le package java.util.......................................................................................................................................124
5.5.1. La classe StringTokenizer...................................................................................................................124
5.5.2. La classe Random...............................................................................................................................125
5.5.3. Les classes Date et Calendar...............................................................................................................125
5.5.4. La classe SimpleDateFormat..............................................................................................................126
5.5.5. La classe Vector..................................................................................................................................127
5.5.6. La classe Hashtable.............................................................................................................................128
5.5.7. L'interface Enumeration......................................................................................................................128
5.5.8. La manipulation d'archives zip...........................................................................................................129
5.5.9. Les expressions régulières..................................................................................................................132
Développons en Java

Table des matières
5. Les packages de bases
5.5.9.1. Les motifs.................................................................................................................................132
5.5.9.2. La classe Pattern.......................................................................................................................134
5.5.9.3. La classe Matcher.....................................................................................................................135
5.5.10. La classe Formatter...........................................................................................................................137
5.5.11. La classe Scanner..............................................................................................................................137
5.6. La présentation rapide du package java.net..................................................................................................138
5.7. La présentation rapide du package java.applet..............................................................................................138
6. Les fonctions mathématiques.......................................................................................................................................139
6.1. Les variables de classe..................................................................................................................................139
6.2. Les fonctions trigonométriques.....................................................................................................................139
6.3. Les fonctions de comparaisons.....................................................................................................................140
6.4. Les arrondis...................................................................................................................................................140
6.4.1. La méthode round(n)...........................................................................................................................140
6.4.2. La méthode rint(double)......................................................................................................................140
6.4.3. La méthode floor(double)...................................................................................................................141
6.4.4. La méthode ceil(double).....................................................................................................................141
6.4.5. La méthode abs(x)...............................................................................................................................142
6.5. La méthode IEEEremainder(double, double)................................................................................................142
6.6. Les Exponentielles et puissances..................................................................................................................142
6.6.1. La méthode pow(double, double).......................................................................................................142
6.6.2. La méthode sqrt(double).....................................................................................................................143
6.6.3. La méthode exp(double).....................................................................................................................143
6.6.4. La méthode log(double)......................................................................................................................143
6.7. La génération de nombres aléatoires.............................................................................................................143
6.8. La classe BigDecimal....................................................................................................................................144
7. La gestion des exceptions.............................................................................................................................................150
7.1. Les mots clés try, catch et finally..................................................................................................................151
7.2. La classe Throwable......................................................................................................................................152
7.3. Les classes Exception, RunTimeException et Error.....................................................................................153
7.4. Les exceptions personnalisées.......................................................................................................................153
7.5. Les exceptions chaînées................................................................................................................................154
7.6. L'utilisation des exceptions...........................................................................................................................155
8. Le multitâche.................................................................................................................................................................157
8.1. L'interface Runnable.....................................................................................................................................157
8.2. La classe Thread............................................................................................................................................158
8.3. La création et l'exécution d'un thread............................................................................................................160
8.3.1. La dérivation de la classe Thread........................................................................................................160
8.3.2. L'implémentation de l'interface Runnable..........................................................................................161
8.3.3. La modification de la priorité d'un thread...........................................................................................162
8.4. La classe ThreadGroup..................................................................................................................................163
8.5. Un thread en tâche de fond (démon).............................................................................................................163
8.6. L'exclusion mutuelle.....................................................................................................................................164
8.6.1. La sécurisation d'une méthode............................................................................................................164
8.6.2. La sécurisation d'un bloc.....................................................................................................................164
8.6.3. La sécurisation de variables de classes...............................................................................................164
8.6.4. La synchronisation : les méthodes wait() et notify()...........................................................................165
9. JDK 1.5 (nom de code Tiger).......................................................................................................................................166
9.1. Les nouveautés du langage Java version 1.5.................................................................................................166
9.2. L'autoboxing / unboxing................................................................................................................................167
9.3. Les importations statiques.............................................................................................................................167
9.4. Les annotations ou métadonnées (Meta Data)..............................................................................................168
9.5. Les arguments variables (varargs).................................................................................................................168
9.6. Les generics...................................................................................................................................................170
9.7. Les boucles pour le parcours des collections................................................................................................173
Développons en Java