Vous êtes sur la page 1sur 41

IFT-21133

Programmation avancée
en Java

Guide pédagogique

Pierre Marchand
Été 2001
ii
Table des matières

Avant-propos ......................................................................................................................v

Partie I : Présentation du cours


Titre................................................................................................................................3
Sigle ...............................................................................................................................3
Session ...........................................................................................................................3
Nombre de crédits ..........................................................................................................3
But du cours ...................................................................................................................3
Clientèle .........................................................................................................................3
Description.....................................................................................................................3
Préalable.........................................................................................................................3
Exigences particulières ..................................................................................................4
Matériel pédagogique.....................................................................................................4
Objectifs généraux des unités ........................................................................................4
Bibliographie..................................................................................................................4
Professeur pour la section à distance .............................................................................5
Cheminement d’apprentissage .......................................................................................5
Activités d’évaluation ....................................................................................................6
Accès Internet ................................................................................................................7
Codes d’accès.................................................................................................................9
Outils de programmation .............................................................................................11
Calendrier.....................................................................................................................12

Partie II : Étude des unités

Introduction......................................................................................................................15

Unité 1 : Concepts de base..............................................................................................18


Unité 2 : Structures de contrôle ......................................................................................22
Unité 3 : Méthodes, tableaux et la classe Vector ............................................................23
Unité 4 : La programmation à base d'objets....................................................................25
Unité 5 : Programmation orientée objet..........................................................................26
Unité 6 : Chaînes, caractères, graphiques et Java2D ......................................................27
Unité 7 : L'interface utilisateur graphique I ....................................................................29
Unité 8 : L'interface utilisateur graphique II...................................................................30
Unité 9 : Exceptions et processus légers.........................................................................31
Unité 10 : Fichiers, flux et réseaux ...................................................................................33
Unité 11 : Programmation client/serveur I : JDBC et servlets..........................................35

Conclusion ........................................................................................................................37

iii
Avant-Propos
Bonjour et bienvenue au cours IFT-21133, Programmation avancée en Java, section à
distance. Le présent guide a pour but de décrire la démarche pédagogique que nous
adoptons dans ce cours et le cheminement d’apprentissage que nous vous recommandons
pour atteindre les objectifs du cours.

Le cours Programmation avancée en Java suppose que vous avez déjà suivi les cours
Algorithmique et Programmation (IFT-17582) et Structures de données (IFT-10541) et
que vous maîtrisez donc la programmation en C. Il vous demandera néanmoins des
efforts importants. En effet, la matière à couvrir est vaste et plusieurs des concepts
présentés ne vous sont sans doute pas familiers. Nous ne ménagerons aucun effort pour
vous aider à réussir le cours, mais nous vous rappelons que vous êtes le premier
responsable de votre apprentissage.

La charge de travail d’un cours de 3 crédits est habituellement de 9 heures par semaine
pendant 15 semaines, ce qui représente 135 heures de travail. Pour un cours régulier, ceci
inclut trois heures de classe par semaine. Comme, dans un cours à distance, vous n’avez
pas ces trois heures de classe et que le cours ne dure que 13 semaines, vous aurez au
moins trois heures de lecture à effectuer chaque semaine. Les six autres heures serviront à
faire les exercices proposés et les devoirs obligatoires.

Nous vous souhaitons donc une bonne session et espérons que vous partagerez notre
enthousiasme pour le langage Java.

iv
Partie I
Présentation du cours
2
Titre : Programmation avancée en Java

Sigle : IFT-21133ZI

Session : Été 2001

Nombre de crédits : 3

But du cours :

Le présent cours vise à donner à l’étudiante ou à l’étudiant une solide formation en


programmation orientée objet. Cette formation s’effectuera à travers l’apprentissage
du langage Java.

Clientèle

Ce cours s’adresse :
aux étudiantes et aux étudiants du certificat ou de la mineure en informatique,
aux étudiantes et aux étudiants du baccalauréat en informatique, en informatique de
génie, en informatique de gestion et en informatique mathématique.

Description

Java est un langage de programmation évolué, simple, portable, à usage multiple et


sécuritaire. Il combine quatre paradigmes de programmation: impératif, orienté objet,
distribué et parallèle. Il permet la mobilité du code « applet » à travers des sites
informatiques. Le but du cours est d'étudier en détail tous les aspects de la
programmation en Java (classes, objets, méthodes, etc.); héritage, interface;
programmation parallèle: processus légers (threads); programmation réseau;
programmation W3: applets; programmation graphique.

Préalable : IFT-10541 Structures de données

Exigences particulières pour le cours à distance :

• Avoir accès à un micro-ordinateur PC (Pentium 160 MHz ou plus avec 32 Mo de


mémoire vive) avec Windows 95, Windows 98 ou Windows NT. L’ordinateur en
question doit être muni d’un modem et idéalement d’une imprimante. Le Macintosh
est déconseillé, car il n’est pas encore à jour en ce qui a trait à Java.

• Avoir accès à Internet et au courrier électronique.

Matériel pédagogique :

• Le manuel obligatoire,
• Le guide Accès Internet à l’Université Laval : se brancher et comprendre,
• Le fascicule Installation de Windows 95 en mode PPP,
• Le présent guide pédagogique,

3
Objectifs :

À la fin du cours, l’étudiante ou l’étudiant devra maîtriser les concepts de la


programmation orientée objet. Il sera également en mesure de concevoir des
programmes en langage Java.

Le cours est divisé en 13 unités qui sont prévues pour être abordées une par semaine.

Unité 1 : Concepts de base


Unité 2 : Structures de contrôle
Unité 3 : Méthodes, tableaux et la classe Vector
Unité 4 : La programmation à base d'objets
Unité 5 : La programmation orientée objet
Unité 6 : Chaînes, caractères, graphiques et Java2D
Unité 7 : L'interface utilisateur graphique I
Unité 8 : L'interface utilisateur graphique II
Unité 9 : Exceptions et processus légers
Unité 10 : Fichiers, flux et réseaux
Unité 11 : JDBC et servlets.

Bibliographie
Manuel obligatoire : Comment programmer en Java 2. Deitel et Deitel. Éditions
Reynald Goulet, 2000. ISBN: 2-89377-184-X.

Autres :
Java Software Solutions. Foundations of Program Design, Second Edition.
John Lewis et William Loftus. Addison-Wesley, 2000.
ISBN : 0-201-61271-2.

Au cœur de Java 2. Volume 1 - Notions fondamentales. Cay S. Horstmann et


Gary Cornell, Campus Press, 1999. ISBN: 2-7440-0620-3.

Au cœur de Java 2. Volume 2 – Notions avancées. Cay S. Horstmann et


Gary Cornell. Campus Press, 2000. ISBN: 2-7440-0881-8.

Java : de l’esprit à la méthode, 2e édition. Michel Bonjour, Gilles Falquet,


Jaques Guyot et André Le Grand. Vuibert, 1999. ISBN : 2-7117-8647-1.

Le programmeur Java2. Laura Lemay & Rogers Cadenhead, Campus Press,


1998. ISBN: 2-7440-0644-0.

An Introduction to Object-Oriented Programming with Java. C. Thomas


Wu, WCB/McGraw-Hill, 1999. ISBN: 0--256-25462-1

4
Introduction to Programming Using Java. An object-Oriented Approach..
Java 2 Update. David Arnow et Gerald Weiss. Addison-Wesley, 2000.
ISBN : 0-201-61272-0

Computing concepts witn Java 2 essentials, 2nd Edition. Cay Horstmann,


John Wiley & Sons, 2000. ISBN: 0-471-34609-8.

Professeur pour la section à distance


Pierre Marchand
Bureau : 3958 du pavillon Adrien-Pouliot
Disponibilité au bureau : les après-midi de 14h à 17h
Téléphone : Région de Québec 656-2131, poste 7409
Ailleurs : 1-888-757-8077 (sans frais d'interurbain)
Disponibilité au téléphone : les après-midi de 14h à 17h.
Les mardi et mercredi soirs de 19h à 22h.
Télécopieur : (418) 656-2324
Courriel: marchand@ift.ulaval.ca
Chargé de cours au trimestre d’été 2001 : stephane.nicolas@ift.ulaval.ca
Page Web pour le cours : http://www.ift.ulaval.ca/~marchand/ift21133

Cheminement d’apprentissage

Le présent guide pédagogique constitue un guide de travail hebdomadaire. Vous y


trouverez, regroupées par unités, les activités que vous devez réaliser chaque semaine.
Chaque module correspond à l’une des 13 semaines du trimestre. Bien que vous deviez
déterminer vous-même la façon de procéder qui vous convient le mieux, nous vous
suggérons le cheminement d’apprentissage suivant :

Chaque semaine:
• Lire la section du présent guide concernant l’unité de la semaine.
• Lire les sections du manuel obligatoire qu’il indique.
• Le volume de Deitel & Deitel présente à la fin de chaque chapitre une série de questions
de révision. Essayez d’y répondre. Les réponses sont données à la fin des questions.
• Nous suggérons pour chaque unité certains des exercices de programmation présentés à
la fin de chaque chapitre du livre. Essayez de les effectuer. Les solutions sont
disponibles sur la page Web du cours.

Plusieurs fois par semaine, consultez la page Web du cours à l’adresse :


http://www.ift.ulaval.ca/~marchand/ift21133
Ce site contient :
• des précisions sur la matière des différentes unités ;
• une foire aux questions où nous répondons aux questions d’intérêt général posées par
les étudiants ;

5
• au besoin, des précisions et des clarifications sur les énoncés des travaux pratiques ;
• les solutionnaires des exercices, des travaux pratiques et des examens ;
• les résultats des examens ;
• la procédure à suivre en cas de situations exceptionnelles (telles une grève des postes,
une tempête de neige, etc.) qui nuiraient aux activités du cours.

Activités d’évaluation

Dans ce cours, l’évaluation de l’apprentissage se fait au moyen d'un examen sous


surveillance et de trois travaux pratiques.
• L'examen compte pour 70% de la note finale et porte sur l'ensemble de la matière.
• Les travaux pratiques comptent pour 30% (10% chacun). Les énoncés de ces travaux
seront présentés à la page Web du cours).

• La répartition des cotes en fonction de la note finale obtenue est la suivante :

A+ [95-100] A [90-95[ A- [85-90[ Réussite


B+ [80-85[ B [76-80[ B- [72-76[ Réussite
C+ [67-72[ C [63-67[ C- [59-63[ Réussite
D+ [54-59[ D [50-54[ Réussite
E [0-50[ Échec
W Échec pour abandon

Examens:

70 % Examen : le samedi 28 avril 2001, de 13h30 à 16h30.

L'examen est à livre ouvert, i.e. toute documentation est permise.

Il est important de noter que vous devrez passer votre examen en salle, sous
surveillance, dans une ville désignée. Québec et Montréal font partie de ces villes, mais
d’autres se rajouteront en cours de session lorsque nous connaîtrons la provenance exacte
de notre clientèle. Nous mettrons sur le site Web du cours la liste complète de ces villes
aussitôt qu’elle sera connue. Prévoyez donc un déplacement d’au plus 150 km (pour
l’aller seulement) pour vous rendre à l’une ou l’autre de ces villes, et ce, deux fois durant
le trimestre.

Pour les personnes dont le lieu de résidence sera plus loin que 150 km de toutes les villes
désignées, vous devrez vous identifier le plus tôt possible (durant la semaine suivant la
publication de la liste des villes désignées) auprès du Bureau de l’Enseignement à
Distance. Dans ce cas, vous aurez à trouver un répondant qui vous fera passer les
examens dans les mêmes conditions que celles prévalant dans les salles de classe. C’est-
à-dire que vos examens devront être passés exactement dans les mêmes plages horaires

6
que ceux passés en classe, et qu’ils devront être sous surveillance d’un répondant qui
agira à titre de surveillant et à qui nous aurons préalablement envoyé le questionnaire
d’examen. Il sera chargé d’appliquer la même procédure que celle suivie en classe, et
devra nous retourner les cahiers-réponse le plus rapidement possible.

Ce répondant doit toutefois être soumis à une procédure d’accréditation, c’est-à-dire que
le Bureau de l’Enseignement à Distance et le professeur responsable du cours doivent
approuver votre choix. Les critères d’accréditation vous seront transmis sur demande. Si
tel est votre cas, nous vous conseillons de procéder à la recherche d’un répondant le plus
tôt possible afin de vous éviter de mauvaises surprises. Vous devez donc contacter le
Bureau de l’Enseignement à Distance, au (418) 656-3202 ou au 1-800-561-0478 (poste
3202), à ce sujet, le plus rapidement possible dès que vous savez que vous aurez besoin
d’un répondant. Il serait malheureux que vous ayez cherché et trouvé une personne qui
s’avérerait par la suite ne par répondre aux critères d’accréditation.

Accès Internet

Si vous avez déjà accès à l’Internet par l’entremise d’un fournisseur commercial
d’accès, ce qui suit ne vous concerne pas. Vous avez déjà les outils nécessaires pour
envoyer et recevoir du courrier électronique et consulter notre site Web.

Si vous n’avez pas accès à l’Internet, vous pouvez :

1. accéder à Internet depuis une bibliothèque municipale.

En effet, la plupart des bibliothèques municipales offrent l’accès gratuit à l’Internet.


Vous pourrez donc y consulter notre site Web. Toutefois, il n’est pas garanti que l’on
vous permette d’envoyer et surtout de recevoir du courrier électronique (utile pour
poser des questions au professeur et recevoir une réponse). À vous de le vérifier.

2. accéder à Internet depuis un café Internet :

Pour un coût minime, vous pourrez accéder à notre site Web et envoyer et recevoir du
courrier électronique. Cette solution vous évite d’avoir à comprendre tout ce qu’il
faut savoir pour se connecter à un serveur d’accès Internet : logiciels requis,
configuration de ces logiciels, protocoles de communication, etc.

3. vous abonner à un service commercial d’accès Internet :

Si vous désirez vous connecter à Internet à partir de chez vous, cette solution est la
moins problématique car vous obtiendrez tout le support technique et logistique pour
adapter votre poste de travail à cette nouvelle fonctionnalité. Votre fournisseur vous
guidera dans le choix des équipements matériels et logiciels nécessaire. Toutefois,
cette solution implique un certain coût.

7
4. accéder à Internet depuis l’un de nos laboratoires sur le campus de l’Université
Laval :

Les micro-ordinateurs des laboratoires du Département d’informatique sont équipés


des outils nécessaires pour envoyer et recevoir du courrier électronique ainsi que des
navigateurs Internet. Pour utiliser l’un de ces micro-ordinateurs, vous devez entrer un
numéro d’utilisateur et un mot de passe qui vous seront assignés automatiquement au
laboratoire. SVP apportez votre carte d’étudiant et votre NIP lorsque vous vous
présenterez à l’un de nos laboratoires et suivez les consignes de branchement qui sont
affichées sur les babillards. Cette solution est simple et sans coût, mais implique un
déplacement. Nos laboratoires sont ouverts le jour, le soir et les fins de semaine. Vous
pourrez consulter l’horaire d’ouverture de nos laboratoires sur le site Web du
département (http://www.ift.ulaval.ca).

5. accéder à Internet depuis votre propre ordinateur :

Tel que mentionné plus haut, le Département d’informatique assigne un compte


Internet à tous les étudiants inscrits à un cours d’informatique. Ce compte vous
permet non seulement d’accéder à Internet pour consulter les sites Web, mais aussi
d’envoyer et de recevoir du courrier électronique. Il s’agit pour vous de vous relier à
l’un de nos serveurs à partir de votre poste de travail personnel (à la maison, au
bureau ou chez un ami)1. Une fois cette connexion établie, vous aurez accès à toutes
les ressources d’Internet. Le guide joint, intitulé Accès Internet à L’Université Laval :
Se brancher et comprendre, vous permettra d’évaluer vos besoins matériels et
logiciels pour réaliser cette connexion.

En résumé, vous rejoignez nos serveurs par ligne téléphonique. Votre ordinateur
devra donc être doté d’un modem et d’un logiciel de communication. Le logiciel de
communication en question doit être de type PPP (Point-to-Point Protocol), pour vous
permettre de voir les informations des sites Web en format graphique, ce qui est
indispensable pour le cours de Java. Pour vous faciliter la tâche lors de la
configuration de ce type de logiciel, nous avons joint un fascicule sur la connexion en
mode PPP pour Windows 95.

De plus, votre ordinateur devra être doté d’un logiciel pour envoyer et recevoir du
courrier électronique ainsi que d’un navigateur Internet tel que Netscape ou Internet-
Explorer (ces deux logiciels disposent d’outils pour le courrier électronique ; vous
pouvez également utiliser un logiciel spécialisé tel qu’Eudora). Tous ces logiciels
sont offerts gratuitement aux étudiants de l’Université Laval. Vous n’avez qu’à vous
présenter au Technosit de l’Université Laval pour les obtenir, ou, si vous avez déjà
accès à Internet, vous pouvez les télécharger, i.e. aller les chercher sur le site Web du

1 Attention aux frais d’interurbain. Si un appel téléphonique à l’Université Laval entraîne des coûts d’appel
interurbain, vous auriez avantage à envisager une autre des solutions proposées.

8
Technosit2 à la rubrique Téléchargement. Il existe une trousse Internet pour les
ordinateurs MacIntosh et PC-compatibles, disponible au Technosit et sur son site
Web, qui est très simple à installer et à utiliser.

Finalement, veuillez lire la section suivante sur les codes d’accès. Cette section vous
explique quelles sont les autorisations à obtenir pour vous relier par ligne
téléphonique à l’un de nos serveurs et comment obtenir ces autorisations. Ces
contrôles sont nécessaires afin de nous assurer que nous n’offrons des services
d’accès Internet gratuits qu’à nos étudiants et que ceux-ci jouissent de communica-
tions protégées du regard autrui. Vous serez les seuls à connaître vos mots de passe,
puisque nous vous les ferons choisir (pour la plupart) ; vous aurez donc la responsa-
bilité de ne pas les oublier et de les garder secrets.

Codes d’accès

Pour accéder au réseau informatique de l’Université Laval, vous aurez besoin d’un
numéro d’utilisateur et d’un mot de passe. Ceci vous donnera accès à un serveur
universitaire à partir duquel vous pourrez naviguer sur le Web. Pour l’envoi et surtout
pour la réception de courrier électronique vous aurez besoin d’une boîte aux lettres
destinée à recevoir votre courrier électronique. À cette fin, le Département
d’informatique créera pour vous un compte Internet à partir duquel vous pourrez
accéder à l’Internet et envoyer ou recevoir du courrier électronique. Ce compte sera
créé sur l’un des serveurs départementaux. Pour y accéder, vous aurez besoin d’un
autre numéro d’utilisateur et d’un autre mot de passe que ceux que vous utilisez pour
accéder au serveur universitaire.

Pour l’accès au serveur universitaire, votre numéro d’usager sera votre code à barres.
Ce dernier se trouve à l’endos de votre carte d’étudiant. Toutefois, vous devrez
activer votre code à barres, i.e., vous créer un mot de passe associé. Pour ce, vous
pouvez soit vous déplacer au Technosit et bénéficier de l’aide des préposés, soit vous
connecter au serveur universitaire appelé AGORA (adresse : agora.ulaval.ca) pour
demander que soit activé votre code à barres. Vous pouvez utiliser Telnet (un logiciel
de la trousse Internet mentionnée plus haut) pour vous relier. Aux questions login :
(ou username :) et password : , répondez public. On vous proposera ensuite un menu
à partir duquel vous n’aurez qu’à choisir ce qui vous convient. Pour l’activation de
votre code à barres, on vous demandera d’entrer un mot de passe de votre cru.
Choisissez un mot de passe que vous n’oublierez pas et inscrivez-le en lieu sûr.
Évitez de choisir un mot de passe qui soit trop facile à deviner pour quelqu’un qui
vous connaît.

2 L’adresse Internet du SIT est http://www.sit.ulaval.ca

9
Votre code à barres sera activé dans les deux prochains jours ouvrables. Après ce
délai, vous pourrez accéder au réseau informatique de l’Université Laval aux numéros
de téléphone mentionnés dans le guide ci-joint.

Une fois cette connexion établie, vous devrez recommencer la procédure sur l’un de
nos serveurs départementaux appelé BRITTEN (adresse : britten.ift.ulaval.ca).
Encore une fois, vous devrez utiliser Telnet pour vous y relier. À la première question
login :, répondez distrib. Répondez ensuite aux questions. Encore une fois, on vous
demandera de choisir un mot de passe. Votre compte Internet sur ce serveur sera créé
dans les deux prochains jours ouvrables. Après ce délai, vous pourrez configurer
correctement votre logiciel de courrier électronique et votre navigateur Internet.
Toutefois, nous vous demandons d’attendre après la troisième semaine de cours avant
de vous relier à BRITTEN, afin que nous ayons pu obtenir les listes d’inscription de
la part du registraire et vérifier que vous êtes bien inscrite avant de créer votre compte
Internet.

Pour l’activation de votre code à barres et la création de votre compte Internet sur le
serveur départemental, vous aurez à répondre à certaines questions dont les réponses
se trouvent sur votre carte d’étudiant (e.g. numéro de dossier, nom et prénom, date de
naissance, etc). Vous aurez aussi besoin de votre NIP, utile pour gérer votre dossier
étudiant durant toute la durée de vos études à l’Université Laval. Pour obtenir ce NIP,
vous pouvez vous déplacer au secrétariat du département qui gère le programme dans
lequel vous êtes inscrit. Par exemple, les étudiants inscrits au certificat en
informatique doivent se déplacer au secrétariat du Département d’informatique durant
les heures d’ouverture, tandis que les étudiants inscrits aux études libres doivent
contacter le bureau des études libres, etc.

Si vous êtes dans l’impossibilité de vous déplacer à l’Université dans les heures
d’ouverture du département concerné, soit à cause d’un conflit d’horaire, soit à cause
de la distance, vous pouvez contacter le secrétariat du département en question par
téléphone. Dans ce cas, ayez votre carte d’étudiant à portée de la main, car des
vérifications seront nécessaires à l’émission de votre NIP.

Voici les numéros de téléphone à utiliser. Pour les étudiants inscrits :


• au certificat ou au baccalauréat en informatique, contactez Madame Lynda Goulet
au 656-2131, poste 3748 ;
• aux études libres, contactez le Bureau de l’enseignement à distance, au 656-3202,
ou sans frais au 1-80-561-0478, poste 3202 ;
• à tout autre programme, contactez votre direction de programme.

10
Outils de programmation

Pour la réalisation des exercices et des travaux pratiques, vous devez vous procurer le
Java Development Kit (JDK) 1.2.1 de Sun Microsystems sur le CD fourni avec le
livre. Vous pouvez vous procurer la version la plus récente (pour l'instant on en est à
la version 1.3) à l'adresse :

http://www.java.sun.com/j2se/1.3/

Ce fichier a une taille de 16 Mo avant décompaction. Suivez méticuleusement les


instructions qui l’accompagnent pour l’installation dans votre ordinateur, en
particulier en ce qui a trait à path et à classpath. La documentation est également
disponible sur le même site (un autre 16 Mo).

Pour éditer vos sources, vous pouvez utiliser Textpad, disponible gratuitement à
l'adresse :

http://www.textpad.com

Il existe des compilateurs plus conviviaux. En particulier, JBuilder 3 de Inprise


(anciennement Borland) et NetBeans Developer 2.2.1 de Sun Microsystems (qui
s'appelle maintenant Forte for Jave1.0) sont inclus sur le CD fourni avec le livre. Il en
existe de nombreux autres, tels que Visual Café for Java de Symantec, CodeWarrior
de Metrowerks, Visual Age d’IBM, etc. Ces environnements de programmation
disposent d'un IDE (Integrated Development Environment) comprenant un éditeur et
un débogueur intégrés et des outils visuels de conception d'interface utilisateur
graphique. Vous en trouverez une description à la page Outils du site Web du cours.

Vous pouvez les utiliser si vous le voulez. Quel que soit celui que vous utiliserez, vos
travaux doivent être remis sous forme de fichiers texte compilables avec javac ou
appletviewer suivant le cas, qui font partie du JDK mentionné ci-haut.

11
Calendrier Été 2001
Semaine Date Travail

1 30 avril Unité 1
2 7 mai Unité 2
3 14 mai Unité 3
4 21 mai Unité 4
25 mai Remise du travail #1
5 28 mai Unité 5
6 4 juin Unité 6
7 11 juin Unité 7
8 18 juin Unité 8
22 juin Remise du travail #2
9 25 juin Unité 9
10 2 juillet Unité 10
11 9 juillet Unité 11
14 juillet Remise du travail #3
14 juillet Examen

12
Partie 2
Étude des unités
14
Introduction

Pourquoi Java???
On aurait pu croire au début que Java ne servait qu’à créer des animations sur les pages
WWW. Bien au contraire, comme nous allons voir, c’est un langage complet et puissant.

Le vogue Java est plus que le résultat d’une vaste campagne publicitaire. C’est un
phénomène sans précédent. C’est le mouvement de toute une industrie à l’échelle
mondiale. Le langage Java est devenu incontournable et de plus en plus de produits
commerciaux sont conçus en Java (par exemple les suites bureautiques E-Suite de Lotus
et Anyware d’Applix ; pour de nombreux autres exemples voir http://java.
sun.com/nav/used/index.html). La demande pour des informaticiens connaissant Java est
donc en forte croissance.

Contrairement à C, Java est un langage ayant une spécification publiée (The Java
Language Specification, version 1.0, par James Gosling, Bill Joy, and Guy Steele.
Addison-Wesley, 1997, ISBN 0-201-63451-1). En conséquence, Java est un langage
propre, dans lequel tout est précisément défini. Il n’a pas comme le C de structures
indéfinies dont l’exécution dépend du compilateur utilisé. Il n’a pas non plus de fonctions
avec un nombre indéterminé de paramètres.

C’est aussi un langage fortement typé, ce qui permet au compilateur de déceler beaucoup
d’erreurs de programmation.

Contrairement à C, Java a été conçu, dès le départ, comme un langage orienté objet. La
programmation orientée objet n’y a pas été ajoutée après coup (comme avec C++) et est
parfaitement intégrée dans le langage.

Contrairement à C ou C++, Java peut être interprété (exécution de byte-codes par une
machine virtuelle). Il peut aussi être compilé en code natif, au besoin.

Java génère du code mobile, qu’on peut télécharger (par exemple par Internet avec un
navigateur) pour exécution locale.

C’est un langage qui a été conçu pour être portable, et qui devrait fonctionner de façon
identique sur toutes les plates-formes informatiques.

C’est un langage distribué, dans le sens qu’il comporte un support de haut niveau pour les
réseaux (intranets aussi bien qu’Internet). Les classes du package java.net font en sorte
qu’il est presque aussi facile de lire un fichier ou une ressource à distance que de lire un
fichier local. On peut aussi invoquer les méthodes d’objets à distance comme si c’étaient

15
des objets locaux grâce au mécanisme rmi. Il procure aussi un support de bas niveau aux
réseaux au moyen des datagrams et des connections à base de streams par l’intermédiaire
de sockets.

C’est un langage simple qui, s’il ressemble superficiellement au C par sa syntaxe, est
beaucoup plus facile à apprendre. Il n’y a pas de préprocesseur. Il n’y a pas de fichiers
d’en-tête (header files ou fichiers .h). Il n’y a pas de pointeurs, source de nombreuses
difficultés et erreurs. La gestion de mémoire est automatique (Garbage Collection ou
récupérateur de mémoire). Il n’y a pas non plus d’héritage multiple.

Java est robuste, ce qui convient bien dans une optique de génie logiciel. Une façon
d’arriver à cette robustesse, en plus des propriétés mentionnées plus haut, est le
mécanisme d’exception, emprunté à Modula III, qui permet la détection, le traitement et
la récupération des erreurs (par exemple les débordements d’indices, les exceptions de
virgule flottante, les fichiers introuvables, etc.).

C’est un langage concurrent (multi-thread), permettant la programmation concurrente


avec des mécanismes très simples. Ce qui s’avère souvent très compliqué en C++ est
d’une simplicité étonnante en Java.

Contrairement à bien des préjugés, c’est un langage performant. Sa performance rivale


celle de C et de C++ lorsque compilé en code natif ou lorsqu’il est interprété et qu’on
utilise un compilateur JIT. Sun prétend même que sa technologie Hotspot donne des
performances meilleures que celle du code compilé!

Un nombre impressionnant de librairies (API) sont maintenant disponibles couvrant


toutes les sphères de l’informatique. Certaines, telles que JDBC, permettent l’inter-
rogation de bases de données relationnelles à distance, quel que soit le SGBD utilisé. Il
suffit que le serveur possède le pilote Java pour le SGBD qu’il utilise. D’autres gèrent les
graphiques 2D et 3D, la communication, la sécurité, etc. Java supporte aussi les architec-
tures logicielles à base de composantes grâce à un IDL compatible avec CORBA et au
mécanisme de JavaBeans.

Nous concluons en répétant que la connaissance de Java vous donnera un avantage


concurrentiel sur le marché du travail, car de plus en plus d’industries de haute
technologie se tournent vers ce langage.

16
17
Unité 1. Concepts de base
Cette unité présente les concepts nécessaires au développement de programmes
élémentaires en Java. Elle décrit la relation entre les divers types de langages de
programmation ainsi que les outils logiciels utilisés dans le processus de développement.
De plus, elle identifie quelques éléments clés d’un programme en Java et présente les
idées qui sous-tendent la programmation orientée objet en général. Finalement, elle
démontre la relation entre le langage Java et le World-Wide Web, et présente les
applications Java ainsi que les applets Java.

Objectifs de l’unité
• Se rafraîchir la mémoire au sujet des différents langages de programmation et pouvoir
situer Java dans l'ensemble
• Comprendre l'environnement de développement Java et pouvoir compiler et faire
exécuter une application Java et une applet Java.
• Pouvoir écrire des applications Java simples.
• Savoir utiliser les énoncés d'entrée/sortie.
• Se familiariser avec les types de données simples.
• Savoir utiliser les opérateurs arithmétiques sur des nombres entiers et sur des nombres
de virgule flottante.
• Savoir écrire des énoncés conditionnels.
• Savoir utiliser les opérateurs relationnels.
• Comprendre la terminologie de la programmation orientée objet.
• Comprendre la différence entre une application et une applet.
• Pouvoir écrire des applets Java simples.
• Savoir écrire des fichiers html simples pour charger une applet dans l'appletviewer ou
dans un navigateur Internet.
• Comprendre la différence entre une variable et une référence.

Étude

En guise d'introduction, vous devez lire le chapitre 1 du volume de Deitel & Deitel,
surtout les sections 1.1, 1.4 à 1.9 et 1.12 à 1.14. Vous devez ensuite lire les chapitres 2 et
3.

Essayez de compiler et d’exécuter les exemples du volume ainsi que quelques-uns des
exemples qui sont fournis avec le JDK. Ceci vous permettra de vérifier que votre
installation a été effectuée correctement.

Compilation d’une application avec JDK

Supposons que vous désirez exécuter l’exemple Bienvenue4 de la page 44 du livre. Vous
entrez le programme dans un éditeur comme TextPad et vous l’enregistrez en format
texte sous le nom Bienvenue4.java. Pour compiler cette application avec TextPad,

18
choisissez Compile Java dans le menu Tools (on peut attribuer un raccourci à cette
commande, par exemple, CTRL + 1, dans le menu Configure, item Preferences, option
Keyboard). Une nouvelle fenêtre apparaît pour vous indiquer le résultat de l'opération.
Pour exécuter l'application avec TextPad, choisissez Run Java Application dans le
menu Tools. Vous pouvez configurer les commandes du logiciel dans le menu
Configure, item Preferences, option Tools).

Pour compiler une application avec le JDK, vous pouvez aussi utiliser la fenêtre MS-
DOS PROMPT de Windows 95/98 ou la fenêtre INVITE DE COMMANDE
(COMMAND PROMPT) de Windows NT. Vous-vous rendez ensuite au répertoire où se
trouve votre code source Bienvenue4.java au moyen de la commande cd et vous tapez :

>javac Bienvenue4.java

S’il n’y a pas d’erreur de compilation, aucun message n’apparaît. Vous observerez qu'un
fichier Bienvenue4.class a été créé dans votre répertoire. Ensuite, pour exécuter votre
code, vous tapez :

>java Bienvenue4

Remarquez que pour compiler, il faut écrire l'extension .java, mais que pour exécuter, il
ne faut pas écrire l'extension .class. Dans le cas présent, votre application sera exécutée
par la machine virtuelle Java (JVM) de Sun. Avec le JDK 1.3, il s'agit d'un compilateur
JIT (Just In Time Compiler) du nom de HotSpot, qui compile les byte-codes avant de
lancer l’exécution. Il y a un délai initial, mais une fois lancée, l’application roule
beaucoup plus rapidement, c’est-à-dire à des vitesses comparables à celles de C ou de
C++.

Il est également possible de compiler une application Java en code natif, c'est-à-dire créer
un fichier .exe (avec Visual Café, par exemple). On gagne en performance puisqu’on n’a
plus le délai initial de compilation comme avec un JIT. Toutefois, le code généré n’est
pas portable sur d’autres types de machines.

Compilation d’une applet

Supposons maintenant que vous désirez exécuter l’applet example1 dans les démos
fournis avec le JDK. Rendez vous d'abord dans le répertoire C:\jdk1.3\demo\
applets\TicTacToe. Il devrait normalement être déjà compilé, i.e. vous verrez un
fichier example1.html, un fichier TicTacToe.class et un fichier TicTacToe.java.
Sinon, vous le compilez en ouvrant TicTacToe.java et en choisissant Compile Java
dans le menu Tools de TextPad, ou en écrivant javac TicTacToe.java dans la fenêtre
DOS.

Ensuite, une première façon de l'exécuter consiste à ouvrir le fichier example1.html


avec TextPad et à utiliser la commande Run Java Applet dans le menu Tools.

Une deuxième façon consiste à utiliser la commande :

19
>appletviewer example1.html

La troisième consiste à ouvrir le fichier example1.html avec un navigateur supportant


Java. Les navigateurs les plus répandus sont Netscape Navigator et Microsoft Internet
Explorer. Vous pouvez aussi utiliser HotJava de Sun, un navigateur entièrement écrit en
Java. Les trois sont disponibles gratuitement sur le Web. Les trois possèdent un JIT et
peuvent exécuter vos applets de façon performante.

Toutefois, Java évolue rapidement et les navigateurs ne suivent pas toujours. Au moment
où ces lignes sont écrites, on en est à la version 1.3. Or les machines virtuelles des
navigateurs en sont encore à la version 1.1.8! Si vous utilisez dans vos applets des classes
plus récentes, telles que celles de JFC, vous ne pourrez pas les exécuter avec un
navigateur, c’est-à-dire vous ne pourrez pas les mettre sur une page Web. À moins
d’utiliser le Java Plug-in de Sun, qui force le navigateur à utiliser le machine virtuelle de
votre choix (à condition que le client l'aie dans son ordinateur).

Ce plug-in et sa documentation sont disponibles à l’adresse :

http://java.sun.com/products/plugin

Une fois le plug-in installé, il faut modifier le fichier html de vos applets. Il existe à cette
fin un utilitaire, permettant d’effectuer automatiquement cette conversion, qui s’appelle
HTMLConverter. Cet utilitaire est disponible à la même adresse.

Vous pouvez essayer les démos présentés à la même adresse et constater par vous-mêmes
qu’on peut réaliser avec ce plug-in des applets utilisant les classes de la plus récente
version de Java.

Pour conclure, une applet n'a généralement pas de fonction main, de sorte qu'on doit
absolument l'exécuter à partir d'un navigateur ou avec la commande appletviewer.
Certaines applets peuvent toutefois avoir une fonction main, auquel cas on peut
également les exécuter avec la commande java.

Plusieurs notions de cette unité vous sont déjà certainement familières. Remarquez
toutefois la différence entre la taille d’un int et celle d’un long en Java par rapport aux
tailles correspondantes en C/C++. Remarquez aussi l’emploi du jeu de caractères
Unicode, dont l’ASCII est un sous-ensemble. Remarquez aussi l'utilisation de l'énoncé
import qui remplace le #include de C.

Remarquez l'emploi de la méthode paint de la classe Graphics à la page 86. Nous


n'avons pas défini d'objet g de classe Graphics. C'est un cas de redéfinition de méthode
(method overriding) que nous verrons plus en détail au chapitre 9.

Vous remarquerez aussi, aux pages 50 et 99, des énoncés tels que :

number1 = Integer.parseInt(firstNumber);
number1 = Double.parseDouble(firstNumber);

20
On utilise les méthodes dites statiques parseInt et parseDouble des classes Integer et
Double respectivement. Pour de telles méthodes, il n'est pas nécessaire d'avoir créé des
objets de classe Integer ou Double. Ces deux classes seront décrites à la section 9.22, à
la page 443. La méthode main d'une application Java est également une méthode statique.
D'autres méthodes statique sont JOptionPane.showMessageDialog à la page 45 et
JOptionPane.showInputDialog à la page 47. Les méthodes statiques sont expliquées au
chapitre 8 du livre.

Finalement, comme travail pour l'unité 1, nous vous recommandons d’effectuer les
exercices présentés à la fin des chapitres 1, 2 et 3 du livre de Deitel & Deitel, en
particulier les exercices de programmation 2.27, 2.32, 3.8, 3.14, 3.15 (lire attentivement
la page 88 et l'exemple de la p. 94) et 3.21. Vous trouverez les solutions de ces exercices
sur le site Web du cours.

21
Unité 2. Structures de contrôle
Comme tous les langages de programmation, Java possède des structures spécifiques
nous permettant d'implanter des algorithmes de façon structurée. Ces structures sont
identiques à celles de C et de C++. On utilise également divers opérateurs pour contrôler
le fonctionnement de ces structures. Ils sont, pour la plupart, identiques à ceux de C et
C++.

Objectifs de l’unité

• Savoir utiliser les structures if et if / else pour choisir entre des actions.
• Savoir utiliser la structure répétitive while pour exécuter des énoncés à répétition.
• Savoir utiliser les opérateurs d'incrémentation et de décrémentation.
• Savoir utiliser les structures for et do / while pour exécuter des énoncés à répétition.
• Savoir utiliser la sélection multiple au moyen de la structure de sélection switch.
• Savoir utiliser les énoncés break et continue.
• Savoir utiliser les opérateurs logiques.
• Savoir créer une instance d'un objet d'une classe existante et utiliser ses méthodes.

Étude

Lisez les chapitre 4 et 5 du livre de Deitel & Deitel. Ici encore, plusieurs notions vous
sont déjà certainement familières. Prenez note des mots réservés de Java à la page 116.
Remarquez certaines différences avec le C : l'existence d'un type booléen, la possibilité
de déclarer et d'initialiser des variables simultanément et n'importe où (par exemple : for
(int i = 0; i < 10; i++)), l'existence de l'opérateur >>>, le fait que les caractères
ont 16 bits (Unicode) et non 8, et l'existence des énoncés break et continue avec
étiquette.

Remarquez aussi comment on crée et utilise l'objet deuxChiffres de classe


DecimalFormat à la page 132. Prenez note également des types de base de Java,
présentés à la page 144.

Portez attention à l'introduction des barres de défilement (scrollbars) à la page 185.

Effectuez les exercices à la fin des chapitres 4 et 5, en particulier les exercices de


programmation 4.9, 4.11,.4.32b, 5.9 et 5.12.
.

22
Unité 3. Méthodes, tableaux et la classe
Vector
Dans la présente unité, nous apprenons comment définir des programmes de façon
modulaire En Java, ces modules sont appelés méthodes et classes. Un programme Java
est écrit en combinant de nouvelles méthodes et classes avec les méthodes et classes
existantes disponibles dans l'API de Java ou dans d'autres librairies. Cette unité aborde
particulièrement les méthodes. On abordera les classes à l'unité 4. Dans un deuxième
temps, nous étudions comment Java manipule les tableaux.

Objectifs de l’unité

• Comprendre les méthodes mathématiques courantes disponibles dans la librairies Math


de Java
• Savoir créer de nouvelles méthodes.
• Comprendre les mécanismes de passage d'information entre les méthodes.
• Avoir une vue d'ensemble des principales librairies ou API (Application Programming
Interface) disponibles avec Java.
• Comprendre la génération de nombres aléatoires au moyen de la méthode random de la
classe Math.
• S'initier aux contenants (Container) et aux agencements (Layout) ainsi qu'aux boutons
et aux écouteurs d'événements (Listeners).
• Se familiariser avec la portée ou espace de validité (scope) des variables Java.
• Comprendre ce qu'est la surcharge (overloading) d'une méthode.
• Savoir déclarer un tableau, initialiser un tableau et référer aux éléments individuels d'un
tableau.
• Savoir passer un tableau comme paramètre à une méthode.
• Se familiariser avec la classe Vector, qui gère des tableaux d'objets.

Étude
Lisez les chapitres 6 et 7 ainsi que la section 23.2 du livre de Deitel & Deitel. Observez
l'introduction du mot clé implements à la page 223, qui indique que l'applet implémente
une interface de type ActionListener. Ne confondez pas interface avec interface
utilisateur graphique. Nous étudierons les interfaces plus en détail à l'unité 5. On touche
ici pour la première fois au traitement d'événements. Notez comment les clics de souris
sur le bouton roll sont affectés à la fonction actionPerformed(ActionEvent e) au
moyen de l'instruction jet.addActionListener. Ces notions seront approfondies à
l'unité 7. Retenez bien la notion de surcharge (overloading) de méthode et la notion de
signature de méthode aux pages 243 et 244.

Faites attention aux déclarations de tableaux et au passage de tableaux comme


paramètres. Il y a des différences par rapport à C. Par exemple, en Java il est possible de

23
passer à une fonction un tableau à deux dimensions de taille quelconque comme dans
maFonction(int [][] M); ce n'est pas possible en C où il faut spécifier le nombre de
colonnes. Attention aussi aux tableaux d'objets, page 272, et aux tableaux
bidimensionnels irréguliers, page 295.

Finalement, la classe Vector présentée à la section 23.2 est une classe permettant de
gérer des tableaux d'objets que nous utilisons souvent dans les travaux pratiques.

Effectuez les exercices à la fin de ces chapitres, en particulier les exercices de


programmation 6.23, 6.28, 7.18, 7.27, et 10.8.

24
Unité 4. La programmation à base d'objets
Dans les chapitres précédents, nous avons vu comment les concepts qui nous étaient
familiers en C sont implantés en Java. Nous avons aussi abordé les concepts de base et la
terminologie de l'orientation objet. Dans la présente unité, nous approfondissons
davantage l'orientation objet, qui est vraiment à la base de Java, par opposition à
l'orientation action des langages procéduraux comme le C.

Objectifs de l’unité

• Comprendre l'encapsulation et le masquage des données (data hiding).


• Comprendre les notions d'abstraction de données et de types de données abstraits.
• Pouvoir créer des types de données abstraits, en particulier des classes.
• Pouvoir créer, utiliser et détruire des objets.
• Pouvoir contrôler l'accès aux variables d'instance et aux méthodes d'un objet.
• Comprendre l'utilisation de la référence this.
• Comprendre les variables de classe et les méthodes de classe.

Étude

Lisez le chapitre 8 du livre de Deitel & Deitel. Notez bien les propriétés des variables et
des méthodes static, des variables de classe et des méthodes de classe, des variables et
des méthodes final. Observez comment l'accès aux variables d'une classe peut être
contrôlé au moyen des déclarations public et private. À la prochaine unité, nous
rencontrerons la déclaration supplémentaire protected.

Par ailleurs, un avantage important de Java par rapport à d'autres langages orientés objet
est la récupération de mémoire (Garbage Collection, traduction littérale : collecte des
ordures) qui libère automatiquement la mémoire occupée par un objet quand il n'est plus
utilisé. On n'a pas besoin d'utiliser une fonction free() comme C ou C++, qui est une
source de fuites de mémoire si on ne libère pas tous les objets. Attention à la création de
packages à la page 336 et surtout à la compilation de tels packages à la page 339.

Retenez la notion de composition à la section 8.11, page 355.

Faites les exercices à la fin du chapitre, en particulier les exercices de programmation 8.3,
8.5, 8.8 et 8.19.

25
Unité 5. La programmation orientée objet
Cette unité approfondit les notions de programmation orientée objet et souligne ses
technologies clés : l'héritage et le polymorphisme. L'héritage permet la réutilisation du
code par la création de nouvelles classes, basées sur des classes existantes, qui
bénéficient de leurs attributs et de leur comportement. Ces nouvelles classes peuvent être
bonifiées avec des capacités supplémentaires. Le polymorphisme permet à une méthode
de produire des effets différents selon le type d'objet sur lequel elle agit.

Objectifs de l’unité

• Comprendre l'héritage et la réutilisabilité du logiciel.


• Comprendre ce qu'est une superclasse et une sous-classe.
• Comprendre comment le polymorphisme rend les systèmes informatiques extensibles et
maintenables.
• Comprendre la distinction entre une classe abstraite et une classe concrète.
• Pouvoir créer des classes abstraites et des interfaces.

Étude

Lisez le chapitre 9 de Deitel & Deitel. Notez les propriétés des variables final et des
méthodes final, ainsi que leur lien avec les attributs static et private. Notez
l'introduction du mot clé protected. Retenez le rôle de l'expression super() et de la
méthode toString() disponible pour tout objet (dérivé de la classe Object).
Observez aussi comment l'opérateur instanceof, à la page 396 permet de déterminer la
classe à laquelle appartient un objet.

On revient à la distinction entre héritage et composition à la section 9.8, page 402.

Portez une attention particulière au polymorphisme, à la page 409, et aux exemples


présentés à la section 9.15. Distinguez bien la différence entre une classa abstraite et une
interface. Faites attention aux classes internes et aux classes anonymes, décrites à partir
de la page 432.

Faites les exercices à la fin du chapitre 9, en particulier les exercices de programmation


9.11, 9.15, 9.26, 9.28 et 9.29.

26
Unité 6. Chaînes, caractères, graphiques et
Java 2D
Nous abordons deux sujets dans la présente unité. Le traitement des chaînes et des
caractères en Java et les graphiques avec Java 2D.
Les techniques décrites ici sont appropriées pour développer des éditeurs de texte, des
traitements de texte, des logiciels de mise en page, et tout autre type de logiciel de
traitement du texte.
D'autre part, les graphiques jouent un rôle important dans les ordinateurs modernes.
Comme le veut le dicton, « une image vaut mille mots ». On peut communiquer de
l’information plus aisément et plus rapidement au moyen de graphiques qu’avec du texte
et des nombres. Dans les unités précédentes, nous avons utilisé des méthodes graphiques
pour dessiner des lignes, des rectangles et des chaînes de caractères. Nous n’avons
toutefois qu’effleuré les capacités graphiques de Java. Dans la présente unité, nous
abordons l’utilisation de la couleur, le dessin de formes et la gestion des fontes (ou
polices de caractères).

Objectifs de l’unité

• Pouvoir créer et manipuler des objets de classe String.


• Pouvoir créer et manipuler des objets de classe StringBuffer.
• Pouvoir utiliser et manipuler des objets de classe Character.
• Pouvoir utiliser un objet StringTokenizer pour découper une chaîne en tokens.
• Comprendre les contextes graphiques et les objets graphiques.
• Décrire la classe Graphics et ses fonctions.
• Comprendre et pouvoir manipuler les couleurs.
• Comprendre et pouvoir manipuler les fontes (ou polices de caractères).
• Pouvoir utiliser les méthodes de la classe Graphics2D pour dessiner des lignes, des
rectangles, des ellipses, des arcs et des chemins quelconques.
• Pouvoir spécifier les caractéristiques Paint et Stroke des objets affichés avec
Graphics2D.

Étude

Lisez les chapitres 10 et 11 de Deitel & Deitel. Au chapitre 10, remarquez l'utilisation de
la méthode equals pour comparer deux chaînes. Vous pouvez laisser tomber la section
10.6 sur le hashCode. Notez bien les différences entre la classe String et la classe
StringBuffer.

Pour vous convaincre des possibilités étonnantes de Java2D, faites fonctionner


Java2DemoApplet dans les démos fournis avec le JDK 1.2 ou le JDK 1.3. Ensuite, pour
bien comprendre les exemples du chapitre 11, il faut voir l'image couleur produite, mais
les illustrations du livre sont monochromes. Nous vous recommandons donc de les

27
compiler et les exécuter. Vous trouverez les fichiers sources sur le CD fourni avec le
livre. Examinez bien l'exemple 11.22, pour voir comment on peut créer une texture avec
un objet TexturePaint opérant sur un objet BufferedImage (pages 543, 544). Les
objets de la classe GeneralPath (page 545) offrent aussi des possibilités intéressantes.

Faites les exercices à la fin des chapitres 10 et 11, en particulier les exercices de
programmation 10.7, 10.8, 10.12, 11. 9, 11.10, 11.11, et 11.18

28
Unité 7. L'interface utilisateur graphique 1
L'interface utilisateur graphique est un aspect important de tout logiciel moderne. En
dotant diverses applications d'un ensemble consistant et intuitif de composantes
d'interface utilisateur graphique, on permet à l'utilisateur de passer moins de temps à
essayer de retenir quelles commandes de clavier utiliser pour obtenir un résultat donné, et
à passer plus de temps à utiliser le programme de façon productive.

Objectifs de l’unité

• Comprendre les principes de conception d'interfaces utilisateur graphiques.


• Pouvoir construire des interfaces utilisateur graphiques.
• Comprendre les packages contenant les composants de l'interface utilisateur graphique
et les classes et interfaces de traitement des événements.
• Pouvoir utiliser et manipuler des boutons, des étiquettes, des listes, des champs de texte
et des Panels.
• Comprendre les événements de souris et de clavier.
• Comprendre et pouvoir utiliser les gestionnaires de tracé (layout managers).

Étude
Lisez le chapitre 12 de Deitel & Deitel. Pour avoir une idée des éléments d'interface
utilisateur graphique disponibles avec JFC (Java Foundation Classes) ou Swing, compilez
et faites exécuter le démo «SwingSet2» fourni avec le JDK 1.2.
Notez encore une fois, à la page 567, l'utilisation d'une classe interne pour traiter les
événements, i.e. pour implémenter les écouteurs (listeners). Il n'est pas indispensable de
procéder de cette façon. On pourrait également créer une classe publique.

Faites les exercices à la fin du chapitre 12, en particulier les exercices de programmation
12.8, 12.14, 12.19, et 12.27.

29
Unité 8. L'interface utilisateur graphique 2
Avec Java2 et Swing ou JFC, on passe de l'interface un peu primitive de java.awt à des
interfaces plus polies, comparables aux interfaces de logiciels commerciaux.

Objectifs de l’unité

• Pouvoir créer et manipuler des zones de texte, des curseurs coulissants, des menus, des
menus locaux (popup) et des fenêtres.
• Pouvoir créer des objets JPanel sur mesure.
• Pouvoir créer un programme qui peut fonctionner comme applet aussi bien que
comme application.
• Pouvoir changer l'aspect d'interface (look-and-feel) d'une interface utilisateur graphi-
que au moyen de PLAF.
• Pouvoir utiliser les gestionnaires de tracé avancés.

Étude

Lisez le chapitre 13 de Deitel & Deitel. Étudiez bien les sections 13.3 et 13.4 qui traitent
des JPanels sur mesure avec paintComponent(). Cette méthode vous assure un
affichage correct de vos composantes graphiques. Le sujet le plus difficile de ce chapitre
est sans doute le Gridbag Layout. Nous vous recommandons donc d'expérimenter, après
avoir lu les sections 13.15 et 13.16, avec les générateurs d'interfaces utilisateur
graphiques de JBuilder 3 ou de NetBeans (Forte for Java), qui se trouvent tous les deux
sur le CD fourni avec le livre.

Faites les exercices à la fin du chapitre 13, en particulier les exercices de programmation
13.7 et 13.9, ainsi que 13.13.

30
Unité 9. Exceptions et processus légers
Le mécanisme d’exception de Java est à la fois simple et très puissant. Il permet une
récupération élégante en cas d’erreur. Ces erreurs peuvent se produire spontanément lors
d'opérations d'entrée / sortie (clavier, disque). On peut également créer ses propres
exceptions pour détecter les débordements de capacité, les divisions par zéro, les indices
de tableau hors limite, etc.
D’autre part, Java permet la programmation concurrente au moyen des processus légers
ou threads.

Objectifs de l’unité

• Expliquer les concepts d’exception et de traitement d'erreur.


• Pouvoir utiliser les blocs try pour spécifier le code dans lequel une exception peut se
produire.
• Pouvoir lancer des exceptions avec l'instruction throw.
• Comprendre le processus de propagation des exceptions.
• Examiner l’utilisation de la clause finally dans un module de traitement d’exception.
• Pouvoir définir vos propres exceptions.
• Expliquer le concept de threads multiples.
• Créer des threads séparés et montrer comment ils interagissent.
• Démontrer les problèmes associés avec des données partagées.
• Expliquer comment synchroniser des threads.
• Explorer d’autres contrôles de threads.

Étude

Lisez les chapitres 14 et 15 du livre de Deitel & Deitel. L'exemple de traitement


d'exception de la Fig. 14.1 n'est pas très bon. En effet, la méthode quotient teste si le
dénominateur est nul et si c'est le cas, génère une exception. Ce test pourrait se trouver
directement dans la méthode actionPerformed, sans traitement d'exception. Ce serait
beaucoup plus simple. L'approche du livre est rendue nécessaire par le fait que la division
par zéro en virgule flottante ne génère pas d'exception en Java, car l'infini y est supporté.

Essayez plutôt de générer une exception arithmétique (ArithmeticException) en faisant


une division entière par zéro. Il suffit de modifier légèrement la méthode quotient pour
qu'elle retourne un int et génère une ArithmeticException plutôt que DivideByZero-
Exception. On attrape alors une véritable exception déclenchée par le processeur lui-
même.
Par contre, le traitement de NumberFormatException dans cet exemple est tout à fait
approprié. En effet, Integer.parseInt est susceptible de générer une telle exception et
doit absolument se trouver dans une clause try - catch, sinon le programme ne
compilera même pas. Nous aurons affaire à ce type d'exceptions à l'unité 10.

31
Le chapitre 15 est assez difficile parce que la programmation concurrente présente toutes
sortes de subtilités. Assurez-vous d'abord de bien comprendre le cycle de vie d'un
processus léger à la figure 15.1. Ensuite, examinez attentivement les exemples du livre,
en particulier ceux des figures 15.4 à 15.6 portant sur des threads producteur /
consommateur et leur synchronisation.

Effectuez les exercices à la fin des chapitres 14 et 15, en particulier les exercices de
programmation,14.21, 14.27, 15.25 et 15.26 .

32
Unité 10. Fichiers, flux et réseaux
L'utilisation des fichiers est presque inévitable dans la plupart des applications. Nous
examinons dans cette unité comment enregistrer des données dans un fichier et comment
les lire, que ce soit par accès séquentiel ou par accès aléatoire. Java gère les fichiers au
moyen de flux ou streams.
Nous abordons ensuite les notions de réseau. Les sockets constituent sans doute la façon
la plus simple d'établir une communication entre deux ordinateurs, le client et le serveur.
Cette communication s'effectue au moyen d'échanges de flux identiques à ceux qu'on
utilise dans le traitement des fichiers.

Objectifs de l’unité

• Pouvoir créer, lire, écrire et mettre à jour un fichier.


• Comprendre la hiérarchie de classe des flux Java.
• Pouvoir utiliser les classes FileInputStream et FileOutputStream.
• Pouvoir utiliser les classes ObjectInputStream et ObjectOutputStream.
• Savoir utiliser la classe RandomAccessFile.
• Savoir utiliser un dialogue JFileChooser pour accéder aux fichiers et aux répertoires.
• Comprendre l'accès séquentiel et l'accès aléatoire des fichiers.
• Pouvoir utiliser la classe File.
• Comprendre les éléments de réseau en Java utilisant des sockets et des datagrams.
• Pouvoir implémenter des applications réseau en Java au moyen de sockets et de
datagrams.
• Comprendre comment implanter des clients et des serveurs Java qui communiquent
entre eux.

Étude
Lisez les chapitres 17 et 21 de Deitel & Deitel. Il y a deux erreurs dans l'exemple de la
figure 17.14. Si vous ne voyez pas les boutons lors du lancement de l'application, ajoutez
dialoguePrincipal.setVisible(true); entre les lignes 118 et 119. De plus, il faut
ajouter enregistrement.setSolde(Double.parseDouble(valeurs[3])); entre les
lignes 321 et 322. Faites bien attention à la remarque Erreurs de programmation
courantes 17.1 à la page 880. La solution à ce problème est donnée à la section 17.12.

Le chapitre 21 vous initie à la programmation réseau. Compilez et faites exécuter le


navigateur élémentaire de la figure 21.2. Lors de l'exécution, écrivez l'URL du site que
vous voulez atteindre à l'endroit indiqué et tapez enter. Quelle fonctionnalité pour 1,25
page de code!

Pour la programmation à base de sockets, compilez et faites exécuter simultanément le


serveur et le client des figures 21.3 et 21.4. Pour ce faire, ouvrez simultanément

33
Server.java et Client.java avec TextPad. Dans la fenêtre Server.java, faites Run
Java Application dans le menu Tools. Une fois le serveur lancé, passez à la fenêtre
Client.java et faites Run Java Application. Vous pouvez aussi lancer deux instances
de la fenêtre DOS, puis dans l'une faire java Server et dans l'autre java Client. Dans
cet exemple, votre ordinateur sert de serveur (127.0.0.1 = localhost) et vous verrez la
connexion s'établir entre le Client et le Serveur.

Effectuez les exercices à la fin des chapitres 17 et 21, en particulier les exercices de
programmation 17.11 , 21.15 et 21.18.

34
Unité 11. Programmation client/serveur 1 :
JDBC et servlets
Vous avez sans doute entendu parler de l’approche client-serveur dans d’autres cours.
Cette technologie s’avère d’autant plus importante et intéressante que les applications
sont distribuées et font usage d’intranets ou de l’Internet. Nous voyons dans cette unité
comment implanter en Java l’accès aux bases de données à distance et comment Java
gère la sécurité des accès.

Par ailleurs, dans certaines applications, il vaut mieux que le programme s'exécute sur le
serveur plutôt que dans le poste client, comme c'est le cas pour les applets. C'est le rôle
des servlets. Ces dernières sont de plus en plus adoptées comme solution dans les
applications de commerce électronique.

Objectifs de l’unité

• Comprendre le modèle relationnel de base de données.


• Pouvoir utiliser les classes et interfaces du package java.sql pour interroger une base
de données, y insérer ou y mettre à jour des données.
• Comprendre les requêtes de base utilisant SQL.
• Pouvoir utiliser la class JTable pour afficher les données.
• Pouvoir écrire des servlets et les exécuter au moyen du JSDK
• Savoir répondre aux requêtes http GET et POST à partir d'une HttpServlet.
• Pouvoir utiliser les cookies pour enregistrer l'information sur un client durant une
session de navigation.
• Pouvoir utiliser le suivi de session dans un servlet.
• Pouvoir lire et écrire des fichiers dans un servlet.
• Pouvoir accéder une base de données à partir d'un servlet.

Étude

Lisez les chapitres 18 et 19 du livre de Deitel & Deitel. Si vous avez déjà suivi un cours
de bases de données (par exemple IFT-19022 ou IFT-20328), vous pouvez vous rendre
directement à la section 18.6. Compilez et exécutez l'exemple 18.24, après avoir
configuré ODBC tel qu'indiqué à la section 18.6.1. Cet exemple affiche le contenu d'une
table de base de données relationnelle sous forme de tableau à l'aide de la classe JTable.
Exécutez également les exemples 18.29, qui affiche le résultat d'une requête, et 18.30, qui
permet de mettre à jour une base de données. Le livre utilise Access situé dans le même
ordinateur que le programme, mais on pourrait aisément utiliser une base de données à
distance. Si vous voulez accéder à d'autres bases de données qu'Access, par exemple,
Oracle, il vous faut télécharger le driver approprié. Dans le cas d'Oracle, l'adresse est :
http://industry.java.sun.com/products/jdbc/drivers.

35
Vous pouvez aussi lire l'excellent tutoriel de Sun sur JDBC à l'adresse :
http://java.sun.com/docs/books/tutorial/jdbc/index.html.

La seconde partie de cette unité porte sur les servlets. Ce sont des programmes Java qui
s'exécutent sur le serveur à la demande du client. Ils sont de plus en plus utilisées dans
des applications de commerce électronique pour permettre, entre autres, l'accès
sécuritaire à un site Web et l'interaction avec des bases de données. Téléchargez le JSDK
de Sun à l'adresse : http://java.sun.com/products/servlet/download.html. Placez le où vous
voulez sur votre disque. Démarrez le serveur en lançant le fichier startserver.bat du
JSDK. Compilez l'exemple 9.5. Placez votre classe compilée de servlet dans le répertoire
webpages\WEB-INF\servlets. Lancez la page html de la figure 19.6 avec votre
navigateur Internet. Ce dernier devrait alors accéder à votre servlet et afficher le résultat.
Faites la même chose avec les figures 19.7 et 19.8, qui traitent un formulaire, puis avec
les figures 19.9, 19.10 et 19.11, qui placent un cookie dans votre machine, puis les
figures 19.13 et 19.14, qui utilisent le suivi de session, et finalement les figures 19.16 et
19.17 dans lesquelles le servlet accède à une base de données Access.

Vous trouverez d'autres exemples de servlets dans le JSDK. Pour les exécuter, lancez le
serveur avec startserver.bat. Démarrez votre navigateur Internet et connectez vous à
localhost:8080.

Vous pouvez aussi lire le tutoriel de Sun sur les servlets à l'adresse :
http://java.sun.com/docs/books/tutorial/servlets/index.html.

Une extension de l'API Java Servlet de plus en plus utilisée dans le commerce
électronique est l'API Java Server Pages ou JSP, qui permet de configurer des pages Web
de façon dynamique. Si le commerce électronique vous intéresse, vous trouverez des
renseignements sur cette API à l'adresse :
http://java.sun.com/products/jsp/index.html, et un tutoriel à l'adresse :
http://java.sun.com/products/jsp/docs.html

Effectuez les exercices à la fin des chapitres 18 et 19, en particulier les exercices de
programmation18.2 et 19.5.

36
Conclusion
Le langage Java est encore en pleine évolution. Il s’adjoint chaque jour de nouveaux
adeptes, et on évalue présentement à plus de 700 000 le nombre de développeurs en Java.
Il est fort probable que, d’ici quelques années, il remplacera C++ comme logiciel de
choix pour le développement de logiciel.

37