Développons en Java

Développons en Java
Jean Michel DOUDOUX

Table des matières
Développons en Java.............................................................................................................................................................1
A propos de ce document.........................................................................................................................................1
Note de licence.........................................................................................................................................................2
Marques déposées....................................................................................................................................................3
Historique des versions............................................................................................................................................3
Partie 1 : les bases du langage Java....................................................................................................................................4
1. Présentation.......................................................................................................................................................................5
1.1. Les différentes éditions de Java.......................................................................................................................5
1.1.1. Le JDK 1.0......................................................................................................................................6
1.1.2. Le JDK 1.1......................................................................................................................................6
1.1.3. Le JDK 1.2......................................................................................................................................6
1.1.4. Le JDK 1.3......................................................................................................................................7
1.1.5. Le JDK 1.4 béta..............................................................................................................................7
1.1.6. Le résumé des différentes versions.................................................................................................7
1.1.7. Les extensions du JDK....................................................................................................................7
1.2. Les caractéristiques..........................................................................................................................................8
1.3. Les différences entre Java et JavaScript...........................................................................................................9
1.4. L'installation du JDK........................................................................................................................................9
1.4.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x................................................9
1.4.2. L'installation de la documentation sous Windows........................................................................12
1.4.3. La configuration des variables système sous Windows................................................................13
1.4.4. Les éléments du JDK sous Windows............................................................................................13
2. Les techniques de base de programmation en Java....................................................................................................15
2.1. La compilation d'un code source....................................................................................................................15
2.2. L'exécution d'un programme et d'une applet..................................................................................................15
2.2.1. L'exécution d'un programme.........................................................................................................15
2.2.2. L'exécution d'une applet................................................................................................................16
3. La syntaxe et les éléments de bases de java..................................................................................................................17
3.1. Les règles de base............................................................................................................................................17
3.2. Les identificateurs...........................................................................................................................................18
3.3. Les commentaires............................................................................................................................................18
3.4. La déclaration et l'utilisation de variables.......................................................................................................18
3.4.1. La déclaration de variables............................................................................................................18
3.4.2. Les types élémentaires...................................................................................................................19
3.4.3. Le format des types élémentaires...................................................................................................20
3.4.4. L'initialisation des variables...........................................................................................................20
3.4.5. L'affectation...................................................................................................................................21
3.4.6. Les comparaisons...........................................................................................................................21
3.5. Les opérations arithmétiques...........................................................................................................................22
3.5.1. L'arithmétique entière....................................................................................................................22
3.5.2. L'arithmétique en virgule flottante.................................................................................................23
3.5.3. L'incrémentation et la décrémentation...........................................................................................24
3.6. La priorité des opérateurs................................................................................................................................24
3.7. Les structures de contrôles..............................................................................................................................25
3.7.1. Les boucles.....................................................................................................................................25
3.7.2. Les branchements conditionnels....................................................................................................26
3.7.3. Les débranchements.......................................................................................................................27
3.8. Les tableaux.....................................................................................................................................................27
3.8.1. La déclaration des tableaux............................................................................................................27
3.8.2. L'initialisation explicite d'un tableau.............................................................................................28
3.8.3. Le parcours d'un tableau................................................................................................................28
3.9. Les conversions de types.................................................................................................................................29
3.9.1. La conversion d'un entier int en chaine de caractère String..........................................................30
3.9.2. La conversion d'une chaine de caractères String en entier int.......................................................30
3.9.3. La conversion d'un entier int en entier long...................................................................................30
Développons en Java

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

Table des matières
4.9. La gestion dynamique des objets...................................................................................................................62
5. La bibliothèque de classes java......................................................................................................................................63
5.1. Présentation du package java.lang..................................................................................................................67
5.1.1. La classe Object.............................................................................................................................67
5.1.1.1. La méthode getClass()..................................................................................................67
5.1.1.2. La méthode toString()...................................................................................................67
5.1.1.3. La méthode equals().....................................................................................................67
5.1.1.4. La méthode finalize()...................................................................................................67
5.1.1.5. La méthode clone().......................................................................................................68
5.1.2. La classe String..............................................................................................................................68
5.1.3. La classe StringBuffer....................................................................................................................70
5.1.4. Les wrappers..................................................................................................................................70
5.1.5. La classe System............................................................................................................................71
5.1.5.1. L'utilisation des flux d'entrée/sortie standard..............................................................72
5.1.5.2. Les variables d'environnement et les propriétés du système.......................................72
5.1.6. La classe Runtime.........................................................................................................................74
5.2. Présentation rapide du package awt java.........................................................................................................74
5.2.1. Le package java.image...................................................................................................................74
5.2.2. Le package java.awt.perr...............................................................................................................74
5.3. Présentation rapide du package java.io...........................................................................................................74
5.4. Le package java.util.........................................................................................................................................74
5.4.1. La classe StringTokenizer..............................................................................................................75
5.4.2. La classe Random..........................................................................................................................75
5.4.3. Les classes Date et Calendar..........................................................................................................76
5.4.4. La classe Vector.............................................................................................................................77
5.4.5. La classe Hashtable........................................................................................................................78
5.4.6. L'interface Enumeration.................................................................................................................78
5.4.7. Les expressions régulières.............................................................................................................79
5.4.7.1. Les motifs.....................................................................................................................80
5.4.7.2. La classe Pattern...........................................................................................................82
5.4.7.3. La classe Matcher.........................................................................................................82
5.5. Présentation rapide du package java.net.........................................................................................................84
5.6. Présentation rapide du package java.applet.....................................................................................................85
6. Les fonctions mathématiques.........................................................................................................................................86
6.1. Les variables de classe....................................................................................................................................86
6.2. Les fonctions trigonométriques.......................................................................................................................86
6.3. Les fonctions de comparaisons.......................................................................................................................86
6.4. Les arrondis.....................................................................................................................................................87
6.4.1. La méthode round(n)......................................................................................................................87
6.4.2. La méthode rint(double)................................................................................................................87
6.4.3. La méthode floor(double)..............................................................................................................88
6.4.4. La méthode ceil(double)................................................................................................................88
6.4.5. La méthode abs(x)..........................................................................................................................89
6.4.6. La méthode IEEEremainder(double, double)...............................................................................................89
6.5. Les Exponentielles et puissances....................................................................................................................89
6.5.1. La méthode pow(double, double)..................................................................................................89
6.5.2. La méthode sqrt(double)................................................................................................................90
6.5.3. La méthode exp(double)................................................................................................................90
6.5.4. La méthode log(double).................................................................................................................90
6.6. La génération de nombres aléatoires...............................................................................................................90
6.6.1. La méthode random().....................................................................................................................91
7. La gestion des exceptions...............................................................................................................................................92
7.1. Les mots clés try, catch et finally....................................................................................................................92
7.2. La classe Throwable........................................................................................................................................94
7.3. Les classes Exception, RunTimeException et Error.......................................................................................95
7.4. Les exceptions personnalisées.........................................................................................................................95
Développons en Java

Table des matières
8. Le multitâche...................................................................................................................................................................97
Partie 2 : les interfaces graphiques...................................................................................................................................98
9. Le graphisme...................................................................................................................................................................99
9.1 Les opérations sur le contexte graphique.........................................................................................................99
9.1.1 Le tracé de formes géométriques....................................................................................................99
9.1.2 Le tracé de texte............................................................................................................................100
9.1.3 L'utilisation des fontes..................................................................................................................100
9.1.4 La gestion de la couleur................................................................................................................101
9.1.5 Le chevauchement de figures graphiques.....................................................................................101
9.1.6 L'effacement d'une aire.................................................................................................................101
9.1.7 La copier une aire rectangulaire....................................................................................................101
10. Les éléments d'interface graphique de l'AWT.........................................................................................................102
10.1. Les composants graphiques.........................................................................................................................103
10.1.1. Les étiquettes.............................................................................................................................103
10.1.2. Les boutons................................................................................................................................104
10.1.3. Les panneaux.............................................................................................................................104
10.1.4. Les listes déroulantes (combobox).............................................................................................105
10.1.5. La classe TextComponent..........................................................................................................106
10.1.6. Les champs de texte...................................................................................................................107
10.1.7. Les zones de texte multilignes...................................................................................................108
10.1.8. Les listes....................................................................................................................................109
10.1.9. Les cases à cocher......................................................................................................................113
10.1.10. Les boutons radio.....................................................................................................................113
10.1.11. Les barres de défilement..........................................................................................................114
10.1.12. La classe Canvas......................................................................................................................115
10.2. La classe Component..................................................................................................................................116
10.3. Les conteneurs.............................................................................................................................................118
10.3.1. Le conteneur Panel.....................................................................................................................119
10.3.2. Le conteneur Window................................................................................................................119
10.3.3. Le conteneur Frame...................................................................................................................119
10.3.4. Le conteneur Dialog...................................................................................................................121
10.4. Les menus....................................................................................................................................................122
10.4.1 Les méthodes de la classe MenuBar...........................................................................................123
10.4.2. Les méthodes de la classe Menu................................................................................................124
10.4.3. Les méthodes de la classe MenuItem.........................................................................................124
10.4.4. Les méthodes de la classe CheckboxMenuItem........................................................................125
11. La création d'interface graphique avec AWT..........................................................................................................126
11.1. Le dimensionnement des composants.........................................................................................................126
11.2. Le positionnement des composants.............................................................................................................127
11.2.1. La mise en page par flot (FlowLayout)......................................................................................128
11.2.2. La mise en page bordure (BorderLayout)..................................................................................129
11.2.3. La mise en page de type carte (CardLayout).............................................................................130
11.2.4. La mise en page GridLayout......................................................................................................132
11.2.5. La mise en page GridBagLayout...............................................................................................133
11.3. La création de nouveaux composants à partir de Panel..............................................................................135
11.4. Activer ou desactiver des composants........................................................................................................135
11.5. Afficher une image dans une application....................................................................................................135
12. L'interception des actions de l'utilisateur.................................................................................................................136
12.1. Intercepter les actions de l'utilisateur avec Java version 1.0.......................................................................136
12.2. Intercepter les actions de l'utilisateur avec Java version 1.1.......................................................................136
12.2.1. L'interface ItemListener.............................................................................................................138
12.2.2. L'interface TextListener.............................................................................................................140
12.2.3. L'interface MouseMotionListener..............................................................................................140
12.2.4. L'interface MouseListener.........................................................................................................141
Développons en Java