Développons en Java - Site perso de Romain Quarré

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. Java 1.3..................................................................................................................................................10
1.3.5. Java 1.4 (nom de code Merlin)..............................................................................................................10
1.3.6. Java 1.5 (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
2. Les techniques de base de programmation en Java....................................................................................................21
2.1. La compilation d'un code source.....................................................................................................................21
2.2. L'exécution d'un programme et d'une applet...................................................................................................21
2.2.1. L'exécution d'un programme.................................................................................................................21
2.2.2. L'exécution d'une applet........................................................................................................................22
3. La syntaxe et les éléments de bases de Java.................................................................................................................23
3.1. Les règles de base............................................................................................................................................23
3.2. Les identificateurs...........................................................................................................................................23
3.3. Les commentaires............................................................................................................................................24
3.4. La déclaration et l'utilisation de variables.......................................................................................................24
3.4.1. La déclaration de variables...................................................................................................................24
3.4.2. Les types élémentaires..........................................................................................................................25
3.4.3. Le format des types élémentaires..........................................................................................................26
3.4.4. L'initialisation des variables..................................................................................................................27
3.4.5. L'affectation..........................................................................................................................................27
3.4.6. Les comparaisons..................................................................................................................................28
3.5. Les opérations arithmétiques...........................................................................................................................29
3.5.1. L'arithmétique entière...........................................................................................................................29
3.5.2. L'arithmétique en virgule flottante........................................................................................................29
3.5.3. L'incrémentation et la décrémentation..................................................................................................30
3.6. La priorité des opérateurs................................................................................................................................31
3.7. Les structures de contrôles..............................................................................................................................32
3.7.1. Les boucles............................................................................................................................................32
3.7.2. Les branchements conditionnels...........................................................................................................33
Développons en Java

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

Table des matières
4. La programmation orientée objet
4.7. Les packages...................................................................................................................................................58
4.7.1. La définition d'un package....................................................................................................................59
4.7.2. L'utilisation d'un package......................................................................................................................59
4.7.3. La collision de classes...........................................................................................................................60
4.7.4. Les packages et l'environnement système.............................................................................................60
4.8. Les classes internes.........................................................................................................................................60
4.8.1. Les classes internes non statiques.........................................................................................................62
4.8.2. Les classes internes locales...................................................................................................................66
4.8.3. Les classes internes anonymes..............................................................................................................69
4.8.4. Les classes internes statiques................................................................................................................70
4.9. La gestion dynamique des objets....................................................................................................................71
5. Les packages de bases.....................................................................................................................................................72
5.1. Liste des packages selon la version du JDK...................................................................................................72
5.2. Le package java.lang.......................................................................................................................................76
5.2.1. La classe Object....................................................................................................................................77
5.2.1.1. La méthode getClass()................................................................................................................77
5.2.1.2. La méthode toString().................................................................................................................77
5.2.1.3. La méthode equals()....................................................................................................................77
5.2.1.4. La méthode finalize()..................................................................................................................77
5.2.1.5. La méthode clone().....................................................................................................................78
5.2.2. La classe String.....................................................................................................................................78
5.2.3. La classe StringBuffer...........................................................................................................................79
5.2.4. Les wrappers.........................................................................................................................................80
5.2.5. La classe System...................................................................................................................................81
5.2.5.1. L'utilisation des flux d'entrée/sortie standard..............................................................................81
5.2.5.2. Les variables d'environnement et les propriétés du système......................................................83
5.2.6. La classe Runtime.................................................................................................................................85
5.3. Présentation rapide du package awt java.........................................................................................................85
5.4. Présentation rapide du package java.io...........................................................................................................85
5.5. Le package java.util.........................................................................................................................................85
5.5.1. La classe StringTokenizer.....................................................................................................................86
5.5.2. La classe Random.................................................................................................................................86
5.5.3. Les classes Date et Calendar.................................................................................................................87
5.5.4. La classe Vector....................................................................................................................................88
5.5.5. La classe Hashtable...............................................................................................................................89
5.5.6. L'interface Enumeration........................................................................................................................89
5.5.7. Les expressions régulières....................................................................................................................90
5.5.7.1. Les motifs...................................................................................................................................91
5.5.7.2. La classe Pattern.........................................................................................................................92
5.5.7.3. La classe Matcher.......................................................................................................................93
5.5.8. La classe Formatter...............................................................................................................................95
5.5.9. La classe Scanner..................................................................................................................................96
5.6. Présentation rapide du package java.net.........................................................................................................97
5.7. Présentation rapide du package java.applet.....................................................................................................97
6. Les fonctions mathématiques.........................................................................................................................................98
6.1. Les variables de classe....................................................................................................................................98
6.2. Les fonctions trigonométriques.......................................................................................................................98
6.3. Les fonctions de comparaisons.......................................................................................................................99
6.4. Les arrondis.....................................................................................................................................................99
6.4.1. La méthode round(n).............................................................................................................................99
6.4.2. La méthode rint(double)......................................................................................................................100
6.4.3. La méthode floor(double)...................................................................................................................100
6.4.4. La méthode ceil(double).....................................................................................................................101
6.4.5. La méthode abs(x)...............................................................................................................................101
6.5. La méthode IEEEremainder(double, double)................................................................................................101
6.6. Les Exponentielles et puissances..................................................................................................................102
Développons en Java

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