TP 2-BENSLIMANE Heritage, Exception,...

Réalisé par :
 BENSLIMANE Mohamed ;
Université Sidi Mohamed Ben Abdellah Cours : Programmation JAVA
École Supérieure de Technologie de Fès Année Universitaire : 2019/2020
Département Informatique
Introduction………………………………………………..…3
1. Les types de base du langage………………………….…..4
2. Principes de la Programmation Orientée Objet………..…..9
3. Les Exceptions Java……………..…………….……….…15
4. Les Packages Java………………………………………...17
5. L’Héritage…………………………………………...……19
6. Les Classes Abstraites…………………………………….22
7. JDBC……………………………………………………...24
8. Les Applets Java …………………………………………27
9. L’API Swing…………………………………………...…30
Conclusion…………………………………………………...35
2
INTRODUCTION :
Qui n'a pas encore entendu parler de Java ? Personne, c'est normal !
Ce nouveau langage connaît un succès qu'aucun autre langage n'avait
encore connu. Mais quelles en sont les raisons? A notre avis c'est une
multitude de petits (ou gros) détails qui font que finalement Java est une
bonne solution, et ce quelque soit le problème. En effet, tout d'abord, Java
est portable : un programme, une fois compilé fonctionnera aussi bien
sous des stations Unix, que sous Windows ou autre. Au point de vue du
langage, il intègre tous ce que l'on sait faire de mieux en matière de
langage de programmation, tout en évacuant les erreurs faîtes sur les
langages dont il est issu (C et C++).
Son API (Application Programming Interface) est très riche : différents

packages permettent d'accéder au réseau, aux entrées/sorties, aux
différents composants graphiques ... Et bien d'autres points encore.
Finalement, on pourra grâce à Java programmer tout ce que l'on voudra :
gestionnaires de fichiers, traitements de texte, applications réparties,
jeux, ...
Une des caractéristiques principales de ce langage est que le code Java

sera compilé pour une machine dite virtuelle (c'est-à-dire qui n'a pas
forcément d'existence physique,mais son concept peut être reproduit sur
une machine cette fois-ci réelle) : le code machine résultant est nommé
Byte Code. Lors de l'exécution le code machine produit sera transformé en
un code machine compréhensible par le microprocesseur que vous utilisez.
La raison de ce choix est que Java se veut portable : le programmeur ne
souhaite plus faire des adaptions pour que son programme puisse
fonctionner sur telle ou telle machine.
Ce langage est un vrai langage de programmation : il intègre tous ce que

l'on sait faire de mieux en matière de langage de programmation, tout en
y enlevant ce qui s'est avéré être des erreurs du passé. Java est un
langage orienté objet : la brique de base du programme est donc l'objet,
instance d'une classe (on expliquera tout cela en détails dans le chapitre
concerné). La gestion de la mémoire n'est plus à la charge du
programmeur, enfin : en effet, des techniques de désallocation
automatisée de la mémoire existent.
La syntaxe, ainsi que quelques points de sémantique, sont inspirés de
C++ et donc, par conséquent, de C.
3
Java possède une API (Application Programming Interface) extrêmement

riche. En effet, sans celle-ci, Java n'est rien. C'est par elle que le
programmeur va pouvoir accéder à toutes les ressources de la machine, et
celles du réseau Internet. Cette vaste librairie est divisée en packages :
des ensembles de classes.
De plus Java, est simple (relativement aux autres langages orientés objets
: C++ notamment) à appréhender, car il offre, comme nous l'avons dit,
tous les mécanismes nécessaires à un langage orienté objets, tout en
étant débarrassé de mécanismes souvent sources d'erreurs. Il apparaît
donc au terme de cette petite introduction, que Java est une solution aux
problèmes informatiques du moment. De plus, comme il est encore jeune,
il devrait facilement pouvoir s'adapter aux évolutions futures de
l'informatique.
1°/- Les types de base du langage :
Comme beaucoup d'autres langages, Java possède un certain nombre de

types de bases. Mais contrairement au autres, Java impose que la
représentation interne de ces types de bases soit uniforme (même espace
mémoire) et ce, quelque soit la machine sur laquelle tourne le
programme. En effet, cette uniformisation est un gage de portabilité pour
les applications écrites en Java.
La déclaration des variables
Pour un peu situer (ou resituer) les choses, une variable est en quelques
sortes la carte d'identité d'un petit élément (une donnée) du programme.
Ce petit élément est totalement définit par la connaissance des
informations suivantes :
le type de la donnée : nous allons très rapidement revenir sur la notion
de type. En simplifiant les choses, on pourra dire qu'un type correspond à
un ensemble de valeurs que pourra prendre une donnée qui aura était
définit à partir de ce type. Par exemple, le type entier, définit un ensemble
de valeurs numériques, non décimales, compris entre une borne minimale
et une borne maximale (nous en reparlerons).
le nom de la variable : ce nom permet d'identifier ce petit élément de
programme. En l'utilisant, on pourra alors affecter, à la donnée
mentionnée, une valeur (bien entendu, contenue dans l'ensemble de
valeurs définit par le type).
une éventuelle valeur initiale : pour pouvoir correctement utiliser cette
donnée, il pourra être judicieux de lui donner une valeur initiale. Par la
suite, la valeur de la variable pourra malgré tout changer (sauf dans
quelques cas précis).
Bien entendu, il faut, pour que le compilateur comprenne ce qu'on veut lui
dire, que la définition des variables respecte une certaine syntaxe. Toute
4
déclaration débute en mentionnant le type utilisé pour la (ou les)

variable(s) considéré(s). Ensuite, on faire suivre le nom de chaque
variable à définir (séparées par des virgules). Un point-virgule final
permet de terminer la déclaration. Pour chaque variable, on peut à la
volée, mentionner la valeur initiale en utilisant le signe d'égalité suivit de
la valeur : le compilateur fera alors attention à ce que chaque valeur soit
compatible avec le type utilisé. Attention à une chose : le langage fait la
distinction entre minuscules et majuscules. La variable nommée i est donc
distincte de celle nommée I.
Les types numériques

Le langage propose un grand nombre de types numériques. On peut
classer ces types en deux catégories : les types entiers et les types
décimaux. Ce qui différencient les types d'une même catégorie, c'est la
taille de mémoire utilisée pour contenir une valeur. Plus cette taille est
grande, plus les valeurs utilisables sont nombreuses. Vous choisissez donc
un type en fonction de l'étendu de valeur souhaitée pour vos variables.
Les types numériques entiers

Quatre types d'entiers vous sont proposés. La différence réside dans la
taille nécessaire pour stocker la valeur. Le tableau qui suit précise un petit
peu mieux les choses. Le bit y est utilisé pour décrire les tailles. Notez
5
qu'un bit ne peut prendre que deux valeurs (0 ou 1). En conséquence, n

bits ne peuvent définir que 2n valeurs. On regroupe traditionnellement
(c'est lié à des aspects électroniques) les bits par groupe de huit, ce qui
forme un octet (byte en anglais). Un octet peut donc contenir 28 (soit
256) valeurs distinctes.
De même que pour les types numériques, vous avez deux types pour les
nombres décimaux, la seule différence résidant dans la taille utilisée pour
stocker une valeur de ce type.
Le type booléen
On introduit une variable de ce type pas le mot clé booléen. Ce type
accepte seulement deux états : l'un est nommé true et symbolise un état
d'acceptation, l'autre, nommé false, symbolise un état de réfutation.
Attention, ce n'est plus comme en C : le type booléen n'est pas en Java,
un sous-type numérique (on rappelle qu'en C, la valeur 0 est considérée
comme fausse et les autres valeurs entières comme vraies).
Le type chaîne de caractères
Première remarque, par rapport au langage C, le type chaîne de
caractères et totalement différent du type tableau de caractères. Pour ce
qui est de la syntaxe d'un chaîne de caractères, rien n'a changé par
rapport à C ou C++ : une chaîne de caractères commence par un
caractère double guillemets et se termine aussi par ce même signe.
Ainsi, "Amine" est une chaîne de caractères. Là où ça se complique un
petit peu, c'est que le type d'un telle valeur est String, qui est une classe
fournie par la machine virtuelle.
Les tableaux
De même que beaucoup d'autres langages, Java permet lui aussi de
définir des tableaux. Pour ceux qui ne connaissent pas encore ce concept,
on dira qu'un tableau est la succession d'un certain nombre d'éléments
d'un type particulier : on peut donc, par exemple, obtenir un tableau (une
succession) de dix float.
6
Un remarque importante : on peut créer un tableau d'élément de

n'importe quel type.
Une seconde remarque tout aussi importante: un tableau d'élément d'un
type donné possède lui aussi un type : le type tableau d'élément du type
initial. On peut donc créer des tableaux de tableaux : c'est ce mécanisme
qui permet de simuler de tableaux multidimensionnels.
Précédence des opérateurs

Comme vous l'avez certainement déjà remarqué, il est possible de se
servir de parenthèses pour fixer l'ordre d'évaluation des sous- expressions
formant une expression
Java. Ainsi, les expression 3*2+4 et 3*(2+4) n'auront pas les mêmes valeurs
(10 et 18).
Mais attention tout de même : l'utilisation abusive des parenthèses rend
très rapidement un code illisible. Dans le but de ne pas arriver dans de
telles situations, sachez que des règles de priorités ont étaient définies sur
les opérateurs. Le tableau suivant fixe cet ordre : du plus prioritaire à
l'opérateur de séquencement (,) qui est le moins prioritaire.
Dorénavant, utilisez donc bien les parenthèses.
7
Nous venons donc de survoler l'ensemble des opérateurs, ainsi que

quelques expressions du langage. Ils nous seront fort utile pour calculer
des valeurs (numériques ou autres) dans nos programmes. Mais cela ne
fait pas tout, il nous faut aussi pouvoir définir le comportement général du
programme.
Les instructions liées aux boucles
Les instructions conditionnelles et itératives du JAVA sont pratiquement

les mêmes que celles des langages C, ou C++.
8
2°/- Principes de la Programmation Orientée Objet:
Le modèle objet de Java

Nous avons, dans le chapitre précédent, étudié l'ensemble des instructions
de base du langage. Si vous avez bien regardé tous les exemples, vous
avez pu remarquer qu'à chaque fois, le code était placé dans une
structure introduite par le mot clé class. Il s'agissait d'une définition de
classe. Celle-ci se place dans le cadre de la programmation orientée objet.
En quelques mots, on peut dire qu'il s'agit d'une méthodologie permettant
de décrire un problème de façon la plus proche possible de la spécification
de ce dernier.
En d'autres termes, l'approche programmation orientée objet confère au
langage une expressivité accrue.
Définition d'une classe
Comme nous l'avons donc déjà dit, on introduit une définition de classe
par le mot clé class. Celui ci doit être suivi du nom de la classe puis d'une
description de ses champs
(Attributs et méthodes) mise entre parenthèses.
Les attributs de classe
Dans les chapitres précédents, nous avons déjà vu comment définir des
variables à l'intérieur d'une méthode (rappelez vous les exemples avec les
méthodes main). Pour définir un attribut de classe, on réalise la même
démarche. En effet, un attribut de classe peut quand même être vu
comme une variable, au même titre que les variables. La différence
essentielle réside dans le fait que le domaine de visibilité est plus grand
dans le cas des attributs de classe. Par domaine de visibilité, j'entends
l'étendue des parties du code du programme sur lesquelles l'attribut peut
être accédé (ne serait-ce déjà que par toutes les méthodes de la classe).
Une variable, elle, ne peut être utilisée uniquement qu'au niveau du bloc
d'instructions dans lequel elle est définie (éventuellement une méthode).
La classe suivante donne la description d'une classe Circle associée à la
notion de cercle : elle devra donc contenir un point pour le centre (de type
Point2D) et un rayon
(Valeur flottante, double précision). La classe Point2D, elle, contiendra
deux valeurs
(Flottantes, double précision) permettant de définir les coordonnées d'un
point dans le plan.
9
Les méthodes
Maintenant, nous désirons définir des comportements liés à cette classe
graphique qu'est le cercle. Nous devons donc définir des méthodes à cet
effet. Supposons que dans le cadre du programme que nous sommes en
train d'écrire nous ayons besoin de déplacer un cercle selon un vecteur
donné : il nous faut donc écrire une méthode qui prend un vecteur en
paramètre. Nous devons donc, au passage, définir une classe
Vector2D (cette classe possèdera deux attributs de type flottant double
précision). Une petite remarque, au stade actuel de l'écriture de ce petit
programme, on pourrait penser qu'il soit judicieux de ne pas créer la
classe Vector2D et d'utiliser à la place la classe
Point2D contenant la même information. Ceci est une mauvaise idée, car il
est clair que la sémantique d'un point du plan n'est pas la même que celle
d'un vecteur.
Mathématiquement, ils représentent deux concepts différents avec
lesquels ont obtient des traitement différentes. Il est donc très fortement
conseillé des séparer les choses en codes distincts, dès lors que l'on parle
de deux concepts différents. Si vous faite ainsi, il sera très facile de
rajouter un comportement (une méthode) si vous l'avez oublié
(Autrement, cela ne serait peut-être pas si simple). Nous obtenons donc
les classes suivantes :
10
La surcharge de méthodes
Si maintenant, vous voulez définir un déplacement de cercle, non pas en
spécifiant un vecteur, mais bien une valeur en x et une seconde en y, il
vous faut écrire une autre méthode. L'exemple suivant vous montre
comment faire.
11
Vous aurez certainement remarqué que l'on a utilisé le même nom pour
les deux méthodes : cette possibilité s'appelle la surcharge. Cela
fonctionne car, lorsque vous utiliserez une des deux méthodes, vous
spécifierez soit un argument de type Point2D, soit deux arguments de
type double. Plus formellement, deux méthodes ne doivent pas avoir le
même prototype (nous entendons par là le type de paramètres et celui de
retour de la méthode). Donc, si nous voulons définir deux méthodes de
déplacement, une horizontalement et une verticalement, nous ne pouvons
pas les nommer de la même manière, sans quoi on ne pourrait savoir
laquelle choisir lors d'un appel de méthode.
Voici donc un programme possible, agrémenté d'une méthode d'affichage
texte.
12
N.B. : les méthodes System.out.print et System.out.println affichent

toutes les deux un message passé en paramètre, la différence résidant
dans le fait que la seconde rajoute en plus un retour à la ligne suivante.
Instanciation d'objet
Nous avons, jusqu'à maintenant, vu comment définir une classe d'objets. Nous allons, à
présent, voir comment définir des objets à partir d'une classe. Cette création d'objet, à
partir d'une classe, est appelée instanciation. On instancie donc un objet en appliquant
l'opérateur new sur un constructeur de classe. Précisons un peu les choses.
L'allocation de mémoire
Pour qu'un objet puisse réellement exister au sein de la machine, il faut qu'il puisse
stocker son état dans une zone de la mémoire. Or deux objets définis à partir de deux
classes différentes n'ont, à priori, pas forcément besoin de la même taille d'espace
mémoire (car n'ayant pas les mêmes définitions d'attributs). L'opérateur new est donc là
dans le but de nous simplifier la vie. Par l'intermédiaire d'une méthode un peu
particulière (un constructeur) d'une classe données, cet opérateur déterminera sans
problème la taille de l'espace mémoire requis.
Les constructeurs
De manière basique, on peut dire qu'un constructeur est une méthode d'une classe
donnée, servant à créer des objets. Remarque importante à retenir : un constructeur n'a
pas de type de retour, contrairement aux méthodes et se nomme toujours de la même
manière que sa classe. De même que les méthodes acceptent la surcharge, les
constructeurs l'admettent aussi. L'exemple suivant propose donc quelques constructeurs
pour nos classes déjà étudiées.
13
On remarque deux choses en regardant ce programme. Un constructeur

peut créer des objets qu'il utilise. Second point, on s'aperçoit que les
constructeurs servent principalement à définir l'état initial des objets
instanciés. Sans un tel mécanisme il serait difficile de connaître l'état
initial des objets et donc quasi impossible de déterminer l'évolution du
programme.
Quelques règles sur les constructeurs :
14
Si aucun constructeur n'est spécifié, dans la définition de la classe, un

constructeur par défaut vous est obligatoirement fourni, celui-ci
n'admettant aucun paramètre.
Si vous en définissez au moins un, le constructeur par défaut (qui n'admet
pas de paramètres) n'est plus fourni. Si vous en avez l'utilité il vous
faudra alors le définir explicitement.
Les destructeurs
Nous venons donc de voir que des constructeurs pouvaient être fournis
pour permettre la création d'objets. Parallèlement, un destructeur (et un
seul) peut être défini pour être utilisé lors de la destruction de l'objet.
Celui-ci doit forcément se nommer finalize, il ne prend aucun paramètre et
ne renvoie aucun type (void). Cette méthode doit, de plus, être qualifiée
de public, sans quoi le compilateur vous rappellera à l'ordre.
Voici un petit exemple :
3°/- Les exceptions Java :

Nous allons au cours de ce chapitre nous intéresser à la gestion et à la
manipulation des exceptions. Celles-ci permettent de traiter, d'une façon
plus élégante les cas d'erreurs que ce que l'on aurait pu trouver en C, par
exemple, pour réaliser les mêmes choses.
Comme nous allons le voir, deux mécanismes principaux permettent
d'acquitter une exception. Soit on la traite, soit on la relaye à la méthode
appelante. Pour mieux comprendre les choses, rentrons de suite dans des
exemples clairs et explicites.
On traite l'exception.
Si l'on décide de traiter une exception, il nous faut alors définir un certain
nombre de blocs d'instructions. Pour ce faire, trois mots clés sont à notre
disposition : try, catch, finaly. Nous allons donc étudier chacun de ces
mots clés en détail.
15
Le mot clé try.

Ce mot clé permet de spécifier une section de code sur laquelle on
s'attend qu'une exception (une erreur) soit levée. La syntaxe est simple
on place le mot try, une accolade ouvrante, la section de code et, enfin,
une accolade fermante.
Le mot clé catch.
Celui-ci, sert à spécifier le code à exécuter pour une exception (ou une
catégorie) donnée. Il suffit alors de faire suivre le mot catch d'une
parenthèse ouvrante, d'un type exception (une classe) du nom qu'on lui
donne (tout comme un paramètre de fonction), d'une parenthèse
fermante, et du code associé placé entre accolade.
Le mot clé finaly.
Enfin, le mot clé finaly permet d'introduire un code de traitement
d'exception, qui sera de toute manière exécuté. Vous pouvez omettre le
bloc finaly.
Quelques exceptions.
Le tableau suivant vous propose quelques exemples d'exceptions que vous
pouvez traiter.
16
On relaye l'exception.
Maintenant, le problème est de savoir ce que l'on doit faire d'une
exception que l’on n’aurait pas su traiter. Dans ce cas, il faut alors la
relayer à la méthode appelante. Plus généralement, si une méthode est
susceptible de lever une exception, et si celle-ci ne peut la traiter, elle se
doit de prévenir le système qu'elle relaye cette tâche. Pour ce faire on
utilise le mot clé throws.
Le mot clé throws.
Ce mot clé permet d'avertir le système qu'une certaine catégorie
d'exception ne sera pas traitée en local (dans l'exemple suivant,
l'ensemble des exceptions liées aux entrées/sorties).
4°/- Les Package Java :
Nous allons, durant ce chapitre, étudier le concept de package. Un

package est en fait un regroupement de classes, travaillant conjointement
sur le même domaine : en effet, il serait inutile de lier des classes qui non
aucun rapport les unes avec les autres. Par contre, lier toutes les classes
qui travaillent, par exemple, sur les flots de caractères, peut facilement
sembler logique. Partant de cette idée les concepteur du langage ont
développés une série de packages permettant d'utiliser l'ensemble des
ressources de la machine (c'est l'API de Java). Chacun de ces packages
ayant un domaine d'action bien déterminé, comme, par exemple, les
connexions réseaux, les composants graphiques, ...
Il vous est donc possible d'utiliser cet ensemble de packages (l'API) en
spécifiant les packages dont vous avez besoin.
Mais vous pouvez, de plus, définir vos propres packages et les utilisez
dans vos programmes. Nous allons donc, durant ce chapitre, voir
comment on définit un package, comment on en utilise un, quel sont les
intérêts, et quelques autres choses.
Création d'un package.
Nous allons donc, dans un premier temps, nous intéresser à la création
des packages.
Pour ce faire, deux étapes sont nécessaires. La première consiste à
déterminer dans chaque fichier, à quel package il appartient. La seconde
place les fichiers de byte code générés à une position bien précise de
l'arborescence de fichiers de votre support de stockage (disque dur ou
autre). Reprenons en détail chacun de ces deux points.
17
Le mot clé package.

Nous devons donc, en premier lieu, indiquer pour chaque fichier de quel
package il fait partie. Si vous ne spécifiez pas de package, le fichier
appartient à un package qui vous est donné par défaut : par conséquent,
tout fichier Java (et donc toute classe) appartient
à un package, même si vous ne le spécifiez pas explicitement. Au niveau
de la syntaxe, c'est très simple, il suffit d'ajouter le mot clé package suivit
du nom du package auquel le fichier appartient et d'un point-virgule.
Importer les classes d'un package.

Le mot clé import.
Nous allons, maintenant, voir qu'il Il existe plusieurs façons pour utiliser
un package.
En effet vous pouvez soit spécifier que vous utilisez un package complet,
soit vous déterminez, un par un, les fichiers du package que vous voulez
utiliser. Vous pourriez être amener à penser qu'il vaut mieux importer
deux fichiers d'un package, plutôt que le package complet, surtout si
celui-ci comporte de nombreux autres fichiers. Il en est rien.
En effet, comme je l'ai dit, il y a quelque instant, les fichiers ne sont pas
tous chargés dés le début de l'exécution du programme, mais
dynamiquement, et seulement si besoin est. On n'augmente donc pas la
place mémoire prise par le programme, lors de son déroulement. En fait,
quand vous spécifiez que vous importez un package, vous donnez juste
une indication quant à la localisation des fichiers le constituant. Il est donc
préférable d'importer un package complet, plutôt que d'importer quelques
fichiers d'un même package.
Pour importer une classe d'un package, on utilise le mot clé import suivit
du nom du package (associé à un répertoire, rappelons le), d'un point, du
nom de la classe et d'un point-virgule. Dès lors que votre programme
contient une telle déclaration d'importation, vous pouvez y utiliser la
classe. Si vous voulez importer directement le package complet, il vous
suffit de remplacer le nom de la classe par un signe multiplié (*). Ce
mécanisme est repris sur l'utilisation de joker dans les systèmes de
fichiers, ce qui est d'ailleurs logique, quand on pense qu'à une classe est
associé un fichier portant le même nom
Accéder directement à une classe d'un package.
Mais il n'est pas obligé d'importer un package pour pouvoir en utiliser
quelques fonctionnalités. En effet, vous pouvez accéder à une classe en
spécifiant sa localisation complète, directement dans le code. L'exemple
suivant sera plus explicite.
18
5°/- L'héritage :
Afin de vous amener simplement, mais clairement, à l'assimilation de ce
concept, nous allons tout d'abord considérer une extension du programme
manipulant nos fameux cercles sur un espace à deux dimension. Il en
résultera une simplification phénoménale du problème.
Ce qu'il ne faut surtout pas faire
L'extension va consister en l'introduction de classes liées aux autres
notions de figures dans le plan. En effet, nous aimerions, maintenant,
pouvoir manipuler, outre des cercles, des carrés, des rectangles, des
triangles, ou toutes autres figures géométriques de votre choix. L'idée la
plus basique se résume en la définition d'une classe par type de figures.
Ce qu'il faut faire
L'idée principale consiste à définir une classe à partir d'une autre. La
classe définie à partie d'une autre sera nommée classe fille. Celle qui sert
à définir une classe fille sera nommée classe mère. On dit alors que la
classe fille hérite (ou dérive) de la classe mère.
Une remarque importante peut déjà être faites : une classe fille dérive
d'une unique classe mère.
Une fois que l'héritage est spécifié, la classe fille possède aussi l'ensemble
des attributs et des méthodes de sa classe mère.
La principale difficulté, avec l'héritage, est de définir ce qui est propre à la
classe mère et ce qui l'est pour sa classe héritière. Dans tous les cas, cela
est fortement lié au problème considéré. Revenons donc à nos classes
Circle et Square. On remarque alors que dans les deux cas, on a besoin de
connaître la position du centre de la figure. De même, on définit dans les
deux cas, les mêmes méthodes, liées au déplacement de la figure. En
réfléchissant encore un peu, on peut alors pressentir qu'il en sera de
même pour toutes les classes associées à la notion de figures
géométriques. Il pourrait donc être judicieux de définir une classe Shape
de laquelle toutes les classes, associées à une figure géométrique,
pourraient hériter.
19
Au niveau de la syntaxe à utiliser pour définir un lien d'héritage, c'est très

simple. Il suffit d'ajouter le mot clé extends suivit du nom de la classe
mère, de suite après le nom de la classe fille, ce dans la définition de cette
dernière.
Un point important et souvent source d'erreur est à éclaircir. On n'hérite
en aucun cas des constructeurs. Si vous ne spécifiez pas explicitement un
constructeur particulier, vous ne pourrez l'utiliser, ce même s'il en existe
un défini dans la classe mère. Par contre, des règles existent sur
l'utilisation des constructeurs de la classe mère dans les constructeurs
d'une classe fille quelconque.
Avant de voir ces règles en détail, quelques précisions sont à apporter sur
deux mots clés du langage : super et this. Le premier sert à accéder les
définitions de classe au niveau de la classe parente de la classe considérée
(ces définitions pouvant être soit des méthodes ou des constructeurs). Le
second sert à accéder à la classe courante.
20
21
6°/- Les Classes Abstraites :
Faire usage de l'abstraction

Il peut donc, dans certains cas, être utile de définir une méthode sans en
donner le code. Les seules informations données sont donc le nom de la
méthodes, les types des paramètres et le type de retour de cette dernière
: on nomme cela le prototype de la méthode. En Java, on dit qu'on définit
une méthode abstraite. C'est la même chose. Pour réaliser une telle
définition, il suffit de mettre en tête de la définition du prototype le mot
clé abstract. Dans ce cas, on ne définit plus le corps de la méthode et on
supprime les accolades que l’on ne remplace pas un point-virgule. Voici un
exemple de définition de méthode abstraite.
Mais attention : on ne peut pas définir une méthode abstraite n'importe

ou. Cela ne se peut que dans une définition de classe abstraite.
Définir une classe abstraite
Une classe abstraite est une classe qui peut contenir des méthodes
abstraites. Une chose importante est a signaler d'hors et déjà : comme
une classe abstraite, possédant des méthodes dont le code est inconnu,
est incomplète, on ne peut en aucun cas instancier d'objet de cette classe.
Il faut impérativement définir des classes filles, lesquelles fournirons les
définitions manquantes (soit quoi elles seraient aussi abstraites).
Ces classes filles peuvent, par contre, servir à instancier des objets. Dans
le cadre de nos classes de figures, cela se traduit pas le fait que si la
classe Shape est abstraite, on ne peut plus instancier d'objet de cette
nature (plus de "new Shape()").Du point de vue de la syntaxe, on définit
une classe abstraite en rajoutant devant le mot clé abstract. Le code de la
classe Shape devient donc le suivant.
22
Certains d'entre vous sont peut-être gênés par le fait que l'on ne puisse
plus créer d'objet de classe Shape. Mais physiquement, il n'y a pas de
figures, mais des cercles et des carrés, et d'autres formes, que l'on
regroupe sous le terme générique de figures.
Donc, notre modèle est conforme à la spécification (implicite) de notre
problème.
23
7°/- Java Data Base Connectivity :
Nous allons dans cette partie du cours sur le langage Java, nous intéresser
à l'API
(Application Programing Language) JDBC (Java DataBase Connectivity).
Cette API à était développée par SUN pour permettre à des applications
Java d'accéder à des bases de données relationnelles quelconques.
Comme vous le savez certainement, on manipule le contenu d'une base
de données relationnelle en utilisant des ordres codés en langage SQL
(Structured Query Language).
JDBC : Les différents types de pilotes
Nous allons, dans ce chapitre, voir qu'il existe plusieurs types de drivers
(de pilotes) de bases de données. Il existe, de plus, plusieurs bases de
données. D’où un nombre impressionnant de combinaisons possibles.
Nous verrons aussi comment charger dynamiquement un pilote, spécifique
à une base de données, dans la JVM : nous traiterons de deux cas
particuliers.
Les quatre types de pilotes JDBC
Il existe quatre types de drivers (de pilotes) JDBC. Nous ne traiterons
dans ce cours de deux types de pilotes. Malgré cela, voici un petit
descriptif de ces quatre types de pilotes.
Les drivers de pont JDBC/ODBC : ce type de pilote, fourni en standard
avec le J2SE (Java 2 Standard Edition), permet de convertir les appels
JDBC en appel ODBC (Open Data base Connectivity). ODBC est fourni en
standard sur tout Windows et permet la connexion à des bases de natures
diverses (Access, SQL
Server, Oracle, ...).
Les drivers de type 2 : ils sont écrits, en partie, en Java, mais dépendent
malgré tout de code natif. En terme de portage d'application Java, ces
types de pilotes présentent quelques lacunes.
Les drivers de type 3 : ce type de pilote passe par un autre pilote JDBC
intermédiaire (fréquemment de type 1 ou 2). Il s'agit certainement du
type de pilote le moins utile des quatre proposés.
Les drivers de type 4 : leur code est écrit en 100% Java, donc portable.
Ces pilotes sont fournis par quasiment tous les constructeurs de bases de
données. Chaque pilote étant adapté à une base de données très
particulières. Ces drivers constituent la meilleure solution pour le portage
de vos applications Java.
Structure d'un programme JDBC

Un code JDBC est de la forme :
- recherche et chargement du driver approprié à la BD.
- établissement de la connexion à la base de données.
- construction de la requête SQL
- envoi de cette requête et récupération des réponses
24
- parcours des réponses.

Syntaxe
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection conX = DriverManager.getConnection(...);
Statement stmt = conX.createStatement();
ResultSet rs = stmt.executeQuery("SELECT a, b, c ... FROM ...
WHERE ...");
While (rs.next()) {
...
// Traitement
}
La programmation avec JDBC
On utilise le paquetage java.sql. La plupart des méthodes lèvent
l'exception java.sql.SQLException.
Chargement du pilote
On commence un programme JDBC en chargeant dans le programme, le
pilote approprié pour la BD. Comme le programme peut interroger divers
types de BD il peut avoir plusieurs pilotes. C'est au moment de la
connexion que sera choisi le bon pilote par le DriverManager.
On a donc une architecture :
En fait cette instruction construit un objet de la classe Class qui modélise

la classe dont le nom est l'argument de la méthode statique forName(...).
Cette classe est un driver c'est à dire ici une classe qui implémente
l'interface Driver. Dans les spécifications de JDBC il est dit
qu'obligatoirement ces classes doivent, au moment de leur premier
chargement :
- créer une instance de cette classe
25
- enregistrer cette instance au sein du DriverManager par la méthode

statique registerDriver(...) de cette classe.
La connexion :On ouvre une connexion avec une des méthodes
DriverManager.getConnection(...) qui retourne un objet d'une classe qui
implémente l'interface
Connection. Ces méthodes contiennent comme premier argument une
"URL JDBC". Elles recherchent le pilote adapté pour gérer la connexion
avec la base repérée par cette URL.
Une URL JDBC doit commencer par jdbc. Le second argument est le
protocole sous jacent dans lequel le pilote traduit. Le troisième argument
est un identificateur de base de données. La syntaxe d'une URL JDBC est
donc:
jdbc:<sous-protocole>:<baseID> la partie baseID est propre au sous-
protocole.
Les arguments suivants de Driver.getConnection(...) sont des informations
nécessaires à l'ouverture de la connexion souvent un nom de connexion à
la base suivi d'un mot de passe.
Requêtes aux bases de données

Sans trop rentrer dans les détails (voir un cours de bases de données pour
cela), il existe différentes sortes de requêtes SQL dont :
- les requêtes SELECT qui opèrent sur une ou plusieurs tables et placent
le résultat dans une "table" résultante.
- les requêtes d'action qui modifient une ou des colonnes ou lignes de
table. On a par exemple comme requête d'action UPDATE, DELETE,
APPEND.
- des SQL DDL (Data Definition Language) comme
CREATE TABLE, DROP TABLE, ...
SQL est un langage non sensible à la casse (culture IBMSQL et non pas
culture Unix-C). En général les mots clés du langage SQL sont mis en
majuscules.
Syntaxiquement en Java on utilise
executeQuery(...) si la requête est une requête
SELECT et executeUpdate(...) si a requête est une requête d'action ou une
SQL DDL.
Les résultats des requêtes SELECT ont été mis dans un
ResultSet. Cet objet récupéré modélise le résultat qui peut être vu comme
une table. Par exemple
SELECT nom, prenom, adresse FROM Personnes retourne un ResultSet qui
modélise :
On parcourt alors tout le ResultSet pour avoir l'ensemble des réponses à
la requête. La boucle de parcours est : while( rs.next() ) {
// Traitement
}
26
8°/- Les applets Java :
Un des aspects qui ont fait le succès de Java réside certainement dans la
possibilité d'écrire des programmes Java pour être incorporés dans des
documents HTML : je parle, bien entendu, des applets Java. En fait, une
applet Java est une petite (ce qualificatif étant tout à fait relatif)
application Java. Il est clair que Java était une solution parfaitement
adaptée à ce type de traitement : différents navigateurs Web existent et
ils peuvent souvent être installés sur différentes plates-formes.
L'architecture Java, a donc permit de garantir que les applets Java
puissent s'exécuter sur différentes architectures.
Nous allons dans ce chapitre présenter les éléments fondamentaux de la
mise en œuvre d'applets Java.
Notre première applet Java

Afin de coder notre première applet, il va nous falloir générer deux
documents : un code Java (l'applet, à proprement parler) et le document
HTML qui va héberger l'applet.
Nous allons reprendre ces deux points un par un.
Mise en oeuvre de l'applet

Une applet est un composant Java tout ce qu'il y a de plus classique.
Néanmoins, elle doit respecter quelques règles bien précises. En premier
lieu, votre classe se doit de dériver de la classe java.applet.Applet, sans
quoi votre composant ne sera pas vu, par le navigateur, comme étant une
applet. Notez que dans ce document, nous allons parler exclusivement des
applets Java codées via l'AWT. Il est cependant possible de coder des
applets via SWING, mais sachez que dans ce cas, tous les navigateurs ne
seront pas forcément les prendre en charge (certains IE notamment). Si
malgré ce point, c'est ce que vous souhaitez obtenir, dérivez alors votre
composant de la classe
javax.swing.JApplet.
En fait, la classe Applet dérive de la classe java.awt.Panel : il s'agit donc
d'un composant Graphique. Effectivement, une applet Java est intégrée
dans une page HTML.
Il fallait donc que cette classe fournisse un support pour le graphisme. En
plus de cela, une applet peut être vue comme un conteneur (de par son
héritage de Panel) : vous pouvez donc ajouter à une applet des
composants graphiques tels que des boutons, des zones de saisies de
textes, ... Pour de plus amples informations à ce sujet, je vous conseil de
vous reporter aux chapitres relatifs à la mise en oeuvre d'interfaces
graphiques.
27
Comme tout composant graphique, une applet propose donc une méthode
paint.
Celle-ci à pour tâche de retracer le contenu de l'applet. Nous allons nous
servir de cette méthode pour afficher le message "Hello World" dans
l'applet, en faisant, à chaque appel, un peu et aléatoirement varier la
couleur du message. De plus, un thread va être utilisé afin de
régulièrement ré-invoquer l'affichage. Cette applet est de plus présenté en
dessous de l'exemple de code (et oui, nous sommes dans une page
HTML).
Intégration de votre applet dans un document HTML

N'essayez pas encore de lancer votre programme. Il nous manque un
deuxième document, la page HTML. Si nous avez, néanmoins, tenté de
lancer ce programme via la commande java, vous avez du recevoir une
erreur. En effet, le programme précédent ne contient pas de méthode
main. Il ne peut donc démarrer de manière autonome.
Pour intégrer l'applet dans la page HTML, il vous faut utiliser le tag
<APPLET>. Celui-ci accepte plusieurs paramètres (ou attributs) dont
certains sont obligatoires. Le premier paramètre obligatoire est code : il
permet de spécifier la classe d'applet. Attention, il faut mettre l'extension
du fichier (.class), contrairement au démarrage d'une application
classique.
Autre petite chose, à bien comprendre, une applet occupe un espace
rectangulaire au sein de la page HTML. Il vous faut spécifier la taille de cet
espace. Pour ce faire, deux paramètres vous sont proposés : width et
height. L'exemple suivant de page HTML vous montre comment intégrer
l'applet précédente dans une page HTML de test.
28
Le tableau suivant reprend les différents attributs que supporte le tag

<APPLET>.
Attention : si vous utilisez la JVM de la société Microsoft, les attributs ne
fonctionneront pas tous.
Code : permet de spécifier la classe de démarrage de votre applet.
N'oubliez pas que celle-ci se doit de dériver de la classe
java.applet.Applet.
Width et Height : ces deux paramètres fixent la taille qu'occupe l'applet
dans le document HTML conteneur.
CodeBase : si vous ne souhaitez pas placer les fichiers ".class" que dans
le même répertoire que les pages HTML, il faut alors spécifier à la JVM ou
elle se doit de chercher les exécutables.
Archive : si votre applet est constituée de nombreuses classes Java, son
téléchargement peut alors être plus ou moins long. Afin d'optimiser ce
téléchargement, vous pouvez archiver tous vos fichiers dans une archive
Java. Pour ce faire, utilisez l'outil jar.exe fournit dans le J2SE
Tant qu'on y est, un autre tag HTML peut vous permettre d'affiner
l'intégration de l'applet JAVA au sein de la page HTML.
<PARAM Name="???" Value="???"> : ce tag, qui s'utilise entre les tag
<APPLET> et </APPLET> permet de pouvoir passer des valeurs
d'initialisation à l'applet. Cette dernière récupère ces valeurs en utilisant
l'instruction
this.getParameter("???"). Dans cet exemple, this référence, bien entendu,
l'applet et ??? Doit être en accord avec le paramètre Name du tag
<PARAM>.
Ca y est, vous avez votre première applet : c'est bien. Mais si nous
cherchons à aller un peu plus loin dans la mise en oeuvre des applets
Java, il nous faut mieux comprendre le cycle de vie de ces dernières. C'est
ce à quoi nous allons maintenant nous attacher.
Le cycle de vie des applets
Une applet est un petit peu plus complexe qu'une application classique.
Normalement, une application Java n'a qu'un unique point d'entrée : la
méthode main, et elle se termine quand votre programme sort du main
(sauf si vous lancez de nouveau thread : c'est ce qui est fait avec les
fenêtres graphiques, notamment).
Pour une applet, cela ne pouvait pas suffire. En fait, ce n'est plus votre
programme qui démarre, mais le navigateur qui lance la JVM, puis quand
le support d'applet est complètement chargé, votre applet est démarrée.
Elle n'a donc plus de méthode main.
Par contre une applet à quatre points d'entrées plus une autre méthode
d'affichage (la méthode paint). Mais à quoi correspondent ces quatre
points d'entrées d'une applet.
public void init() : cette méthode est invoquée quand le navigateur lance
votre applet (normalement une fois pour toute).
29
public void start() : le start est lancé après la méthode init. Pour mieux
comprendre son utilité, il faut bien comprendre que vous pouvez changer
de document HTML à tout moment. Vous étiez en train d'utiliser une
applet puis vous partez sur http://www.infini-fr.com. Votre applet est
alors stoppée, mais pas complètement déchargée de la mémoire. Si vous
cliquez sur le bouton "Back" du
navigateur, seule la méthode start sera alors relancée.
public void stop() : comme nous venons de le comprendre, cette
méthode est lancée quand vous quittez la page HTML contenant l'applet.
Mais la machine virtuelle Java n'est pas arrêtée et l'applet continu de
vivre. Donc, si vous avez lancé des threads, des sons ou des animations à
partir de la méthode start, prenez soin de tous stopper dans le stop. Il
n'est pas rare de continuer à entendre les musiques d'une applet après
avoir quitté cette dernière : cela fait relativement
mauvais effet.
public void destroy() : cette méthode déclanche lorsque le navigateur
décide de décharger la JVM de sa mémoire. Cela intervient dès que le
navigateur décide qu'il manque de mémoire cache. Dans ce cas, si vous
retournez à l'adresse de l'applet, celle-ci devra être complètement
rechargée. Les méthodes init est start seront alors relancées.
9°/- L'API Swing :

Les classes Swing
Les classes Swing s'appuient sur l'arborescence AWT. Les principales
classes Swing sont :
30
Remarques générales
En Java 1.2, les classes Swing se trouve dans le paquetage
javax.swing et ses sous paquetages. Il est fortement déconseillé de
mélanger des composants Swing et AWT dans une interface graphique.
Les composants "haut niveau"
Les composants dits de haut niveau sont :
-les fenêtres fille de la fenêtre fond d’écran, objets des classes JFrame,
JWindow, JDialog
-ainsi que les objets de la classe JApplet
Pour ces objets conteneurs, on n’ajoute pas leurs contenus directement
dans ces objets (contrairement à AWT). On passe par l’intermédiaire de
leur « ContentPane » qui est récupéré par la méthode getContentPane().
Les ajouts Swing
Par rapport à AWT, Swing propose des améliorations notoires sur certains
composants (JLabel, JButton, ..., par rapport à Label, Button, ...) et de
nouveaux composants (bulle d’aide, onglet, ...)
JLabel
On peut construire facilement un JLabel comportant une image gif ou jpg
(accompagnée d’un texte ou non).
Le constructeur le plus complet de JLabel est : public JLabel (String text,
Icon icon,
horizontalAlignment) et il existe d'autres constructeurs avec des
arguments en moins.
Le composant JTable
JTable modélise un tableau c’est à dire une structure présentant des lignes
et des colonnes, bref l'interface graphique d'un tableur. Les cellules de ce
tableur sont des
Component.
C’est un composant complexe et beaucoup de classes dont il dépend sont
dans le paquetage
javax.swing.table.
En général on met une JTable dans une
JScrollPane. Si ce n’est pas le cas les en-têtes des colonnes n’apparaissent
pas.
Les données d’un JTable sont dans le modèle
javax.swing.table.TableModel.
Le composant JTree
Modélise une arborescence. Utilise l’interface TreeModel et la classe
DefaultTreeModel (il n’y a pas de
AbstractTreeModel).
Construire un arbre
On définit tout d’abord les noeuds comme instance de la classe
DefaultMutableTreeNode. En général on utilise le constructeur : public
DefaultMutableTreeNode(Object
31
userObject, boolean allowsChildren) qui crée un noeud sans parent et

sans enfant, initialisé avec l’objet indiqué. Si allowsChildren vaut false ce
noeud restera une feuille.
Par la suite, lorsque tous les noeuds ont été créés comme objet
DefaultMutableTreeNode, ils sont assemblés pour construire un arbre à
l’aide de la méthode add () de
DefaultMutableTreeNode et l’arbre final est construit à l’aide de
JTree(TreeNode root).
Les composants Swing pour le texte
Swing propose 5 classes pour traiter le texte. Ces classes dérivent de la
classe JTextComponent (qui dérive de
JComponent).
Deux de ces classes remplacent les équivalents AWT :
JTextField et JTextArea. Swing propose une classe pour des entrées «
masquées » : JPasswordField.
Dans ces 3 classes, l’affichage du texte est constitué d’une seule police et
d’une seule couleur.
Il existe deux autres classes pour le traitement avancé de

« Texte ».
JEditorPane est un traitement de texte pouvant afficher du texte formaté

avec de nombreux attributs
32
(Différentes couleurs, polices, souligné, gras, ...).

JTextPane permet de définir sa propre grammaire de documents et ses
styles associés alors que JTextEditor est spécialisé pour les textes de
types MIME text/plain,
Text/html, text/rtf.
Dans ces deux classes, les données peuvent être des
Component Swing ou des images.
Traitement d'évènements simples

Nous allons maintenant voir comment savoir qu'un évènement a eu lieu,
et comment allons nous pouvoir y répondre. Pour cela, il nous faut définir
un écouteur, puis enregistrer ce dernier sur un objet susceptible de
déclencher un évènement. Ainsi, si l'évènement apparaît, il pourra être
traité par l'écouteur.
Définition d'un écouteur
Dans le modèle Java de traitement d'évènements, il nous faut définir un
écouteur. Un écouteur est un objet qui possède au moins une méthode qui
pourra être invoquée si l'évènement attendu apparaît. En fait, un écouteur
doit remplir un contrat bien particulier. Dans cet objectif, il se doit
d'implémenter un comportement (la plupart du temps en implémentant
une interface, ou bien en dérivant de certaines classes).
Il existe plusieurs types d'écouteurs, donc plusieurs types d'interfaces.
Toutes ces interfaces ont un nom se terminant par Listener (par exemple
ActionListener,
WindowListener, ...). Selon l'interface, il y a une ou plusieurs méthodes à
implémenter.
A titre d'exemple, considérons l'évènement ActionEvent : cet évènement
est déclenché dès lors que l'on action un bouton (par exemple) soit en
cliquant dessus avec la souris soit en utilisant le clavier. Pour être capable
d'écouter et de traiter un tel évènement, un objet écouteur se doit
d'implémenter une interface nommée
ActionListener. Si vous êtes curieux et que vous étudiez l'interface
ActionListener, vous remarquerez qu'elle ne contient qu'une unique
méthode à implémenter :
actionPerformed. Cette méthode doit donc contenir le code à exécuter si
jamais vous cliquez sur votre bouton.
Enregistrement d'un écouteur
Le problème est simple. On à définit un écouteur (l'objet de classe
PushMe) susceptible de répondre à un click sur le bouton. Mais qui à dit au
bouton, qu'il fallait avertir l'écouteur, si on lui cliquait dessus ?
Absolument personne : le problème est que chaque écouteur doit être
enregistré auprès des objets qu'il est censé écouter (un écouteur peut
écouter plusieurs sources d'évènements - une source d'évènement peut
alerter plusieurs écouteurs). L'exemple suivant enregistre l'écouteur à une
source d'évènements.
33
Maintenant, vous pouvez cliquer sur le bouton. Un message est affiché en

confirmation sur la console. Notez que l'objet source de l'évènement est
aussi affiché sur la console.
Qu'a permi de faire la méthode addActionListener ? En fait c'est simple,
elle à simplement permit de rajouter un écouteur au bouton. A chaque fois
que le bouton est actionné, il cherche maintenant à invoquer la méthode
actionPerformed sur chacun de ses écouteurs. ActionListener pouvant être
utilisé comme un type, le compilateur ne dit rien et tout fonctionne.
34
Conclusion :
Créer la partie statique d’une interface utilisateur est

relativement simple en Java. On dispose d’un nombre important
de composants que l’on peut disposer à sa guise grâce aux
différentes politiques de placement prises en compte par le
langage. Chaque composant possède des attributs et des
méthodes permettant de modifier leur aspect et leurs
comportements.
Bien que les mécanismes mis en oeuvre soient simples, le
programmeur doit garder à l’esprit que la réalisation d’une
interface utilisateur « professionnelle » (plusieurs niveaux de
conteneurs, des menus, des boutons, des boîtes dialogues …) est
une tâche difficile et longue.
TP : Programmation orientée objet en Java

1. Implémentation
Dans cette partie nous allons définir une hiérarchie de classe modélisant
un ensemble d'objets graphiques élémentaires.
Exercice 1: Ecrire le code des différentes classes nécessaires à
l'implémentation de la hiérarchie suivante :
Avec les méthodes (on utilisera la classe java.awt.Point pour représenter

des points):
35
- Dans la classe Figure (Figure sera considérée comme une classe

abstraite) :
Figure(), constructeur vide.
void setColor(Color c), fixe la couleur de l'objet.
String getName().
Color getColor().
void draw(Graphics g), qui dessine l'objet dans g.
boolean contains(int x,int y), vrai ssi l'objet contient le point (x,y).
- Dans la classe Line :

Ligne() et Ligne(int x1, int y1, int x2, int y2), pour les constructeurs.
void setExtremity1(int x,int y),
void setExtremity2(int x,int y),
- Dans la classe Rectangle :

Rectangle() et Rectangle(Point pos,int w,int h).
void setLocation(int x1,int y1), change la position du sommet en
haut à
gauche.
void setDimension(int w, int h), change les dimensions du rectangle.
Point getLocation().
int getWidth().
int getHeight().
- Dans la classe Circle :

Circle() et Circle(int x1,int y1,int r).
void setLocation(int x1,int y1), change la position du centre du
cercle.
void setRayon(int r), change le rayon.
Point getLocation().
int getRayon().
Note:
a)les méthodes draw() et contains() doivent être réécrites dans chacune

des classes Line, Rectangle et Circle pour pouvoir tenir compte des
spécificités et des paramètres de ces figures géométriques.
b) dans un premier temps la méthode contains() de Line retournera

systématiquement false.
Exercice 2: Créer une application TestGraphic, héritant de Frame. Créer

un composant DrawComponent, inscrit dans TestGraphic, qui affiche 3
cercles et un rectangle, dont voici les caractéristiques :
Circle1 x = 200,y = 200,r = 100 ;
36
Circle2 x = 160,y = 150,r = 20 ;

Circle3 x = 240,y = 150,r = 20
et le Rectangle x = 150,y = 220,w = 100, h = 40.
2. Dans ce qui suit nous allons gérer les événements
Exercice 3: Ajouter à la classe TestGraphic la méthode

changeColor(ObjetGraphique o) qui change la couleur de l'objet
graphique o en lui attribuant la couleur suivant la sienne dans
la liste circulaire : ( Color.black, Color.blue , Color.cyan, Color.red,
Color.green, Color.magenta, Color.orange, Color.yellow )
Exercice 4: Modifier l'application TestGraphic pour capturer les

évènements de la souris. Chaque click de l'utilisateur dans l'un des objets
graphiques doit provoquer un changement de couleur de l'objet pointé.
Exercice 5: Créer un dialogue (un dialogue est simplement une classe de

type Dialog qui se manipule comme s'il s'agissait d'une Frame) qui
permette d'entrer des paramètres (couleur, taille) permettant de
construire des lignes, des cercles et des rectangles. Donnez la possibilité
de pouvoir créer directement de telles figures à l'aide de boutons
"Rectangle", "Ligne" et "Cercle". Lorsque vous cliquez sur un de ces
boutons et qu'ensuite vous cliquez sur le DrawComponent, alors une
figure de l'un de ces types est affichée à l'endroit où vous venez de
cliquer.
Exercice 6: Donnez la possibilité de bouger les figures. Pour cela

récupérer la figure dans laquelle vous avez cliqué (méthode contains
définie plus haut). Utilisez ensuite un listener de type
MouseMotionListener qui gère les déplacements de la souris.
3. Indication
3.1 La classe Graphics : cette classe fournit des méthodes permettant de

dessiner dans une fenêtre graphique.
Vous devez importer la librairie awt avec : import java.awt.*;
Voici quelques exemples d'appel de méthodes: soit g une instance de
Graphics :
- pour tracer une ligne reliant les points (x1,y1) et (x2,y2):

g.drawLine(x1,y1,x2,y2);
- pour dessiner un rectangle à la position (x,y) , sommet supérieur

gauche, de largeur w et de hauteur h: g.drawRect(x,y,w,h);
37
- pour dessiner un cercle de centre (X,Y) et de rayon R : g.drawOval(X-R,

Y-R, R*2, R*2);
- pour changer la couleur du prochain dessin : g.setColor(Color.white);

//Color.white est la couleur blanche
3.2 Un cercle (X,Y) de rayon R, contient un point (x,y) ssi : ((x-X)²+(y-

Y)²) <= R²
38

TP 2-BENSLIMANE Heritage, Exception,...

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP 2-BENSLIMANE Heritage, Exception,...

Transféré par

Droits d'auteur :

Formats disponibles

Réalisé par :

1. Les types de base du langage………………………….…..4

2. Principes de la Programmation Orientée Objet………..…..9

3. Les Exceptions Java……………..…………….……….…15

4. Les Packages Java………………………………………...17

6. Les Classes Abstraites…………………………………….22

8. Les Applets Java …………………………………………27

Son API (Application Programming Interface) est très riche : différents

Une des caractéristiques principales de ce langage est que le code Java

Ce langage est un vrai langage de programmation : il intègre tous ce que

Java possède une API (Application Programming Interface) extrêmement

1°/- Les types de base du langage :

Comme beaucoup d'autres langages, Java possède un certain nombre de

déclaration débute en mentionnant le type utilisé pour la (ou les)

Les types numériques

Les types numériques entiers

qu'un bit ne peut prendre que deux valeurs (0 ou 1). En conséquence, n

Un remarque importante : on peut créer un tableau d'élément de

Précédence des opérateurs

Nous venons donc de survoler l'ensemble des opérateurs, ainsi que

Les instructions liées aux boucles

Les instructions conditionnelles et itératives du JAVA sont pratiquement

2°/- Principes de la Programmation Orientée Objet:

Le modèle objet de Java

Définition d'une classe

N.B. : les méthodes System.out.print et System.out.println affichent

On remarque deux choses en regardant ce programme. Un constructeur

Si aucun constructeur n'est spécifié, dans la définition de la classe, un

3°/- Les exceptions Java :

Le mot clé try.

4°/- Les Package Java :

Nous allons, durant ce chapitre, étudier le concept de package. Un

Le mot clé package.

Importer les classes d'un package.

Au niveau de la syntaxe à utiliser pour définir un lien d'héritage, c'est très

6°/- Les Classes Abstraites :

Faire usage de l'abstraction

Mais attention : on ne peut pas définir une méthode abstraite n'importe

7°/- Java Data Base Connectivity :

Structure d'un programme JDBC

- parcours des réponses.

En fait cette instruction construit un objet de la classe Class qui modélise

- enregistrer cette instance au sein du DriverManager par la méthode

Requêtes aux bases de données

8°/- Les applets Java :

Notre première applet Java

Mise en oeuvre de l'applet

Intégration de votre applet dans un document HTML

Le tableau suivant reprend les différents attributs que supporte le tag

9°/- L'API Swing :

userObject, boolean allowsChildren) qui crée un noeud sans parent et

Il existe deux autres classes pour le traitement avancé de

JEditorPane est un traitement de texte pouvant afficher du texte formaté

(Différentes couleurs, polices, souligné, gras, ...).

Traitement d'évènements simples

Maintenant, vous pouvez cliquer sur le bouton. Un message est affiché en

Créer la partie statique d’une interface utilisateur est

TP : Programmation orientée objet en Java

Avec les méthodes (on utilisera la classe java.awt.Point pour représenter

- Dans la classe Figure (Figure sera considérée comme une classe

- Dans la classe Line :

- Dans la classe Rectangle :

- Dans la classe Circle :

a)les méthodes draw() et contains() doivent être réécrites dans chacune