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
Notes de licence......................................................................................................................................................2
Marques déposées...................................................................................................................................................3
Historique des versions...........................................................................................................................................3
Partie 1 : les bases du langage Java....................................................................................................................................5
1. Présentation.......................................................................................................................................................................6
1.1. Les caractéristiques..........................................................................................................................................6
1.2. Bref historique de Java.....................................................................................................................................7
1.3. Les différentes éditions de Java.......................................................................................................................8
1.3.1. Java 1.0...................................................................................................................................................8
1.3.2. Java 1.1...................................................................................................................................................8
1.3.3. Java 1.2...................................................................................................................................................9
1.3.4. Java 1.3...................................................................................................................................................9
1.3.5. Java 1.4 (nom de code Merlin)...............................................................................................................9
1.3.6. Java 1.5 (nom de code Tiger)...............................................................................................................10
1.3.7. Le résumé des différentes versions......................................................................................................10
1.3.8. Les extensions du JDK.........................................................................................................................10
1.4. Un rapide tour d'horizon des API et de quelques outils.................................................................................11
1.5. Les différences entre Java et JavaScript.........................................................................................................12
1.6. L'installation du JDK......................................................................................................................................12
1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x.....................................................12
1.6.2. L'installation de la documentation de java 1.3 sous Windows............................................................15
1.6.3. La configuration des variables système sous Windows.......................................................................16
1.6.4. Les éléments du JDK 1.3 sous Windows.............................................................................................16
2. Les techniques de base de programmation en Java....................................................................................................18
2.1. La compilation d'un code source.....................................................................................................................18
2.2. L'exécution d'un programme et d'une applet...................................................................................................18
2.2.1. L'exécution d'un programme.................................................................................................................18
2.2.2. L'exécution d'une applet........................................................................................................................19
3. La syntaxe et les éléments de bases de java..................................................................................................................20
3.1. Les règles de base............................................................................................................................................20
3.2. Les identificateurs...........................................................................................................................................21
3.3. Les commentaires............................................................................................................................................21
3.4. La déclaration et l'utilisation de variables.......................................................................................................21
3.4.1. La déclaration de variables...................................................................................................................21
3.4.2. Les types élémentaires..........................................................................................................................22
3.4.3. Le format des types élémentaires..........................................................................................................23
3.4.4. L'initialisation des variables..................................................................................................................24
3.4.5. L'affectation..........................................................................................................................................24
3.4.6. Les comparaisons..................................................................................................................................25
3.5. Les opérations arithmétiques...........................................................................................................................25
3.5.1. L'arithmétique entière...........................................................................................................................25
3.5.2. L'arithmétique en virgule flottante........................................................................................................26
3.5.3. L'incrémentation et la décrémentation..................................................................................................27
3.6. La priorité des opérateurs................................................................................................................................28
3.7. Les structures de contrôles..............................................................................................................................28
3.7.1. Les boucles............................................................................................................................................28
3.7.2. Les branchements conditionnels...........................................................................................................30
3.7.3. Les débranchements..............................................................................................................................30
3.8. Les tableaux.....................................................................................................................................................30
3.8.1. La déclaration des tableaux...................................................................................................................31
3.8.2. L'initialisation explicite d'un tableau....................................................................................................31
Développons en Java −630

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

Table des matières
4. La programmation orientée objet
4.7.4. Les packages et l'environnement système.............................................................................................54
4.8. Les classes internes.........................................................................................................................................54
4.8.1. Les classes internes non statiques.........................................................................................................56
4.8.2. Les classes internes locales...................................................................................................................60
4.8.3. Les classes internes anonymes..............................................................................................................63
4.8.4. Les classes internes statiques................................................................................................................64
4.9. La gestion dynamique des objets....................................................................................................................65
5. La bibliothèque de classes java......................................................................................................................................66
5.1. Présentation du package java.lang..................................................................................................................71
5.1.1. La classe Object....................................................................................................................................71
5.1.1.1. La méthode getClass()................................................................................................................71
5.1.1.2. La méthode toString().................................................................................................................72
5.1.1.3. La méthode equals()....................................................................................................................72
5.1.1.4. La méthode finalize()..................................................................................................................72
5.1.1.5. La méthode clone().....................................................................................................................72
5.1.2. La classe String.....................................................................................................................................73
5.1.3. La classe StringBuffer...........................................................................................................................74
5.1.4. Les wrappers.........................................................................................................................................75
5.1.5. La classe System...................................................................................................................................76
5.1.5.1. L'utilisation des flux d'entrée/sortie standard..............................................................................76
5.1.5.2. Les variables d'environnement et les propriétés du système......................................................76
5.1.6. La classe Runtime.................................................................................................................................78
5.2. Présentation rapide du package awt java.........................................................................................................78
5.2.1. Le package java.image..........................................................................................................................79
5.2.2. Le package java.awt.perr......................................................................................................................79
5.3. Présentation rapide du package java.io...........................................................................................................79
5.4. Le package java.util.........................................................................................................................................79
5.4.1. La classe StringTokenizer.....................................................................................................................79
5.4.2. La classe Random.................................................................................................................................80
5.4.3. Les classes Date et Calendar.................................................................................................................80
5.4.4. La classe Vector....................................................................................................................................81
5.4.5. La classe Hashtable...............................................................................................................................82
5.4.6. L'interface Enumeration........................................................................................................................83
5.4.7. Les expressions régulières....................................................................................................................84
5.4.7.1. Les motifs...................................................................................................................................84
5.4.7.2. La classe Pattern.........................................................................................................................86
5.4.7.3. La classe Matcher.......................................................................................................................87
5.5. Présentation rapide du package java.net.........................................................................................................89
5.6. Présentation rapide du package java.applet.....................................................................................................89
6. Les fonctions mathématiques.........................................................................................................................................90
6.1. Les variables de classe....................................................................................................................................90
6.2. Les fonctions trigonométriques.......................................................................................................................90
6.3. Les fonctions de comparaisons.......................................................................................................................90
6.4. Les arrondis.....................................................................................................................................................91
6.4.1. La méthode round(n).............................................................................................................................91
6.4.2. La méthode rint(double)........................................................................................................................91
6.4.3. La méthode floor(double).....................................................................................................................92
6.4.4. La méthode ceil(double).......................................................................................................................92
6.4.5. La méthode abs(x).................................................................................................................................93
6.5. La méthode IEEEremainder(double, double)..................................................................................................93
6.6. Les Exponentielles et puissances....................................................................................................................93
6.6.1. La méthode pow(double, double).........................................................................................................93
6.6.2. La méthode sqrt(double).......................................................................................................................94
6.6.3. La méthode exp(double).......................................................................................................................94
6.6.4. La méthode log(double)........................................................................................................................94
6.7. La génération de nombres aléatoires...............................................................................................................95
Développons en Java −628

Table des matières
6. Les fonctions mathématiques
6.7.1. La méthode random()............................................................................................................................95
7. La gestion des exceptions...............................................................................................................................................96
7.1. Les mots clés try, catch et finally....................................................................................................................96
7.2. La classe Throwable........................................................................................................................................98
7.3. Les classes Exception, RunTimeException et Error.......................................................................................99
7.4. Les exceptions personnalisées.........................................................................................................................99
8. Le multitâche.................................................................................................................................................................101
8.1. L’interface Runnable.....................................................................................................................................101
8.2. La classe Thread............................................................................................................................................102
8.3. La création et l'exécution d’un thread...........................................................................................................104
8.3.1. La dérivation de la classe Thread........................................................................................................104
8.3.2. Implémentation de l’interface Runnable.............................................................................................105
8.3.3. Modification de la priorité d’un thread...............................................................................................106
8.4. La classe ThreadGroup..................................................................................................................................107
8.5. Thread en tâche de fond (démon)..................................................................................................................108
8.6. Exclusion mutuelle........................................................................................................................................108
8.6.1. Sécurisation d’une méthode................................................................................................................108
8.6.2. Sécurisation d’un bloc.........................................................................................................................109
8.6.3. Sécurisation de variables de classes....................................................................................................109
8.6.4. La synchronisation : les méthodes wait() et notify()..........................................................................109
Partie 2 : Développement des interfaces graphiques.....................................................................................................110
9. Le graphisme.................................................................................................................................................................111
9.1. Les opérations sur le contexte graphique......................................................................................................111
9.1.1. Le tracé de formes géométriques........................................................................................................111
9.1.2. Le tracé de texte..................................................................................................................................112
9.1.3. L'utilisation des fontes........................................................................................................................112
9.1.4. La gestion de la couleur......................................................................................................................113
9.1.5. Le chevauchement de figures graphiques...........................................................................................113
9.1.6. L'effacement d'une aire.......................................................................................................................113
9.1.7. La copier une aire rectangulaire..........................................................................................................113
10. Les éléments d'interface graphique de l'AWT.........................................................................................................114
10.1. Les composants graphiques.........................................................................................................................115
10.1.1. Les étiquettes.....................................................................................................................................116
10.1.2. Les boutons.......................................................................................................................................116
10.1.3. Les panneaux.....................................................................................................................................117
10.1.4. Les listes déroulantes (combobox)....................................................................................................117
10.1.5. La classe TextComponent.................................................................................................................119
10.1.6. Les champs de texte..........................................................................................................................119
10.1.7. Les zones de texte multilignes..........................................................................................................120
10.1.8. Les listes............................................................................................................................................121
10.1.9. Les cases à cocher.............................................................................................................................125
10.1.10. Les boutons radio............................................................................................................................126
10.1.11. Les barres de défilement.................................................................................................................126
10.1.12. La classe Canvas.............................................................................................................................128
10.2. La classe Component..................................................................................................................................128
10.3. Les conteneurs.............................................................................................................................................130
10.3.1. Le conteneur Panel............................................................................................................................131
10.3.2. Le conteneur Window.......................................................................................................................131
10.3.3. Le conteneur Frame..........................................................................................................................132
10.3.4. Le conteneur Dialog..........................................................................................................................133
10.4. Les menus....................................................................................................................................................134
10.4.1. Les méthodes de la classe MenuBar.................................................................................................136
10.4.2. Les méthodes de la classe Menu.......................................................................................................136
Développons en Java −627