Développons en Java

Développons en Java
Jean Michel DOUDOUX

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

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

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

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