Développons en Java - Idir BOUIFLOU

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............................................................................................................12
1.3.3. Java 1.0..................................................................................................................................................13
1.3.4. Java 1.1..................................................................................................................................................13
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)............................................................................................................14
1.3.8. J2SE 5.0 (nom de code Tiger)...............................................................................................................15
1.3.9. Java SE 6 (nom de code Mustang)........................................................................................................15
1.3.9.1. Les évolutions de Java 6.............................................................................................................16
1.3.9.2. Java 6 update...............................................................................................................................19
1.3.10. Les futures versions de Java................................................................................................................25
1.3.11. Le résumé des différentes versions.....................................................................................................25
1.3.12. Le support des différentes versions.....................................................................................................26
1.3.13. Les extensions du JDK........................................................................................................................26
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................26
1.5. Les différences entre Java et JavaScript..........................................................................................................28
1.6. L'installation du JDK.......................................................................................................................................28
1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x......................................................28
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................30
1.6.3. La configuration des variables système sous Windows 9x...................................................................31
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................32
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................32
1.6.6. L'installation de la version 1.5 du JDK de Sun sous Windows.............................................................33
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................34
2. Les notions et techniques de base en Java....................................................................................................................38
2.1. Les concepts de base.......................................................................................................................................38
2.1.1. La compilation et l'exécution................................................................................................................38
2.1.2. Les packages.........................................................................................................................................41
2.1.3. Le déploiement sous la forme d'un jar..................................................................................................43
2.1.4. Le classpath...........................................................................................................................................44
2.1.4.1. La définition du classpath pour exécuter une application...........................................................46
2.1.4.2. La définition du classpath pour exécuter une application avec la variable CLASSPATH.........48
2.1.4.3. La définition du classpath pour exécuter une application utilisant une ou plusieurs
bibliothèques.............................................................................................................................48
2.1.4.4. La définition du classpath pour exécuter une application packagée en jar.................................49
2.2. L'exécution d'une applet..................................................................................................................................51
3. La syntaxe et les éléments de bases de Java.................................................................................................................52
3.1. Les règles de base............................................................................................................................................52
3.2. Les identificateurs...........................................................................................................................................52
3.3. Les commentaires............................................................................................................................................53
3.4. La déclaration et l'utilisation de variables.......................................................................................................53
Développons en Java

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

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

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