Développons en Java Jean Michel DOUDOUX

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............................................................................................................................................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.10. Java 6 update.......................................................................................................................................18
1.3.10.1. Java 6 update 1..........................................................................................................................19
1.3.10.2. Java 6 update 2..........................................................................................................................19
1.3.10.3. Java 6 update 3..........................................................................................................................19
1.3.10.4. Java 6 update 4..........................................................................................................................19
1.3.10.5. Java 6 update 5..........................................................................................................................19
1.3.10.6. Java 6 update 6..........................................................................................................................21
1.3.10.7. Java 6 update 7..........................................................................................................................21
1.3.10.8. Java 6 update 10........................................................................................................................22
1.3.10.9. Java 6 update 11........................................................................................................................22
1.3.10.10. Java 6 update 12......................................................................................................................22
1.3.10.11. Java 6 update 13......................................................................................................................22
1.3.10.12. Java 6 update 14......................................................................................................................22
1.3.10.13. Java 6 update 15......................................................................................................................23
1.3.10.14. Java 6 update 16......................................................................................................................23
1.3.11. Les futures versions de Java................................................................................................................23
1.3.12. Le résumé des différentes versions.....................................................................................................23
1.3.13. Les extensions du JDK........................................................................................................................23
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................24
1.5. Les différences entre Java et JavaScript..........................................................................................................25
1.6. L'installation du JDK.......................................................................................................................................26
1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x......................................................26
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................28
1.6.3. La configuration des variables système sous Windows 9x...................................................................29
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................30
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................30
1.6.6. L'installation de la version 1.5 du JDK de Sun sous Windows.............................................................31
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................32
2. Les notions et techniques de base en Java....................................................................................................................36
2.1. Les concepts de base.......................................................................................................................................36
2.1.1. La compilation et l'exécution................................................................................................................36
2.1.2. Les packages.........................................................................................................................................39
2.1.3. Le déploiement sous la forme d'un jar..................................................................................................41
2.1.4. Le classpath...........................................................................................................................................42
Développons en Java

Table des matières
2. Les notions et techniques de base en Java
2.1.4.1. La définition du classpath pour exécuter une application...........................................................44
2.1.4.2. La définition du classpath pour exécuter une application avec la variable CLASSPATH.........46
2.1.4.3. La définition du classpath pour exécuter une application utilisant une ou plusieurs
bibliothèques.............................................................................................................................46
2.1.4.4. La définition du classpath pour exécuter une application packagée en jar.................................47
2.2. L'exécution d'une applet..................................................................................................................................49
3. La syntaxe et les éléments de bases de Java.................................................................................................................50
3.1. Les règles de base............................................................................................................................................50
3.2. Les identificateurs...........................................................................................................................................50
3.3. Les commentaires............................................................................................................................................51
3.4. La déclaration et l'utilisation de variables.......................................................................................................51
3.4.1. La déclaration de variables...................................................................................................................51
3.4.2. Les types élémentaires..........................................................................................................................52
3.4.3. Le format des types élémentaires..........................................................................................................53
3.4.4. L'initialisation des variables..................................................................................................................54
3.4.5. L'affectation..........................................................................................................................................54
3.4.6. Les comparaisons..................................................................................................................................55
3.5. Les opérations arithmétiques...........................................................................................................................55
3.5.1. L'arithmétique entière...........................................................................................................................56
3.5.2. L'arithmétique en virgule flottante........................................................................................................56
3.5.3. L'incrémentation et la décrémentation..................................................................................................57
3.6. La priorité des opérateurs................................................................................................................................58
3.7. Les structures de contrôles..............................................................................................................................58
3.7.1. Les boucles............................................................................................................................................58
3.7.2. Les branchements conditionnels...........................................................................................................60
3.7.3. Les débranchements..............................................................................................................................60
3.8. Les tableaux.....................................................................................................................................................60
3.8.1. La déclaration des tableaux...................................................................................................................61
3.8.2. L'initialisation explicite d'un tableau....................................................................................................61
3.8.3. Le parcours d'un tableau.......................................................................................................................62
3.9. Les conversions de types.................................................................................................................................62
3.9.1. La conversion d'un entier int en chaîne de caractère String..................................................................63
3.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................63
3.9.3. La conversion d'un entier int en entier long..........................................................................................63
3.10. La manipulation des chaînes de caractères...................................................................................................63
3.10.1. Les caractères spéciaux dans les chaines............................................................................................64
3.10.2. L'addition de chaînes de caractères.....................................................................................................64
3.10.3. La comparaison de deux chaines........................................................................................................65
3.10.4. La détermination de la longueur d'une chaine....................................................................................65
3.10.5. La modification de la casse d'une chaine............................................................................................65
4. La programmation orientée objet.................................................................................................................................66
4.1. Le concept de classe........................................................................................................................................66
4.1.1. La syntaxe de déclaration d'une classe..................................................................................................66
4.2. Les objets.........................................................................................................................................................67
4.2.1. La création d'un objet : instancier une classe........................................................................................67
4.2.2. La durée de vie d'un objet.....................................................................................................................69
4.2.3. La création d'objets identiques..............................................................................................................69
4.2.4. Les références et la comparaison d'objets.............................................................................................69
4.2.5. L'objet null............................................................................................................................................70
4.2.6. Les variables de classes.........................................................................................................................70
4.2.7. La variable this......................................................................................................................................70
4.2.8. L'opérateur instanceof...........................................................................................................................71
4.3. Les modificateurs d'accès................................................................................................................................72
4.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................72
4.3.2. Le mot clé static....................................................................................................................................72
4.3.3. Le mot clé final.....................................................................................................................................73
Développons en Java

Table des matières
4. La programmation orientée objet
4.3.4. Le mot clé abstract................................................................................................................................74
4.3.5. Le mot clé synchronized.......................................................................................................................74
4.3.6. Le mot clé volatile.................................................................................................................................74
4.3.7. Le mot clé native...................................................................................................................................75
4.4. Les propriétés ou attributs...............................................................................................................................75
4.4.1. Les variables d'instances.......................................................................................................................75
4.4.2. Les variables de classes.........................................................................................................................75
4.4.3. Les constantes.......................................................................................................................................75
4.5. Les méthodes...................................................................................................................................................76
4.5.1. La syntaxe de la déclaration..................................................................................................................76
4.5.2. La transmission de paramètres..............................................................................................................77
4.5.3. L'émission de messages........................................................................................................................78
4.5.4. L'enchainement de références à des variables et à des méthodes.........................................................78
4.5.5. La surcharge de méthodes.....................................................................................................................78
4.5.6. Les constructeurs...................................................................................................................................79
4.5.7. Le destructeur........................................................................................................................................80
4.5.8. Les accesseurs.......................................................................................................................................80
4.6. L'héritage.........................................................................................................................................................80
4.6.1. Le principe de l'héritage........................................................................................................................80
4.6.2. La mise en oeuvre de l'héritage.............................................................................................................81
4.6.3. L'accès aux propriétés héritées..............................................................................................................81
4.6.4. La redéfinition d'une méthode héritée...................................................................................................81
4.6.5. Le polymorphisme................................................................................................................................81
4.6.6. Le transtypage induit par l'héritage facilite le polymorphisme.............................................................82
4.6.7. Les interfaces et l'héritage multiple......................................................................................................82
4.6.8. Des conseils sur l'héritage.....................................................................................................................84
4.7. Les packages...................................................................................................................................................84
4.7.1. La définition d'un package....................................................................................................................84
4.7.2. L'utilisation d'un package......................................................................................................................84
4.7.3. La collision de classes...........................................................................................................................85
4.7.4. Les packages et l'environnement système.............................................................................................85
4.8. Les classes internes.........................................................................................................................................85
4.8.1. Les classes internes non statiques.........................................................................................................88
4.8.2. Les classes internes locales...................................................................................................................92
4.8.3. Les classes internes anonymes..............................................................................................................94
4.8.4. Les classes internes statiques................................................................................................................95
4.9. La gestion dynamique des objets....................................................................................................................96
5. Les packages de bases.....................................................................................................................................................97
5.1. Les packages selon la version du JDK............................................................................................................97
5.2. Le package java.lang.....................................................................................................................................103
5.2.1. La classe Object..................................................................................................................................103
5.2.1.1. La méthode getClass()..............................................................................................................104
5.2.1.2. La méthode toString()...............................................................................................................104
5.2.1.3. La méthode equals()..................................................................................................................104
5.2.1.4. La méthode finalize()................................................................................................................104
5.2.1.5. La méthode clone()...................................................................................................................105
5.2.2. La classe String...................................................................................................................................105
5.2.3. La classe StringBuffer.........................................................................................................................107
5.2.4. Les wrappers.......................................................................................................................................108
5.2.5. La classe System.................................................................................................................................109
5.2.5.1. L'utilisation des flux d'entrée/sortie standard............................................................................109
5.2.5.2. Les variables d'environnement et les propriétés du système....................................................111
5.2.6. Les classes Runtime et Process...........................................................................................................113
5.3. La présentation rapide du package awt java..................................................................................................116
5.4. La présentation rapide du package java.io....................................................................................................116
5.5. Le package java.util.......................................................................................................................................116
5.5.1. La classe StringTokenizer...................................................................................................................116
Développons en Java

Table des matières
5. Les packages de bases
5.5.2. La classe Random...............................................................................................................................117
5.5.3. Les classes Date et Calendar...............................................................................................................117
5.5.4. La classe SimpleDateFormat..............................................................................................................118
5.5.5. La classe Vector..................................................................................................................................124
5.5.6. La classe Hashtable.............................................................................................................................125
5.5.7. L'interface Enumeration......................................................................................................................125
5.5.8. La manipulation d'archives zip...........................................................................................................126
5.5.9. Les expressions régulières..................................................................................................................129
5.5.9.1. Les motifs.................................................................................................................................130
5.5.9.2. La classe Pattern.......................................................................................................................131
5.5.9.3. La classe Matcher.....................................................................................................................132
5.5.10. La classe Formatter...........................................................................................................................134
5.5.11. La classe Scanner..............................................................................................................................135
5.6. La présentation rapide du package java.net..................................................................................................136
5.7. La présentation rapide du package java.applet..............................................................................................136
6. Les fonctions mathématiques.......................................................................................................................................137
6.1. Les variables de classe..................................................................................................................................137
6.2. Les fonctions trigonométriques.....................................................................................................................138
6.3. Les fonctions de comparaisons.....................................................................................................................138
6.4. Les arrondis...................................................................................................................................................138
6.4.1. La méthode round(n)...........................................................................................................................138
6.4.2. La méthode rint(double)......................................................................................................................139
6.4.3. La méthode floor(double)...................................................................................................................139
6.4.4. La méthode ceil(double).....................................................................................................................140
6.4.5. La méthode abs(x)...............................................................................................................................140
6.5. La méthode IEEEremainder(double, double)................................................................................................140
6.6. Les Exponentielles et puissances..................................................................................................................141
6.6.1. La méthode pow(double, double).......................................................................................................141
6.6.2. La méthode sqrt(double).....................................................................................................................141
6.6.3. La méthode exp(double).....................................................................................................................141
6.6.4. La méthode log(double)......................................................................................................................142
6.7. La génération de nombres aléatoires.............................................................................................................142
6.7.1. La méthode random()..........................................................................................................................142
6.8. La classe BigDecimal....................................................................................................................................142
7. La gestion des exceptions.............................................................................................................................................149
7.1. Les mots clés try, catch et finally..................................................................................................................150
7.2. La classe Throwable......................................................................................................................................151
7.3. Les classes Exception, RunTimeException et Error.....................................................................................152
7.4. Les exceptions personnalisées.......................................................................................................................152
7.5. Les exceptions chaînées................................................................................................................................153
7.6. L'utilisation des exceptions...........................................................................................................................154
8. Le multitâche.................................................................................................................................................................156
8.1. L'interface Runnable.....................................................................................................................................156
8.2. La classe Thread............................................................................................................................................157
8.3. La création et l'exécution d'un thread............................................................................................................159
8.3.1. La dérivation de la classe Thread........................................................................................................159
8.3.2. L'implémentation de l'interface Runnable..........................................................................................160
8.3.3. La modification de la priorité d'un thread...........................................................................................161
8.4. La classe ThreadGroup..................................................................................................................................162
8.5. Un thread en tâche de fond (démon).............................................................................................................162
8.6. L'exclusion mutuelle.....................................................................................................................................163
8.6.1. La sécurisation d'une méthode............................................................................................................163
8.6.2. La sécurisation d'un bloc.....................................................................................................................163
8.6.3. La sécurisation de variables de classes...............................................................................................164
8.6.4. La synchronisation : les méthodes wait() et notify()...........................................................................164
Développons en Java