PROGRAMMATION Présenté par :

ORIENTÉE OBJET Pr. Imad EL

KHALDI
AVEC LANGAGE
JAVA
INTRODUCTION À LA
PROGRAMMATION
Partie
1

ORIENTÉE OBJET -
POO-
 La programmation
procédurale
La programmation procédurale
telle que étudiée au travers des
langages C, Pascal… définie un
programme comme étant un
ensemble de données sur
lesquelles agissent des procédures
et des fonctions.

Cette approche a permis de

décomposer les fonctionnalités
d’un programme en procédures qui
s ’ exécutent séquentiellement .
La programmation
procédurale
Dans ce
cas, 1définir un certain nombre de variables
Programm (structures, tableaux…)
2écrire des procédures pour les
er
manipuler sans associer explicitement
les unes aux autres.

Exécut appeler ces procédures dans un ordre décrit

er par le séquençage des instructions et en
leur fournissant les données nécessaires à
l’accomplissement de leurs tâches.
Les inconvénients de la
programmation procédurale
Devant la complexité des applications, cette technique de
programmation présentait quelques inconvénients :

 Cette méthode oblige le développeur à penser de manière

algorithmique.
 Le développeur doit faire un effort supplémentaire pour
structurer le programme.
 Séparation entre les procédures et les données.
 Le code est peu lisible et difficile à modifier, à maintenir
 L’ajout de fonctionnalités difficile
 Réutilisation du code incertaine
 Le travail d’équipe est délicat
Les inconvénients de la
programmation procédurale
Finalement, il est peut-être plus simple de s’inspirer du monde
réel car le monde réel est composé d’objets, d’êtres vivants, de
matière … donc pourquoi ne pas programmer de manière plus
réaliste ?

- Les objets ont des propriétés : Un chat à 4 pattes, un serpent

aucune
- Les objets ont une utilité, une ou plusieurs fonctions :
• Une voiture permet de se déplacer
• Un couteau peut couper
Alors, plutôt que de focaliser sur les procédures, intéressons-
nous d’avantage aux données
De cette analyse est née la programmation orientée
La Programmation Orienté
Objet
Définition:

La POO est une méthode d’implémentation dans laquelle les

programmes sont organisés sous formes de collections
coopératives d’objets, dont chacun représente une instance
d’une classe quelconque et dont toutes les classes sont membres
d’une hiérarchie de classes unis à travers des relations
d’héritage.
La Programmation Orienté
Objet
Qu’est-ce qu’un objet ?

 Un élément qui modélise toute entité, concrète ou abstraite,

manipulée par le logiciel
 Un élément qui réagit à certains messages qu’on lui envoie de
l’extérieur
 Un élément qui ne réagit pas toujours de la même manière

L’objet est l’élément central de la POO

 Programmation procédurale vs
programmation orientée objet

Pour résumer, on peut programmer suivant deux

approches :
Programmation Programmation orientée-
▪
procédurale
Centrée sur les procédures objet:
(traitements) ▪ Les données
Centrée et les
sur les traitements
données
▪ Les données sont séparées des concernant ces données sont
fonctions et procédures qui les regroupés dans des entités
manipulent appelées objets
▪ Lorsqu’on programme, on ▪ Lorsqu’on programme, on
réfléchi aux traitement réfléchi aux objets
▪ Un programme objet est un réseau
d'objets qui communiquent par
l'envoi de messages pour réaliser
un traitement
 Programmation procédurale vs
programmation orientée objet

Programmation Programmation
procédurale orientée-objet:
Données
Obje
t
Obje
t

Fonction
et
procédur
Objet
e
Que doit faire le Sur quoi porte le
programme ? programme ?
Programmation
procédurale
Centrée sur les procédures
▪ Décomposition des fonctionnalités d'un programme en
procédures qui vont s'exécuter séquentiellement
Couplage procédures/données
▪ Les données sont indépendantes des procédures
▪ Les données à traiter sont passées en arguments aux
procédures
Ressemble peu à notre schème de penser
▪ Le programmeur doit faire un effort cognitif pour interpréter
ce qu'il veut modéliser pour être "compris" par la machine.
▪ Peu intuitif lors de l'analyse d'un code existant.
Programmation
procédurale
Tend à générer du code "Spaghetti"
▪ La maintenance et l'ajout de nouvelles fonctionnalités demandent
de modifier ou d'insérer des séquences dans ce qui existe déjà
▪ Peu devenir complexe très rapidement
▪ Modularité et abstraction absente (ou presque)
▪ Réutilisation ardue
▪ Travail d'équipe difficile (peu modulaire), donc la qualité du code
en souffre
 Programmation orientée
objet
Facilité d'organisation
 Réutilisation
 Méthode plus intuitive
 Possibilité d'héritage
 Facilité de correction
 Projets plus faciles à gérer (plus de modularité)
 La programmation objet permet de regrouper les
données et les traitements sur ces données dans une
seule entité appelée Classe
 Programmation orientée
objet
 LA POO est facilement concevable : elle décrit des entités
comme il en existe dans le monde réel.
 Exemple : l'objet Voiture qui implémente la méthode [Link] et
possède la propriété [Link]ée est facilement concevable et
peut être utilisée dans une simulation de course automobile où on
fera interagir plusieurs objets Voiture.
 Les modèles à objets ont été créés pour modéliser le monde réel.
 Dans un modèle à objets, toute entité du monde réel est
un objet, et réciproquement, tout objet représente une
entité du monde réel.
Programmation orientée
objet
 Sécurité : Les informations concernant un domaine étant
centralisées en objets, il est facile de sécuriser le programme en
interdisant ou autorisant l'accès à ces objets aux autres parties du
programme.
 Diviser la complexité : deux types de développeurs, ceux
qui conçoivent les objets et ceux qui utilisent ces objets dans
leurs programmes.
 Partager les tâches : La programmation objet permet d'obtenir
des projets stratifiés. Chaque protagoniste ne travaille que
sur des implémentations le concernant.
Notion d’objet et de
classe
 Un objet est un élément identifiable du monde
réel
Il est concret (une voiture, un stylo) ou
abstrait (une entreprise, le temps).
 Un objet est caractérisé par :
o Ce qu’il est (c'est à dire les données sur lui
même, son état)
o Par ce qu’il sait faire (son comportement)
 Un objet fait partie d'une catégorie d'objets
appelée classe
 La classe est le type de l’objet
Autrement
DIT !
 Un objet est une instance de classe
Un objet est une variable dont le type est sa classe.
Réciproquement, on peut dire qu'une variable est un
objet dont la classe est son type !
 Un objet est un exemplaire d'une classe.
La classe est comme un moule, à partir duquel on
peut faire des gâteaux: les objets.
 Représentation d’une
classe

Pour accéder aux membres (attributs et méthodes) on écrit :

[Link] ou encore
Voiture.démarrer()
Pour distinguer l'accès à un attribut de l'accès à une méthode, on
met toujours des parenthèses après une méthode, même s'il n'y a
aucun paramètre.
Exemple
comparatif!
En En
POO PP
Concepts de base de la
POO
La POO se base sur les notions clés
suivantes :
 Encapsulation
 Abstraction
 Classe et objets
 Héritage
 Polymorphisme
Concepts de base de la
POO
Encapsulation des données:

 C’est le fait de réunir à l'intérieur d'une même entité

(objet) le code (méthodes) + données (champs).

 Il est donc possible de masquer les informations d'un
objet aux autres.
 On dit qu’il y a encapsulation de données et du
comportement des objets.
Concepts de base de la
POO
Encapsulation des données:
On précise trois modes d’accès aux attributs d’un objet.
 Le mode public avec lequel les attributs seront accessibles
directement par l’objet lui-même ou par d’autres objets. Il
s’agit du niveau le plus bas de protection.
 Le mode private avec lequel les attributs de l’objet seront
inaccessibles à partir d’autres objets : seules les méthodes de
l’objet pourront y accéder. Il s’agit du niveau le plus fort de
protection.
 Le mode protected avec lequel les attributs seront
accessibles directement par l’objet lui-même ou par ses objets
descendants (lien d’héritage).
Concepts de base de la
POO
Abstraction:

C’est le faite de se concentrer sur les caractéristiques

importantes d’un objet selon le point de vue de l’observateur.

L’abstraction est un principe qui consiste à ignorer certains

aspects d’un sujets qui ne sont pas importants pour le problème
dans le but de se concentrer sur ceux qui le sont.
Concepts de base de la
POO
Classe et objet:
Avant de créer des objets, il faut définir un modèle et des objets
pourront être crées à partir de ce modèle.
Ce modèle s’appelle une classe et les objets fabriqués à partir
du modèle sont des instances.

Une Classe est composé:

 D’attribut (ou champs, variables d’instances)
ou
structure de ses instances et
(les ils décrivent
objets).
 De méthodes (ou la la classe)décrivant les
opérations de applicables opérations
aux instances de la classe.
Concepts de base de la
POO
Classe et objet:
Exemple
Concepts de base de la
POO
Héritage:
La notion d’héritage est une relation entre différentes classes
permettant de définir une nouvelle classe en se basant sur les
classes existantes.
On parle d’héritage simple lorsqu’une classe fille ne possède
qu’une classe mère.
On parle d’héritage multiple lorsqu’une classe fille possède
plusieurs classes mères.
Concepts de base de la
POO
Héritage:
 Par construction toutes les sous-classes
d’une même classe possèdent toutes les attributs et les
méthodes de leur classe mère.
 Les attributs et les méthodes peuvent être modifiés au niveau

de la sous- classe.
 Il peut y avoir des attributs et/ou des méthodes

supplémentaires dans une sous-classe

Concepts de base de la
POO
Héritage:
Exemple
Concepts de base de la
POO
Polymorphisme:

Le termepolymorphisme issu du grec signifie

la possibilité de prendre plusieurs formes.
Une entité est polymorphe si à l’exécution elle peut se référer à
des instances de classe différentes.
 INTRODUCTION AU
LANGAGE DE Partie

PROGRAMMATION
2

ORIENTÉE OBJET JAVA

Histoire de
JAVA
1. Java est un langage objet ressemblant au langage C++
2. Mis au point en 1991 par la firme Sun Microsystems
3. Le but était de constituer un langage de programmation
pouvant être intégré dans les appareils électroménagers.
4. James Gosling décida de créer un langage orienté objet comme
C++
5. Mais en éliminant les points difficiles de C++, et en le
rendant moins encombrant et plus portable
6. ce langage fut baptisé Java en l'honneur de la boisson
préférée des programmeurs, c'est-à-dire le café java.
Histoire de
JAVA
7. A la même époque, le Web faisait son apparition, or Java
possédait toutes les caractéristiques faisant de lui un langage
approprié pour le Web.
▪ Portabilité : Le réseau mondial comportaient des machines
différentes, alors que Java était conçu pour tourner sur
n’importe quelle machine.
▪ Le web était limité en bande passante: Java était conçu
pour être petit.
Comparaison de java et
C++
1. Java est très proche du langage C++ (ils ont presque la même
syntaxe)
2. Java est plus simple que C++
3. Les caractéristiques critiques du langage C++ (celles qui sont
à l'origine des principales erreurs) ont été supprimées.
• Les pointeurs
• La surcharge d'opérateurs
• L'héritage multiple
• La libération de mémoire est transparente pour l'utilisateur
(grâce à un ramasse-miettes)
• Une meilleure gestion des erreurs
• Les chaines et les tableaux sont désormais des objets faisant
partie intégrante du langage
Comparaison Java et
C++
4. Toutefois Java est beaucoup moins rapide que le langage
C++, il perd en rapidité ce qu'il gagne en portabilité...
Source et
compilation
Compilation d’un programme java : Génération du
byte code
La Machine
virtuelle
byte-code assure la portabilité des
programmes Java
 interprétation VS
compilation
Avec C et Avec
C++ JAVA
Fichie
r
Fichie Sour
r Précompilati
ce
Compilati Sour Pseudoco on
on ce de
Fichier Fichier Fichier (bytecod
compilé compilé compilé e)
sous sous Unix sous Mac VM VM
Exécution Windows OS Windows VM Unix Mac
Systèm Système OS
e Système Mac Exécution
Windo Unix OS Systèm Systè Systè
ws e me me
Windo Unix Mac
ws OS
Notez
bien !
1. Le fichier dont l’extension est .java c’est un simple fichier
texte ouvrable par un éditeur de texte
2. Le byte-code ou pseudo-code ou encore le code
intermédiaire est un fichier dont l’extension est .class
3. Le pseudo-code est généré par le compilateur java
( javac ), il ne dépend pas de la plate forme.
4. La machine virtuelle dépend de la plate forme, elle est
téléchargeable à partir du site oracle, elle permet
d’exécuter le pseudo-code.
5. La machine virtuelle est appelée aussi interpréteur.
Fonctionnement de la machine
virtuelle
1. Chargement :
▪ Chargement sélectif et dynamique des classes
▪ Vérification statique du code

2. Protection lors de l’exécution

▪ Le Security Manager possède un droit de veto (accès sauvage aux système
de fichier … )
▪ Cette protection peut être modulée
 Fonctionnement de la machine
virtuelle
Interprétation (le mode le plus simple) : La JVM interprète le
bytecode : décode une instruction de bytecode à la fois et exécute
l'opération correspondante
Le mode HotSpot :
▪ La JVM traduit les instructions vers le langage machine
▪ Conserver les instructions traduites pour limiter le nombre
d'opérations de traduction.
l'exécution est plus rapide mais nécessite une plus grande
quantité de mémoire
Le mode adaptive compiler: la JVM traduit uniquement les
instructions fréquemment exécutées, utilisant
alternativement les techniques de l’interprétation ou de
HotSpot selon les besoins
 ramasse-
miettes
La machine virtuelle est également
équipée d'un ramasse-miettes (en
anglais : garbage collector) qui permet de
libérer la mémoire qui n'est plus utilisée
par le programme Java.
Son principe :
▪Déterminer quels objets ne peuvent plus être
utilisés par le programme
▪Récupérer l'espace utilisé par ces objets
 en
libérant la mémoire,
C++ cetteet c’esttâche
une action
était quiassurer
était l’origine
par le
de plusieurs erreurs. Illustration d'un ramasse-miette
programmeur en
compactant.
Performance du
java
Exécution d’un programme JAVA
▪Le code java est compact (il n’est pas complétement
compilé)
▪Le chargement des classes nécessaires et sélectif et
dynamique
▪ … . Mais java est interprété -- manque
de rapidité

Remédier au problème de
l’interprétation
Utilisation d’un JIT (compilateur « jus-in-
time »
▪Compilation à la volée du Bytecode
▪Réutilisation du code déjà compilé
 Types de programme
JAVA
Java permet de créer deux types de
programmes :
Les applications indépendantes : programmes tels
qu'on les connaît, c'est-à-dire s'exécutant dans le
système d'exploitation à condition d'avoir installé
une machine virtuelle.
Les applets : petites applications destinées à
fonctionner sur un navigateur.
Les servlets Java: sont exécutés sur le serveur,
permettant de répondre à une requête d'un client
http. elle renvoie une réponse sous la forme
d'une page web dynamique.
 Qu’est ce que le
JDK ?
Le Java Development Kit désigne un ensemble de
bibliothèques logicielles de base du langage de
programmation Java, ainsi que les outils avec lesquels
le code Java peut être compilé, transformé en
bytecode destiné à la machine virtuelle Java.
Qu’est ce que le
JDK ?
JDK : comprend essentiellement :
▪ Javac : le compilateur Java
▪Java : un interpréteur d'applications (machine
virtuelle)
▪Applet viewer : un interpréteur d'applets
▪Jdb : un débogueur
▪ Javap : un décompilateur, pour revenir du
bytecode au code source
▪Javadoc : un générateur de documentation
▪jar: l'éditeur d'archives Java
Ou se procurer
JDK ?
Le JDK est disponible gratuitement en téléchargement
sur le site de la société Oracle :
Java SE Downloads
Les Outils
JDK :
• Le compilateur
• L’interpréteur
• L’interpréteur
d’applet
• Javadoc
• L’éditeur d’archive
•…
Les Outils
JDK :
• Le compilateur Le compilateur javac
transforme le code source en
• L’interpréteur bytecode, un fichier
• L’interpréteur d’extension .class intermédiaire
interprétable par la machine
d’applet virtuelle sur n'importe quelle
• Javadoc plate-forme.
• L’éditeur d’archive Sous ligne de commande on
utilise la syntaxe suivante :
•… Javac <option><[Link]>
Les Outils
JDK :
• Le compilateur L'interpréteur java est la
machine virtuelle
• L’interpréteur permettant de lire le
• L’interpréteur bytecode.
d’applet Sous ligne de commande on
utilise la syntaxe suivante :
• Javadoc
Java <Nom du fichier sans
• L’éditeur d’archive extension >

•…
Les Outils
JDK :
• Le compilateur
• L’interpréteur Appletviewer a pour but de
pouvoir visualiser
• L’interpréteur l'exécution d'un applet (il
d’applet est aussi possible de la
visualiser sur la plupart des
• Javadoc navigateurs internet.
• L’éditeur d’archive
•…
Les Outils
JDK :
• Le compilateur JavaDoc est un utilitaire permettant
de créer une documentation au
• L’interpréteur format HTML à partir de vos
• L’interpréteur programmes, grâce aux
commentaires / * * / prévus à
d’applet cet effet, et qui sont à
• Javadoc incorporer dans le code.
• L’éditeur d’archive
•…
Les de Outils
JDK :
• Le compilateur Jar permet de compresser toutes
les classes d'un même projet
• L’interpréteur dans une archive (un fichier zip
• L’interpréteur avec l'extension
.jar) pour constituer une
d’applet bibliothèque de classes que
• Javadoc l'on peut ensuite
importer comme bibliothèque
• L’éditeur d’archive externe à un autre projet .
•…
Et la liste n’est pas
exhaustive !!
Les outils
JDK

JRE
( L'environnement
d'exécution
Java), est une famille
de logiciels perm
qui
l'exécution et des
programmes écrits en
Java , sur différentes
plateformes
Compilation et
exécution
On a deux choix :
▪Compiler et exécuter en utilisant les
lignes de code
installer JDK
▪Utiliser un IDE comme Eclipse
installer JRE et Eclipse
Environnement de développement
intégré
Nombreux sont les IDE (Integrated Development
Environment) pour JAVA
▪Editeur de texte, compilateur, débogueur, exécution
JAVA
aujourd’hui
Maturité certaine
▪Technologie largement reconnue dans le monde industriel
Evolutions de JAVA contrôlées par organisation
indépendante Java Community Process ([Link])
▪Évolutions du langage
▪Nouvelles API
Passage de Java dans la communauté open source (2007)
 OpenJDK
Bataille avec C# .NET sur la plateforme Windows
Rachat de SUN par Oracle (avril 2009)
 Retene
•zLa
! JVM est le cœur de Java, elle fait fonctionner vos programmes Java,
précompilés en byte code.
• Les fichiers contenant le code source de vos programmes ont l’extension
.java.
• Les fichiers précompilés ont l’extension .class
• Le byte code est un code intermédiaire entre celui de votre
programme et celui que votre machine peut comprendre.
• Un programme Java, codé sous Windows, peut être précompilé sous
Mac et enfin exécuté sous Linux.
• Votre machine ne peut pas comprendre le byte code, elle a besoin
de la JVM.
INITIATION EN Partie
3

LANGAGE JAVA
Installation et
présentation
1. Installation du JDK
2. Installation d’Eclipse
3. Présentation rapide de
l’interface Eclipse
Création d’un nouveau
projet java

Cliquez sur
finish
 Création d’un nouveau
projet java

Cliquez sur
restore
Création d’une
classe
Une classe est un ensemble de
codes contenant plusieurs
instructions que doit effectuer
votre programme. ( on va
détailler cette notion plus loin)

Saisir le nom Cochez cette

de la classe option
Cliquez sur ex : prog
Class
 Création d’une
classe

exécuter le
code

écrire le
code
Voir
l’exécution
Pour gérer les
projets
Structure d’un programme
JAVA
• Toutes les applications JAVA sont composés d’au moins une classe
spécifique
• Le nom de cette classe correspond au nom de l’application
(prog dans notre cas)
• Cette classe doit contenir une méthode (fonction) appelé
main()
• La méthode main() sera le point de démarrage de notre
programme
• Dans cette partie on va travailler qu’avec une seule classe
Classe crée

Méthode
main
Premier Code : Hello
Word
On place le code entre les deux accolades de la
méthode main()

public class Prog

{

public static void main(String[] args)

{
/* Code à insérer */
Comme en langage C : le
}
} commentaire et entre deux / /
ou deux / * */ s’il comprend
plusieurs lignes
Premier Code : Hello
Word
On place le code entre les deux accolades de la
méthode main()
public class Prog
{
public static void main(String[] args)
{
[Link]("Hello Word");
}
}
On exécute le programme en cliquant sur :

Sur la console on visualise le résultat :

 [Link]( "")
System : C’est une classe utilitaire qui permet d’utiliser l’entrée et la
sortie standard. out : objet de la classe System qui gère la sortie
standard.
print : méthode qui écrit dans la console le texte passé en paramètre.
Exemple :
[Link]( "")
Pour forcer un retour à la ligne on
:
▪ Utilise le caractère
Ex [Link]("Hello Word\n");
d’échappement
:
▪ On
« \ nutilise
» la méthode println()
Ex : [Link]("Hello Word");

Pour afficher un guillemet double ou

apostrophe dans la sortie standard, vous
devrez « l'échapper » avec un \
Ex : [Link]("Coucou mon \"chou\" !
");
Compilation en ligne de
code
1. Installez JDK
2. Ouvrez le dossier JDK situé dans le dossier Programmes
3. Ouvrez le dossier bin
4. Copiez le chemin d’accès
5. Rendez-vous sur « Panneau de configuration »  « Système »  «
paramètres système avancés »  « Variables d’environnement »
6. La boite « variables d’environnement » s’affiche dans la liste « variables
système » cliquez sur la variable Path , une fois sélectionnée, cliquez sur «
Modifier »
7. Une petite boîte s’affiche, qui contient le nom de la variable et sa
valeur
8. Allez jusqu’au bout de la valeur , ajoutez-y un point-virgule ( ; ) s’il n’y en a
pas, et ajoutez alors le chemin d’accès au répertoire bin de votre JDK, en
terminant celui-ci par un point- virgule
9. Valider les modification, désormais vous pouvez compiler et exécuter
en ligne de commande.
Compilation en ligne de
code
Dém
o!
Variable en
java
Une variable est un objet repéré par son nom, pouvant
contenir des données, qui pourront être modifiées
Les variables en langage Java sont typées
les noms de variables peuvent être aussi long , toutefois le
compilateur ne tiendra compte que des 247 premiers
caractères,
Les variables doivent répondre à certains critères:
▪un nom de variable doit commencer par une lettre (majuscule ou
minuscule) ou un "_" (pas par un chiffre)
▪un nom de variables peut comporter seulement des
lettres, des chiffres et le caractère _
▪Les noms de variables ne peuvent pas être les noms suivants (qui
sont des noms réservés)
 mots
réservés

Parmi les mots interdits pour les identificateurs, il faut ajouter les
booléens
false et true ainsi que null .
Déclaration d’une
variable
Une variable se déclare de la façon suivante:
type Nom_de_la_variable;

ou bien s'il y a plusieurs variables du même type:

type Nom_de_la_variable1, Nom_de_la_variable2, ...;

Java impose que les variables soient

impérativement déclarées.
Java permet de définir une variable à n'importe quel
endroit du code, afin de le rendre plus lisible.
 Déclaration d’une
constante
final int REPONSE = 42;

Il s'agit là d'une utilisation restrictive du mot clé final, car

celui-ci permet d'affecter une valeur différente à chaque
exécution du programme, tout en garantissant que la
variable, une fois initialisée avec une valeur, ne subira plus
aucune modification.
Afficher le contenu d’une
variable
Afficher une variable :
[Link](Nom_variable);
Afficher une variable concaténée avec une chaine de
caractère :
[Link](Nom_variable+"Chaine de caractère");
Types de données et
opérateurs
Il existe deux types de données en java :
des données de type simple ou primitif
des données de type complexe ou des objets

Les types de données complexe sont appelés également

enveloppeur ou Wrapper, ils ont été introduit pour
satisfaire la philosophie de l’orienté objet : puisque tout
les élément manipulés par JAVA sont des classes .
Types de données
(primitifs)
Primitive Signification Taille Plage de valeurs acceptée
valeur du jeu de caractères Unicode (65000
char Caractère 2
caractères possibles)
byte Entier très 1 -128 à 127
court
short Entier court 2 -32768 à 32767
int Entier 4 -2 147 483 648 à 2 147 483 647

long Entier long 8 -9223372036854775808 à

9223372036854775807
float flottant (réel) 4 -1.4*10-45 à 3.4*1038
double flottant double 8 4.9*10-324 à 1.7*10308
0 ou 1 (en réalité, toute
boolean booléen 1
autre valeur que 0 est
considérée égale à 1)
Exemples de déclaration et
d’initiation
byte temperature;
byte temperature;
temperature = 32000 ;
int
temperatureSoleil =
15600000 ;
long anneeLumiere;
Float pi=3.141592653f //faites attention au point et au f à la fin
anneeLumiere =
double division; ;
9460700000000000
division=0.333333333333333333333333333333333333333333334;
char caractere; caractere = ‘A’
boolean question; question = true ;
Déclaration d’une chaine de
caractères
Le type chaine de caractère n’est pas un type primitif c’est un type
complexe (une classe : possède des attributs et des méthode)
La syntaxe :
String phrase ;
phrase="bonjour";
String str=new String();
str="tout le monde"
String chaine="ma
chaine" ;
String Ch=new
String("C\’est une
chaine");

Attention ! String commence

Conversion des types de donnée
(casting)
le fait de modifier le type d'une donnée en
une autre Ex : float X=12.354f
int i; i=X  génère une erreur  il faut
faire la conversion
i = (int)X
A savoir :
Conversion implicite : effectuée par le
compilateur Ex: int x; x=8.254 on aura 8
dans X
Conversion explicite (obligatoire) : une modification du type
de donnée forcée à l’aide d’un opérateur de cast
EX : float f=64.12f; char C =(char)f;
Convertir en chaine de
caractère
Examinons le code
suivant :
int i=12154;
String j=new String() ;
j=[Link](i);

Commentaire : on a
transformé une valeur
entière en chaine de
caractère en utilisant la
méthode valueOf() de la
classe string
Les
opérateurs
1. Les opérateurs de calcul
2. Les opérateurs
d’assignation
3. Les opérateurs
d’incrémentation
4. Les opérateurs de
comparaison
5. Les opérateurs logiques
6. Les opérateurs bit à bit
7. Les opérateurs de
rotation de bit
Les opérateurs de
calcul
Résultat (avec
Opérateur Dénomination Effet Exemple
x
valant 7)
+ opérateur Ajoute deux x+3 10
d'addition valeurs
opérateur de
- Soustrait deux x-3 4
soustraction
valeurs
opérateur de
* Multiplie deux x*3 21
multiplication
valeurs
plus: opérateur
/ Divise deux x/3 2.3333333
de
valeurs
division
opérateur Affecte une Met la valeur 3
= x=3
d'affectation valeur à dans la
une variable variable x
Les opérateurs
d’assignation
Opérateurs Effets
addition deux valeurs et stocke le résultat
+=
dans la
variable (à gauche)
soustrait deux valeurs et stocke le résultat
-=
dans la
variable
multiplie deux valeurs et stocke le résultat
*=
dans la
variable
divise deux valeurs et stocke le résultat dans
/=
la
variable
Les opérateurs
d’incrémentation

Résultat (avec
Opérateur Dénomination Effet Syntaxe
x
valant 7)
Augmente d'une unité
++ Incrémentation x++ 8
la
variable
Diminue d'une unité
-- Décrémentation x-- 6
la
variable
 Les opérateurs de
comparaison
Opérateur Dénomination Effet Exempl Résultat
e
opérate Compare deux valeurs et Retourne Truesi X est
== x==3
ur vérifie leur égal à 3, sinon
d'égalit égalité False
é
opérateur Vérifie qu'une variable Retourne Truesi X est
< x<3
d'infériorité est strictement inférieure inférieur à 3,
stricte à une valeur sinon False
opérateu Vérifie qu'une variable Retourne Truesi X est
<= x<=3
r est inférieure ou égale à inférieur ou égal à
d'inférior une valeur 3, sinonFalse
ité
opérateur Vérifie qu'une variable est Retourne Truesi X est
> x>3
de strictement supérieure à supérieur à 3,
supériorité une valeur sinon False
stricte
opérateur Vérifie qu'une variable Retourne Truesi X est
>= x>=3
Les opérateurs
logiques
Opérateur Dénomination Effet Syntaxe
Vérifie qu'une des ((condition1)||
|| OU logique
conditions est (conditio
réalisée n2))
Vérifie que toutes les ((condition1)&&(con
&& ET logique
conditions sont ditio n2))
réalisées

Inverse l'état d'une variable

booléenne (retourne la
! NON logique (!condition)
valeur True si la variable
vaut False, False si elle vaut
True)
Les opérateurs bit-
à-bit
Opérateur Dénomination Effet Syntaxe Résultat
Retourne 1 si les deux 9 & 12 (1001
& ET bit-à-bit 8 (1000)
bits de même &
poids sont à 1 1100)

Retourne 1 si l'un ou
9 | 12 (1001
| OU inclusif l'autre des deux bits de 13 (1101)
|
même poids est à 1 (ou
1100)
les deux)

Retourne 1 si l'un des

9 ^ 12 (1001
^ OU exclusif deux bits de même poids 5 (0101)
^
est à 1 (mais pas les
1100)
deux)
 Les opérateurs de rotation
de Dénomination
Opérate
bit Effet Syntaxe Résultat
ur
Décale les bits vers la gauche (multiplie
<< Rotation à par 2 à chaque décalage). Les bits 6 << 1 (110 << 12
gauche qui sortent à gauche sont perdus, 1) (1100)
tandis que des zéros sont insérés à
droite
Décale les bits vers la droite (divise
Rotation à
par 2 à chaque décalage). Les bits
>> droite avec 6 >> 1 (0110 3 (0011)
qui sortent à droite sont perdus,
conservation >> 1)
tandis que le bit non-nul de poids
du signe
plus fort est recopié à gauche
Décale les bits vers la droite (divise
Rotation à
par 2 à chaque décalage). Les zéros 3 >>> 1 (0011
>>> droite avec 1 (0001)
>>>
remplissage de qui sortent à droite sont perdus,
tandis que des zéros sont insérés à 1)
zéros
gauche
 Lire les entrées
clavier
• On va utiliser une classe nommée Scanner
• Il faut au début l’importer en tapant la code import
[Link]; en haut
• Nb : pour importer
Instancier untoutes
objetles Scanner
classes du package
: SC util on écrit
= new :import [Link].*
Scanner([Link]);
Scanner
int D = [Link]();
• On
// récupère
désormais lela valeur
valeur tapéesaisie en dans
se trouve la variable D
écrivant :
 Lire les entrées
clavier
La méthode nextInt() pour
récupérer une valeur entière,
toutefois il existe pour
chaque type une méthode.
Pour récupérer une
chaine de caractère on
utilise nextLine()
Lire les entrées
claviers
il y a un type de variables primitives qui n’est pas pris en
compte par la classe Scanner : il s’agit du type char.
Pas de nextChar()
Voici comment on pourra récupérer un caractère :
[Link]("Saisissez une lettre : ");
Scanner sc = new Scanner([Link]);
String str = [Link](); // on a récupéré la chaine saisie
char carac = [Link](0); // on a récupéré le premier caractère
 Les structure « if » «
else »
Comme en langage C, l’alternative double s’exprime ainsi :

if (//condition)
{ ... //Exécution des instructions si la condition est
remplie } else
{... //Exécution des instructions si la condition n'est pas
remplie }
 Imbrication des «
if »
L’imbrication des
ifif: (//condition1)
{ ... //Exécution des instructions si la condition 1 est remplie }
else if (//condition2)
{ ... //Exécution des instructions si la condition 1 est remplie }
else if (//condition3)
{ ... //Exécution des instructions si la condition 1 est remplie }
/. . ./

else
{... //Exécution des instructions si les conditions ne sont pas remplies }
Imbrication des «
if »
Exemple
:
int
if i
(i=<0;
0)
[Link]("Ce nombre est négatif !");
else if (i > 0)
[Link]("Ce nombre est positif !");
else
[Link]("Ce nombre est nul !");
Condition
ternaire
Exemple 1:
int x = 10, y = 20;
int max = (x < y) ? y : x ; //Maintenant, max vaut 20

Exemple 2:
int x = 10, y = 20;
int max = (x < y) ? y * 2 : x * 2 ; //Ici, max vaut 2 * 20 donc
40
La structure
switch
Switch (<variable>)
{
case <val1> : <trait 1> ; break ;
case <val2> : <trait 2> ; break ;
/ . . . /
case <valn> : <trait n> ; break ;
default : <trait par défaut >
}
 « Switch »
imbriquée
switch (<variable 1>)
{
case <val1> : <trait 1> ; break ;
case <val2> :
Switch (<variable 2>);
{
case <val1> : <sous-trait 1>; break; Switch
case <val2> : <sous-trait 2>; break imbriqu
ée
;default : <sous-trait par défaut >
}/ . . . /
break ;
case <val3> : <trait 3> ; break ;
/ . . . /
case <valn> : <trait n> ; break ;
default : <trait par défaut >
}
La structure «
While »
while(<condition>)
{
<instructions>
}

Exemple :

int i = 1 ; // initialisation du compteur

while (i <= 5)
{
[Link](i) ;
i++;
}
La structure « do …
while »
Do
{
<instructions>
}
while(<condition >) ; // n’oublier pas ;

 la condition est évaluée après chaque passage dans

la boucle.
 On exécute le corps de la boucle tant que la
condition est vérifiée.
 La boucle « do... while » s'exécutera au moins
une fois
La boucle «
For »
For (<initialisation>;<condition>;<pas>)
{
<instructions>
}
La boucle «
For »
Exemple :
for (int i=1;i<=5 ;i++)
{ [Link](i) ; }
Exemple:
For (int i=0,j=2; (i<10 && j<6); i++,j+=2)
{[Link]("i = " + i + ", j = " + j);}
lorsque on a qu'une instruction dans notre boucle, on peut
enlever les accolades, car elles deviennent superflues, tout
comme pour les instructions if, else if ou else.
 Tableaux : tableaux à une
dimension
Déclaration d’un tableau avec valeur initiales :
<type du tableau> <nom du tableau>[] = {<contenu du tableau>};

int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};

char tableauCaractere[]={'a','b','c','d','e','f','g'};
String tableauChaine[]={"chaine1","chaine2","chaine3", "chaine4"};

Déclaration d’un tableau vide:

int tableEntier[] = new int[6]; //Ou encore
int[] tableEntier2 = new int[6];
Accès aux
éléments :
Pour accéder au premier élément :
tableEntier[0] Pour accéder au deuxième
élément : tableEntier[1] Pour accéder au
troisième élément : tableEntier[2]
Pour accéder au nième
.. tableEntier[n-1]
élément :
un tableau contenant N éléments aura comme indices
possibles 0, 1, 2 ou 3 … . N-1 .
 Afficher les éléments d’un
tableau
char tableauCaractere[]={'a','b','c','d','e','f','g'};
for(int i = 0; i < [Link]; i++)
{ [Link]("A l'emplacement " + i +" du tableau
nous avons = "+ tableauCaractere[i]); }
A l’exécution on aura:
 Nouvelle syntaxe
(JDK1.5)
String tab[] = {"toto", "titi", "tutu", "tete", "tata"};

for(int i=0; i<[Link];i++) for(String str : tab)

{ [Link](str);
[Link](tab[i]);
}

On peut utiliser cette

syntaxe pour plusieurs types
de tableaux
Tableau : tableau à deux
dimensions
Déclarations :
int premiersNombres[][]={{0,2,4,6,8},{1,3,5,7,9}};

int Table[][]= new int[6][6];

Travaux
pratiques
o Ecrire un code qui permet de calculer et afficher le factoriel d’un
nombre introduit par le clavier.
o Ecrire un code demandant a l'utilisateur de saisir dix valeurs
numériques puis de saisir une valeur N. Il affichera ensuite le
nombre de valeurs strictement supérieures a N.
Par exemple, si l'utilisateur saisit 4, 19, 3, -2, 8, 0, 2, 10, 34, 7 puis 3,
alors le nombre de valeurs strictement supérieures à 3 parmi les 10
premières saisies est 6 (4; 19; 8; 10; 34 et 7).
o Ecrire un code permettant de trier un tableau de valeurs entières
par ordre croissant.
 Les méthodes de
oclasse
Méthode en POO  Fonction en Programmation
procédurale
o Exemple:
L’appel de la fonction
somme()

Méthode main()

Méthode
somme()
Méthode de
classe Nom de la
méthode

Argument de la
méthode

Variable
locale

Valeur retournée par la

fonction
 Méthode de
classe
o Les méthodes qui ne renvoient rien. Les méthodes
de ce type n'ont pas d'instruction return , et elles sont
de type void
o Les méthodes qui retournent des types primitifs (double,
int. . .). Elles sont de type double, int, char . . . Celles-ci
possèdent une instruction return ;
o Les méthodes qui retournent des objets. Par exemple, une
méthode qui retourne un objet de type String. Celles-ci aussi
comportent une instruction return.
o les méthodes ajoutées après main doivent être déclarées
static
La surcharge des
méthodes
o La surcharge de méthode consiste à donner le même
nom à des méthodes comportant des paramètres
différents (en type et/ ou en nombre) .
o En effet, une méthode est déterminé par ce que
l'on appelle sa signature, c'est-à-dire:
o Son nom
o Ses paramètres
La surcharge des
méthodes

Arguments
différents
La surcharge des
méthodes

La machine
virtuelle va
invoqué la première
méthode puisque
le paramètre passé
lors de l’appel et
de « type String »
Travaux
dirigés
Ecrire des méthodes ayant le même nom et qui
permettent de saisir les éléments d’un tableau de
type :
▪int
▪char
▪String
▪byte
 Des méthodes concernant les
chaînes de caractères
toLowerCase() : Cette méthode permet de transformer tout caractère
alphabétique en son équivalent minuscule.
toUpperCase() : Elle transforme une chaîne de caractères en capitales,
et s'utilise comme suit :

length() : renvoie la longueur d'une chaîne de caractères (en comptant

les espaces).
 Des méthodes concernant les
chaînes de caractères
equals() : Cette méthode permet de vérifier (donc de tester) si
deux chaînes de caractères sont identiques, elle renvoie une valeur
booléenne.
 Des méthodes concernant les
chaînes de caractères
substring() : extrait une partie d'une chaîne de caractères. Elle prend
deux entiers en arguments : le premier définit le premier caractère (inclus) de
la sous-chaîne à extraire, le second correspond au dernier caractère (exclu) à
extraire.
Des méthodes concernant les
chaînes de caractères
indexOf() : explore une chaîne de caractères à la recherche d'une
suite donnée de caractères, et renvoie la position (ou l'index) de la sous-
chaîne passée en argument.
Des méthodes concernant les
mathématiques
Toutes ces méthodes
retournent un nombre de
type double.
CLASSE ET Partie
4

OBJETS
Syntaxe de déclaration d’une
classe
public class Nom_de_la_classe
{
type1 p1; //
propriété p1 type2 p2;
//
propriété
type3 p2
m3(…){ // méthode m3
…
}
type4 m4(…){ // méthode m4
…
}
…
}
Structure de base d’une
classe
o Une classe peut être comparée à un moule qui, lorsque nous le
remplissons, nous donne un objet ayant la forme du moule ainsi
que toutes ses caractéristiques .
o Créons une nouvelle classe
o Nommons cette classe Ville
o Le nom de la classe doit impérativement
commencé par une majuscule
o On aura le résultat suivant
 Structure d’une
classe
Notre classe Ville est précédé par le mot
public qui détermine la portée de la classe
public : cela signifie que tout le monde
peut faire appel à l'élément
Définissant les données (variables
d’instance) qu’on va attribuer à la
classe Ville :
▪un nom : chaîne de caractères
▪un nombre d'habitants : un entier
▪un pays apparenté : une chaîne de
caractères
Variables d’instances
Explorer les
classes
 Constructeu
o
r?
Pour créer un objet, nous devons utiliser ce qu'on
appelle un constructeur
o Un constructeur est une méthode d'instance qui se
charge de créer un objet et éventuellement initialiser ses
variables de classe
o il a pour rôle de signaler à la JVM qu'il faut réserver de
la mémoire pour notre futur objet et toutes ses variables.
o Un constructeur par défaut n’est pas paramétré,
Aucun mais
permet comme même d’instancier les objets
arguments
Constructe
ur?
o Un constructeur est une méthode qui n'a aucun
type de retour (void, double, . . .)
o Porte le même nom de la classe
o Un objet peut avoir plusieurs constructeurs
o Un constructeur peut avoir des arguments (Constructeur
avec arguments)
o Si la classe ne possède pas un constructeur, un constructeur
par défaut est défini par La JVM
 Instanciation d’un objet : appel du
constructeur

Instanciation ou création
de l’objet
Instanciation d’un objet : appel du
constructeur

Ou
bien
Taounat
e

Création Ville
Création
d’une d’un objet
référence Ville
vers l’objet
Constructeur avec
arguments

o A savoir, un objet peut avoir plusieurs constructeurs. Il s'agit de la

même méthode, mais surchargée !
o Pour instancier un objet (créer) avec des arguments :
Surcharge des
constructeurs
Accessibilité aux variables
d’instance
Pour accéder aux variables d’instance
d’un objet on utilise le point
Dans notre exemple :

L’accès aux données membres (variables

d’instance) est possible, s’elles sont
déclarées publiques
Accessibilité aux variables
d’instance
La plupart du temps, Il faut Protéger les variables
d’instance  pour qu’un code extérieur ne fasse pas
n’importe quoi avec nos objet !
Pour cela on doit les déclarer private
Dans notre exemple :

Désormais , seulement les méthodes membres peuvent

accéder aux variables d’instance
Encapsulati
on
o Les variables protégées ne sont accessibles que par les
méthodes de la classe (accesseurs et mutateurs)
o On s'assure que le fonctionnement interne à l'objet est
intègre, car toute modification d'une donnée de
l'objet est maîtrisée.
o On souhaite que des méthodes restent internes.
Encapsulati
on
Un attribut public est accessible par toute
public
fonction définie ou non au sein de la classe.

Un attribut privé (private) n'est accessible que par

privé
les seules méthodes internes de la classe.

Un champ protégé (protected) n'est accessible que

protégé par les seules méthodes internes de la classe ou
d'un objet dérivé.
Accesseurs et
mutateur
o Un accesseur est une méthode qui va nous
permettre d'accéder aux variables de nos objets
en lecture
o Un mutateur nous permettra d'en faire de même en
écriture
o Grâce aux accesseurs, vous pourrez afficher les
variables de vos objets, et grâce aux mutateurs,
vous pourrez les modifier
• On les a déclarées public, pour qu’on
puisse y accéder à traves une autre
classe ( par exemple Ma_classe)
• Les mutateurs et les accesseurs
sont des simples méthodes. Les
préfixes « get » et
« set » sont des conventions de
nommage non obligatoires
Méthodes de
classe
o Les mutateurs et les accesseurs sont des méthodes de
classe
o On peut créer à volonté des méthodes autant qu’on
aurais besoin
o Exemple :
 L’opérateur «
othis »
Le mot clé this permet de désigner l'objet dans lequel on se
trouve
o lorsque l'on désire faire référence dans une fonction membre à
l'objet dans lequel elle se trouve, on utilise this.
o L'objet courant this est en réalité une variable système
qui permet de désigner l'objet courant.
o Cette variable est passée en tant que paramètre caché de
chaque fonction membre.
L’opérateur «
this » l'on désire accéder à une donnée membre d'un objet à partir
Ainsi, lorsque
d'une fonction membre du même objet, il suffit de faire précéder le nom de
la donnée membre par this . Par exemple :

En réalité, lorsque l'on donne des noms différents aux données membres et
aux variables utilisées dans les fonctions membres, la variable this est
implicite, cela signifie que l'on est pas obligé de mettre this. devant chaque
donnée membre.
L’opérateur «
this »
On peut utiliser l’opérateur this paramétré à l’intérieur d’un
constructeur
pour appeler un autre constructeur :
Variable de
classe
o Il s’agit d’une variable commune entre tous les objets
d’une classe
o Une seule copie existe
o Une variable de classe doit être précédé par le mot clé
static
Exemple :

o Pour accéder à la variable : <nom_objet>.<nom_variable_classe> ou bien

<nom_classe>.<nom_varibla_classe>
o Dans notre exemple : [Link] ou bien
[Link]
o On peut utiliser ce genre de variable pour connaitre le nombre d’instance
Méthodes de
classe
o On peut déclarer une méthode de classe (méthodes statiques)
o Une telle méthode appartient à la classe et il ne faut donc pas
créer d'instances pour accéder à ces méthodes
o la méthode abs de la classe Math qui permet de récupérer la valeur
absolue d'un nombre
o Une méthode de classe ne peut pas en aucun cas accéder aux variables
d'instances qui appartiennent aux instances de la classe.
Exemple
d’utilisation
o On va écrire une méthode statique qui retourne le nombre de
ville créer :
o On déclare d’abord une variable de classe :
o La variable NbrVille sera incrémentée à l’intérieur des
constructeurs :

o La méthode statique retournant le nombre de

villes créees
HÉRITA Partie
5

GE
L’hérita
ge
o Le concept d'héritage est un des concepts les plus importants de la
programmation orientée objet
o Il s’agit d’un mécanisme permettant de créer une nouvelle classe à
partir d'une classe existante en lui offrant ses propriétés et ses
méthodes.
o Ainsi, pourdéfinir une nouvelle classe, il suffit
de la faire hériter d'une classe existante et de lui
ajouter de nouvelles propriétés/méthodes.
o les classes héritées forment une hiérarchie descendante, au sommet de
laquelle se situe la classe de base (superclasse).
o On appelle également la classe héritée la sous-classe et la classe
parente la super- classe.
L’hérita
ge
Anim
al
Herbivore Carnivor Omnivor
e e
Lapin Lio Ours
n
Cheval tigre
 L’hérita
ge
o Une classe donnée ne peut posséder qu'une seule superclasse,
mais elle peut posséder un nombre illimité de sous-classes
o Lors de l'instanciation d'une classe, celle-ci hérite de l'ensemble des
propriétés et des méthodes de sa superclasse, qui elle-même hérite
d'une éventuelle superclasse, etc.
o Le programmeur doit concevoir une hiérarchie de classe de telles
façon que les propriétés et méthodes communes à plusieurs classes
soient placées dans une superclasse.
o Grâce à ce système organisationnel, il est aisé de réutiliser des
composants existants et de leur ajouter un comportement.
o la modification de la superclasse implique la modification automatique
de toutes les sous-classes.
Synta
xe
Continuons sur notre exemple :
Créons une classe Capitale qui va hériter de la classe Ville
La classe Capital va avoir les mêmes attributs et
méthodes que Ville

Le mot extends informera java que la classe Capitale est hérité de la

classe Ville
 Tester Ce
code !

Remarquez que l’objet cap utilise la

méthode decriToi() de la classe
Ville l’objet cap possède les
propriétés de l’objet Ville

On n’a pas spécifier un constructeur pour la classe Capital, lors de

l’instanciation c’est le constructeur de la classe Ville qui sera appelé
Le mot «
Protected
o
»
Règle : à l’intérieur d’une classe héritée on peut pas accéder aux
attributs de la classe mère s’ils sont déclarés private
o Les attributs doivent être précédés du mot protected ou
public
o La diff érence :
o public toutes classes peuvent y accéder
o protected : seulement les classe héritées peuvent accéder
o Dans notre exemple, il faut changer la portée des variables :
 Java et héritage
omultiple ! à C++ Java ne gère pas les
Contrairement
héritage multiple
o Une classe dérivée ne peut hériter que d'une seule
classe mère
o On aurai jamais ce genre d’exemple:

o Raison simple : si les deux classes mères : Ville et Zone ont toutes les
deux un méthode decrisToi() , lors de l’appel via l’objet Capital,
le JVM ne saura pas qu’elle méthode utiliser ???  Le
programmeur doit gérer ce cas d’erreur.
Mot clef
super
o Nous pouvons faire appel aux membre de la classe mère dans nos
constructeurs grâce au mot clé super
o Cela aura pour effet de récupérer les éléments de l'objet de base, et de
les envoyer à notre objet hérité.

o super() appelle le constructeur par défaut de la classe mère (Ville dans notre
cas) dans le constructeur de la classe fille (Capitale)
Super avec
paramètres
Exempl
e:

o Nous avons appelé le constructeur avec arguments de la classe mère

o Attention ! Super ne doit pas être précédé par des lignes de code.
o Super est similaire à this, this pointe sur l’objet courant et super
pointe sur la classe mère.
 Polymorphis
o
me
Le polymorphisme signifie "plusieurs formes", et il se produit lorsque nous avons
de nombreuses classes qui sont liées les unes aux autres par héritage.

o Comme nous l'avons précisé précédemment, L'héritage nous permet

d'hériter des attributs et des méthodes d'une autre classe. Le polymorphisme
utilise ces méthodes pour effectuer différentes tâches. Cela nous permet
d'effectuer une même action de différentes manières.
 Polymorphis
o
me
Un des concepts fondamentaux de la programmation
orientée objet
o Consiste à redéfinir une méthode d’une classe mère dans une
classe fille

Classe mère : Classe fille :

Ville Capitale
Fonction polymorphe

o Si vous ne redéfinissez pas la méthode d'une classe mère dans une classe
fille à l'appel de celle-ci avec un objet fille, c'est la méthode de la classe
mère qui sera invoquée
Polymorphisme vs
surcharge
La surcharge : Les méthodes surchargée ont le même nom mais des
signatures différentes (Overload)  différence de signature

Le polymorphisme : Les méthodes ont le même nom et la même

signature mais chacune est définies différemment dans les
classes mères et les classes filles.
(Override)  différence de comportement
 Transtypage des
oréférences
Covariance des variables :
signifie qu'une variable objet peut pointer vers
un objet qui hérite du type de cette variable

o Dans notre cas, un objet de type Ville peut contenir un objet de

type Capitale.
o Attention : supposant une méthode propre à la classe Capitale

o La syntaxe suivante engendre une erreur :

o puisque rabat et de type Ville, et Ville ne possède pas une
méthode getMon()
o Dans ce cas il faut faire un transtypage de références
Le mot clé :
final
Variable « final » : une variable déclarée final ne peut plus
voir sa valeur modifiée
ex : final int x=1;
Méthode « final » : Les méthodes « final » ne peuvent pas être
redéfinies dans les classes dérivés
ex : public String DecrisToi() {/* .. */}
final
Classe « final » : une classe final ne peut pas être étendue pour
créer des sous classes
PAQUE Partie
6

TAGE
QU’EST CE
QU’UN
o Un package est un regroupement de classes ayant une
PACKAGE ? fonctionnalité communes
thématique et des
o Un package peut contenir des sous-packages.
o Exemple : pour utiliser la classe Vector du package :
[Link] on écris :
import [Link] au tout début du
programme.
Pour utiliser toutes les classes du package [Link] on
écris :
imort [Link].*
o D ’une manière générale : import
Nom_package.Nom_classe
CRÉATION
D’UN PACKAGE
o Pour qu’une classe appartienne à un package
particulier on doit :
o Le spécifier explicitement au moyen de l’instruction package
o Il faudra créer un répertoire au nom du package et
sauvegarder les classes appartenant au package dans
ce répertoire
o Syntaxe :
package MonPackage
public class Employe
{ /*
…… */
}
PORTÉE
D’UNE
La portée d’une classe définie la zone dans laquelle elle
CLASSE
est visible

Mots clés Portée

aucun À l’intérieur d’un package
public Partout
private À l’intérieur de la classe
protected À l’intérieur des
extensions (classe filles)
de la classe appartenant
au même package que
la classe mère
CLASSES ABSTRAITES Partie
7

ET INTERFACES
CLASSE
ABSTRAITE
o Une classe abstraite est totalement l'opposé d'une classe final
o C’est est une classe qui ne peut pas être instanciée directement
o Elle n'est utilisable qu'à travers sa descendance (classe filles)
o Une classe abstraite doit toujours être dérivée pour pouvoir générer
des objets.
o Une classe abstraite est précédée du mot clé abstract , Ex :

abstract class classeabstraite

o L'utilité d'une classe abstraite est de permettre le regroupement (la
factorisation) des attributs et méthodes communs à un groupe de
classes.
 annotati

CLASSE on

ABSTRAITE Mot clé

abstract
Exemple :

Redéfinition de la méthode est

obligatoire

Deux méthodes abstraites non

définies
CLASSE
ABSTRAITE
o une classe abstraite peut contenir des méthodes abstraites,
c'est à dire des méthodes qui n'ont pas d'implémentation (elle
n’ont pas de corps) :

o Les méthodes abstraites de la superclasse abstraite doivent

obligatoirement être implémentées dans toutes les classes filles.
o L'intérêt des méthodes abstraites vient du fait que l'on peut les
appeler de la même façon pour tous les objets dérivés.
o Une classe qui possède une (ou plusieurs) méthode abstraite est
obligatoirement abstraite.
o Une classe abstraite peut hériter d’une autre classe abstraite
INTER
FACE
o Java n’admet pas l’héritage multiple, pour répondre à
certaines situation, java permet une forme d’héritage
multiple
o Utilisation de classe très particulière que l’on appelle
interface
o Une interface :
o Ne possède pas de champs, à l’exception des constantes
o Ont seulement des méthodes qui sont implicitement abstraites
( elles n’ont pas de corps)
o Comme les classes abstraites, une interface ne peut être
instanciée
DÉCLARATION
D’UNE INTERFACE
Déclaration :
public interface Une_interface
{
public void method1();
public double method2();
/* autres méthodes */
}
Remarquer qu’on pas utiliser le abstract
mot clé :
IMPLÉMENTATION
D’U
o
NE INTERFACE
Lorsqu’une classe hérite les caractéristiques d’une interface I
 on dit
que la classe implémente l’interface I
o La syntaxe de l’implémentation est :

public interface Une_interface Class Une_classe implements Une_interface

{ {
public void method1(); // champs
public double method2(); public void method1()
/* autres méthodes */ {// ensemble d’instructions }
} Public double method2()
{// ensemple d’instructions }

Les méthodes doivent être

définies
EXEMPLE
D’IMPLÉMENTATI
ON Point implémente
Arithm

Méthode définie avec le minimum

d’instruction
INTER
FACE
o Une interface peut étendre une interface
o Une classe peut implémenter plusieurs interfaces mais ne
peut étendre qu’une seule classe .

o Deux interfaces peuvent avoir une même méthode  ça va

pas créer un conflit puisque la méthode sera définit à
l’intérieur de la classe
 CLASSES
PRÉDÉFINIES :
Partie
8

OBJECT,
ENVELOPPE,
LA CLASSE «
OBJECT »
LA CLASSE
OBJECT
o Lorsque vous créez une classe (Ville par exemple), celle-ci hérite, de façon
tacite, de la classe Object présente dans Java.
o Toutes nos classes héritent donc des méthodes de la classe Object, comme :
equals() qui prend un objet en paramètre et qui permet de tester
l'égalité d'objets
classe Object, Méthode :
toString()
toString() : son prototype est : String toString()  représente
l’objet sous forme d’une chaine de caractère
Après l’exécution de ce code :

On aura
:

toString() renvoie une chaine décrivant l’objet :

Capitale@1db9742 On peut la redéfinir pour qu’elle fasse
autre chose.
Redéfinir la méthode
toString()

Classe Classe
Capitale Ville
classe Object, Méthode :
equals()
o equals() : son prototype est : boolean equals(Object o)  cette
méthode permet de comparer un objet à l’objet courant pour savoir s’il
sont égaux ou non
o rappel : (O1 == O2) (renvoie true si et seulement si O1 et O2
référencient le même objet.
o La méthode equals() fonctionne suivant le même principe (comme
==) dans la plupart des cas
o Pour comparer si les champs des objets sont égaux, il faut redéfinir
la méthode
equals()
Exempl
e:
Redéfinition
de la
Exemple de
méthode
toString redéfinition des
méthodes equals et
toString

Vérifie si l’objet passé en

paramètre est une instance
de Point ou non

Vérifie l’égalité des

champs
classe Object, Méthode :
clone()
o clone() : son prototype est : Object clone()
o Son rôle est dupliquer un objet rapidement en dupliquant la zone
mémoire dans laquelle il se trouve
o Pour cloner un objet il faut appeler cette méthode
o Le clonage est interdit par défaut , alors :
o Il faut redéfinir la méthode clone() de la classe object qui est
protected
par une méthode public dans la classe de l’objet que l’on veut
cloner
o Le classe qu’on veut cloner doit implémenter l’interface
cloneable
o L’interface cloneable ne comporte pas de méthode, elle est
juste faite pour autoriser le clonage
Redéfinir la méthode :
clone()

On doit implémenter l’interface

cloneable :

Puis redéfinir la méthode clone()

Appel de la méthode clone() de l’objet

object
Un cast de Object vers Ville
classe Object, Méthode :
hashCode()
Le rôle de la méthode hashCode() et de calculer un code numérique
pour l’objet dans lequel on se trouve , ce code numérique est censé
être représentatif de l’objet
Après l’exécution du code suivant :

On
aura :
 classe Object, Méthode :
finalize()
o Il n’ y a pas de destruction d’objet en JAVA, c’est le « gabrage
collector » qui s’en charge
o La méthode finalize() est appelée par la machine JAVA juste
avant l’effacement de l’objet
o Notons que l’appel de cette méthode ne se fait pas au moment où un
objet n’est plus référencié, mais au moment où la machine JAVA décide
de l’effacer
o L’effacement des objets respecte un algorithme compliqué en voie de
perfectionnement
classe Object, Méthode :
getClass()
o getClass() : son prototype est public Class
getClass()
renvoie des informations sous la forme d'un objet de
la classe Class.
Tester ce
Code !
LES
ENVELOPP
ES
Les enveloppes
(Wrappers)
Sont des classes qui encapsulent des données de types primitifs, afin de pouvoir les
utiliser comme des objets ordinaires.
Type primitif Classe enveloppe
boolean Boolean
char Character
byte Byte
short Short
int Integer Sous-classe
de la classe
long Long Number
float Float
double Double
Enveloppes vs
primitifs l’adresse de
l’objet
V V

5 &
l’objet pointé par la
référence V
int V;
5

Integer V = new Integer(5);

 Auto-boxing & Auto-
unboxing
Auto-boxing : La conversion automatique de types primitifs en objets de
leurs classes enveloppe correspondantes est appelée auto-boxing. Par
exemple - conversion de int en Integer, long en Long, double en
Double, etc.

Auto-unboxing : C'est juste le processus inverse de l'autoboxing. La conversion

automatique d'un objet d'une classe enveloppe en son type primitif
correspondant est appelée un-boxing. Par exemple - conversion d'Integer en
int, de Long en long, de Double en double, etc.
Méthodes communes :
XXXVALUE()
Ici xxx représentent des types de données numériques primitifs (byte,
short, int, long, float, double).
Cette méthode permet de convertir la valeur de cet objet Number en
type de données primitif spécifié.

Cette méthode retourne la valeur numérique représentée par cet

objet après conversion au type spécifié.
Méthodes communes :
XXXVALUE()

Lors de la conversion, une perte de précision est possible. Par exemple, comme
nous pouvons le constater, la fraction (".7689") a été omise lors de la conversion
d'un objet Double en type de données int.
 Méthodes communes :
COMPARETO()
La méthode compare l'objet Number qui a appelé la méthode à l'argument.
Il est possible de comparer Byte, Long, Integer, etc.
Cependant, deux types différents ne peuvent pas être comparés,
l'argument et l'objet Number appelant la méthode doivent être du
même type.
Syntaxe :
public int compareTo( NumberSubClass
referenceName ) valeur retournée
la valeur 0 si le Number est égal à
l'argument.
la valeur -1 si le Number est inférieur à
l'argument. la valeur 1 si le Number est
supérieur à l'argument.
Méthodes communes :
COMPARETO()
Méthodes communes :
EQUALS()
La méthode détermine si l'objet
Number qui appel la méthode est
égal à l'objet transmis en tant
qu'argument.
Syntaxe :
public boolean equals(Object o)
La méthode retourne True si
l'argument n'est pas null et est un
objet du même type et avec la
même valeur numérique
Méthodes communes :
parseXXX()
Cette méthode est utilisée pour obtenir le type de données primitif d'une
certaine String. parseXxx() est une méthode statique et peut avoir un
argument ou deux.
Syntaxe :static int parseInt(String s) static int
parseInt(String s, int radix) Paramètres :
s - Ceci est une représentation sous forme de chaîne de
décimale. radix - Ceci serait utilisé pour convertir
String s en entier.
Valeur de retour
parseInt (String s) - Ceci retourne un entier (décimal
seulement).
parseInt (String s, int i) - Ceci retourne un entier, étant donné une représentation
sous forme de chaîne de nombres décimaux, binaires, octaux ou hexadécimaux
(valeur de base égale à 10, 2, 8 ou 16 respectivement), en entrée.
Méthodes communes :
parseXXX()
Méthodes communes :
toString()
La méthode est utilisée pour obtenir un objet String représentant la valeur de
l'objet Number.
Il existe deux variantes de la méthode toString(). Elles sont utilisées pour obtenir
une représentation sous forme de chaîne d'un nombre. Les autres variantes de ces
méthodes sont [Link] (int i), [Link](int i),
[Link](int i), qui renverront respectivement une représentation
binaire, hexa-décimale, octale sous forme de String, d'un entier spécifié (i).
Syntaxe : String toString()
static String toString(int i) Valeur de
retour
String toString () - retourne un objet String représentant la valeur de l'objet
Number sur lequel il est appelé.
static String toString (int i) - retourne un objet String décimal représentant
l'entier spécifié (i)
Méthodes communes :
toString()
La classe Byte,
Short
o La classe Byte possède trois constantes :
o Byte.MAX_VALUE qui vaut 27-1
o Byte.MIN_VALUE qui vaut -27
o [Link] qui vaut 8 le nombre de bits de la représentation
d'un byte.
o La classe Short possède trois constantes :
o Short.MAX_VALUE qui vaut 215-1
o Short.MIN_VALUE qui vaut -215
o [Link] qui vaut 16 le nombre de bits de la représentation
d'un short.
La classe
Integer
La classe Integer possède trois constantes :
▪Integer.MAX_VALUE qui vaut 232-1,
▪Integer.MIN_VALUE qui vaut -232
▪[Link] qui vaut 32 le nombre de bits de la
représentation d'un int.
stat ic int highestOneBit(int i) Retourne la valeur entière du bit 1 de plus
fort poids de la représentation
de i
stat ic int lowestOneBit(int i) Retourne la valeur entière du bit 1 de moins
fort poids de la représentation
de i
Retourne le nombre de 0 en début de la
static int numberOfLeadingZeros (int c) représentation de i.

static int numberOfTrailingZeros (int c) Retourne le nombre de 0 en fin de la

représentation de i.
Retourne la valeur de i à laquelle on a fait
static int rotateLeft(int i, int d) subir une rotation de distance d vers la
gauche. Un bit peut aller occuper le bit de
signe.
Retourne la valeur de i à laquelle on a fait
static int rotateRight(int i, int d) subir une rotation de distance d vers la
droite. Un bit peut aller occuper le bit de
signe.
static int reverse(int i) Retourne la valeur obtenue en inversant
l'ordre des bits de i.
static int bitCount(int i) Retourne le nombre de bits à 1 dans la
La classe

oLong
La classe Long possède trois constantes :
o Long.MAX_VALUE qui vaut 263-1
o Long.MIN_VALUEqui vaut -263
o [Link] qui vaut 64 le nombre de bits de la représentation
d'un long.
o La classe Long a les mêmes méthodes que la classe
Integer.
La classe
float
o La classe Float possède les constantes :
o Float.MAX_VALUE qui vaut (2-2-23)2127
o Float.MIN_VALUE qui vaut 2-149
o [Link] qui vaut 32 le nombre de bits de la représentation
d'un Float
o [Link] une représentation de NotANumber
o Float.POSITIVE_INFINITY qui représente +∞
o Float.NEGATIVE_INFINITY qui représente -∞
La classe
double
o La classe Double possède les constantes :
o Double.MAX_VALUE qui vaut (2-2-52)21023
o Double.MIN_VALUE qui vaut 2-1074
o [Link] qui vaut 64 le nombre de bits de la représentation d'un
Double
o [Link] une représentation de NotANumber
o Double.POSITIVE_INFINITY qui représente +∞
o Double.NEGATIVE_INFINITY qui représente -∞
La classe :
Boolean
Il y a deux constantes de type Boolean : [Link] et
[Link]
La classe :
Character
static boolean isLetter(charc) Retourne true si le caractère c est une
lettre
static boolean isDigit(char c) Retourne true si le caractère c est un chiffre
static boolean isLetterOrDigit(char Retourne true si le caractère c est un
c) chiffre ou une lettre
static boolean isLowerCase(char c) Retourne true si le caractère c est une lettre
majuscule
static boolean isUpperCase(char c) Retourne true si le caractère c est un espace
et false sinon.
static boolean isSpaceChar(char c) Retourne true si le caractère c est un espace
et false sinon.
static boolean isWhiteSpace(char c) Retourne true si le caractère c est un espace
selon Java et false sinon. ('\n', '\r', '\
t', '\f' ...)
static boolean Retourne true si le caractère c peut faire
isJavaIdentifierPart(char c) partie d'un identificateur Java et
false sinon.
static boolean Retourne true si le caractère c peut être le
isJavaIdentifierStart(char c) premier caractère d'un identificateur
Java et false sinon.
EXEMPL
ES
Retourne
True
Retourne
True
La classe

Void
La classe Void enveloppe le type primitif void. Cette classe
ne peut pas être instanciée.
LA CLASSE «
DATE »
La classe
Date
o La classe Date représente une date avec une précision du millième
de seconde.
o Elle permet :
o l'interprétation des dates en année, mois, jours, heure, minute et seconde,
o le formatage et l'analyse de dates exprimées sous la forme de chaînes de
caractères.
 Les constructeur de la
classe Date Crée une Date et l'initialise au temps courant.
Date()

Date(long date) Crée une Date et l'initialise avec l'argument date précisant un
nombre de millisecondes écoulées depuis le 1er Janvier 1970
à 00:00:00 GMT.
Crée une date et l’initialise avec les
Date(int year, int arguments : year : L’année après
month, int day) 1900
month : entre 0 -11
day : le jour du mois entre 1-31
Crée une date et l’initialise avec les
Date(int year, int arguments : year : L’année après
month, int date, int 1900
hrs, int min) month : entre 0 -11
day : le jour du mois
entre 1-31 hrs : l’heure
entre 0-23
min : Les minutes entre
0-59
 Les constructeur de la
classe Date
public Date(int year,
int month, int date, Comme le précédent :
int hrs, int min, sec - seconds between 0-59
int sec)
 Méthode de la classe
Date
public static long
UTC(int year, int month,
int day, int hrs, int Calcule la valeur de l’UCT pour la date
min, int sec) YMDHMS
public int getYear() Retourne l’année après 1900
public void setYear(int
year) Modifie l’année de la date
public int getMonth() Retourne le mois
public int getDate() Retourne le jour du mois
public int getDay() Retourne le jour de la semaine
public int getHours() Retourne l’heure
public int getMinutes() Retourne les minutes
public int getSeconds() Retourne les secondes
 Méthode de la classe
Date
public void setMonth(int
month)
public void setDate(int date)
public void setDay(int day)
public void setHours(int
hours)
public void setMinutes(int Même comportement que setYear(int
minutes) year)
public void setSeconds(int
seconds)
public void setTime(long
time)
 Méthode de la classe
Date
boolean after(Date d)
boolean before(Date d) Comparaison de deux dates
int compareTo(Date d)
long getTime() Retourne le nombre de millisecondes
écoulées depuis le 1 janvier 1970,
00:00:00 GMT représenté par cet
void setTime(long t) objet Date.
Affecte la date du temps t.
Calculer la différence entre deux dates : on utilise la
méthode getTime()
GESTION DES Partie
9

EXCEPTIONS
EXCEPTI
ON
o Une exception est une erreur se produisant dans un programme qui
conduit le plus souvent à l'arrêt de celui-ci.
o Une exception non traitée engendrera un arrêt immédiat du
programme
o La gestion des exceptions s'appelle aussi « la capture d'exception »
Le principe :
o Repérer un morceau de code (par exemple, une division par zéro)
qui pourrait générer une exception.
o Capturer l'exception correspondante
o La traiter, c'est-à-dire d'afficher un message personnalisé et
de continuer l'exécution.
GESTION DES
EXCEPTIONS
Java contient une classe nommée Exception dans laquelle sont
répertoriés différents cas d'erreur
Exemple : voyons ce code

Après l’exécution, on aura :

Cela signifie qu’une exception a été levée à cause de la division par 0

 arrêt du programme
Le nom de cette exception est : ArithmeticException
SOLUT
ION
Capturer l’exception avec le bloc try{…} catch{…} ,puis
réaliser un traitement en conséquence :
Source d’exception

Instruction Code à
Après exécutée exécuter
exécution :
L’INSTRUCTION
catch
ArithmeticException : le nom de l’exception
La variable e : peut servir à préciser notre message grâce à l'appel
de la méthode
getMessage()
LE MOT CLÉ
finally
Considérons ce
code :

Après exécution :

Remarquer :
o On a capturer l’exception levée
o Le bloc finally est exécuté systématiquement
o Cela est surtout utilisé lorsque on doit s’assurer d'avoir fermé un
fichier, fermer une connexion à une base de données ou un socket
(une connexion réseau)
EXCEPTIONS
PERSON NALISÉES
Pour créer une exception personnalisée, on doit créer une classe qui va
hériter de la classe Exception
Exemple : une exception permettant d'interdire l'instanciation d'un
objet Ville ou Capitale présentant un nombre négatif
d'habitants.
Créons la classe notre classe :

par convention, les exceptions ont un nom se terminant par «

Exception »
EXCEPTIONS
PERSON
Dans le constructeurNALISÉES
de la classe Ville on va mettre une condition s’elle est
satisfaite, lèvera une exception de type NombreHabitantException : nous
devons dire à notre constructeur de Ville : « si l'utilisateur crée une instance
de Ville avec un nombre d'habitants négatif, créer un objet de type
NombreHabitantException » • throws nous indique que
si une erreur est capturée,
celle-ci sera traitée en tant
qu'objet de la classe
NombreHabitantException
.
• indique aussi à la JVM que
le constructeur de notre
objet Ville est
potentiellement dangereux
et qu'il faudra gérer les
exceptions possibles.
EXCEPTIONS
PERSON
Dans le constructeurNALISÉES
de la classe Ville on va mettre une condition s’elle est
satisfaite, lèvera une exception de type NombreHabitantException : nous
devons dire à notre constructeur de Ville : « si l'utilisateur crée une instance
de Ville avec un nombre d'habitants négatif, créer un objet de type
NombreHabitantException »

Si la condition if(nbre < 0)

est remplie, throw new
NombreHabitantException();
instancie la classe
NombreHabitantException. Par
conséquent, si un nombre
d'habitants est négatif,
l'exception est levée.
 EXCEPTIONS
PERSONNALISÉES
Après avoir apporter ces modification, dans la méthode main() , on
instancie une Ville

Une erreur signale que, désormais, on doit gérer les exceptions qui pourraient survenir
en utilisant le bloc try{} … catch{}
 EXCEPTIONS
PERSONNALISÉES
Ainsi, pour que l'erreur disparaisse, il nous faut entourer notre
instanciation avec un bloc try{…}catch{…}, comme à la figure
suivante.

Vous essayez d'instancier une classe Ville setta

avec un nombre d'habitants négatif ! t
inconnu
GESTION DE
PLUSIEURS
On suis les mêmes
EXCEPTION
étapes : Dans notre
exemple
INTERFACES Partie
10

PRÉDÉFINIES
 L’interface
Comparable
o L’interface Comparable, nécessite l’implémentation de
la méthode compareTo :
interface Comparable {
public int compareTo(Object
o);
}
La méthode compareTo permet de comparer l’objet courant (this) à l’objet o reçu en argument
et renvoyer un entier (dont la valeur exacte est sans importance) :
 négatif (la valeur -1)si l’on considère que l’objet courant est "inférieur" à l’objet o (au sens de
l’ordre qu’on veut définir),
 nul (la valeur 0)si l’on considère que l’objet courant est égal à l’objet o (il n’est ni inférieur, ni
supérieur),
 positif (la valeur 1)si l’on considère que l’objet courant est "supérieur" à l’objet o
 L’interface

Comparable
L’interface Cloneable :

interface Cloneable {
public Object clone();
}
 L’interface

Comparable
Une classe qui veut que ses instances puissent être clonés superficiellement
devra implémenter l’interface Cloneable et redéfinir la méthode clone() :
class XSurface implements
Cloneable{
...
public Object clone() throws CloneNotSupportedException {
return [Link]();
 } } instances puissent être clonés en profondeur devra
Une classe qui veut que ses
implémenter l’interface Cloneable et redéfinir la méthode clone() :
class XProfondeur implements
Cloneable{ X x;
...
public Object clone() throws
CloneNotSupportedException { XProfondeur xp =
(XProfondeur)[Link]() ;
xp.x = (X)[Link]();
return xp; } }
FL Partie
11

UX
Présentati
on
Un programme a souvent besoin d’importer de l’information depuis
une source externe ou d’exporter une information vers une
destination externe.
Cette information peut être : dans un fichier, sur un disque,
quelque part sur le réseau, en mémoire,dans un autre programme.
Elle peut être de n’importe quel type : type de base, objets, caractères,
image,
sons…
Pour importer une information, un programme ouvre un flux sur une
source d’information (un fichier, la mémoire, un socket) et lit l’information
séquentiellement.
Pour exporter une information vers une destination externe, le programme
peut ouvrir un flux vers cette destination et y écrire l’information
séquentiellement.
 Définitio
n
Flux : tuyaux dans lesquels on envoie ou
on lit des séries de données.
 un flux d’entrée permet de lire des
éléments.
 un flux de sortie permet d’écrire des
éléments.

En Java, toutes les entrées/sorties sont gérées

via des flux
 Entrées/sorties standards (clavier/console)
 Fichiers
 Sockets
 ...
Principes de
flux
Pour effectuer une entrée ou une sortie de données en Java, le principe
est simple et se résume aux opérations suivantes :
 Ouverture d'un moyen de communication.
 Écriture ou lecture des données.
 Fermeture du moyen de communication.

Lecture Écriture
Ouvre un flux en lecture Ouvre un flux en écriture
Lit tant qu’il ya quelque chose à lire Écrire tant qu’il ya quel que chose à écrire
Ferme le flux Ferme le flux
Les familles de
flux
Il y a deux grandes classes de flux :
 les flux d’éléments binaires, sous-classes de InputStream et
OutputStream
 les flux de caractères
Binaire , sous-classes deinformation
Lire et écrire des Reader et Writer
codées ;
sur 8 bits
Flux de données
Texte Lire et écrire des informations codées sur 16 bits
les flux d’éléments
binaires
les flux de
caractères
Le Package
[Link]
Le Package [Link] offre une véritable collection de classes permettant
la gestion des Entrées/Sorties. On énumère alors les classes suivantes:
Le Package [Link] : Les classes
utilisées
Pour une manipulation assez exhaustive des fichiers nous avons choisis
les 13 classes suivantes :
File InputStreamRead
FileRead er
er OutputStreamWri
FileWrite ter
r BufferedReader
RandomAcces BufferedWriter
sFile PrintWriter
FileInputStream ObjectInputStrea
m
FileOutputStrea ObjectOutputStr
 Flux : Opérations
classiques
En Java, le nombre de classes intervenant dans la manipulation des flux est
important . On va faire une description systématique de ces classes après la
réalisation des opérations classiques suivantes :

 création séquentielle d’un fichier binaire ;

 lecture séquentielle d’un fichier binaire ;

 accès direct à un fichier binaire ;

 création d’un fichier texte ;

 lecture d’un fichier texte ;

Création séquentielle d’un fichier
binaireOutputStream Classe abstraite:Classe de base des flux Binaire

Classe dérivée de OutputStream: permet de manipuler

FileOutputStream
un flux binaire associé à un fichier en écriture.

FileOutputStream f = new FileOutputStream ("[Link]")

;
La classe FileOutputStream: contient des méthodes qui
FileOutputStream permettent d’envoyer sur le flux un octet ou un tableau
d’octets.

La classe DataOutputStream: contient des méthodes

DataOutputStream plus évoluées et qui dispose un constructeur recevant
en argument un objet de tye FileOutputStream.

DataOutputStream sortie = new DataOutputStream (f) ;

DataOutputStream sortie = new DataOutputStream

(new FileOutputStream ("[Link]"))
;
Création séquentielle d’un fichier
import [Link].* ; // pour les classes flux
binaire
public class CreFchierBinaire{
public static void main (String args[]) throws IOException {
String nomfich ; int n ;
[Link] ("donnez le nom du fichier a creer : ") ; nomfich =
[Link]() ; DataOutputStream sortie = new DataOutputStream( new
do { [Link]
FileOutputStream ("donnez; un entier : ") ;
(nomfich)) n = [Link]() ;
if (n != 0)
{ sortie. writeInt (n) ; }
}
while (n != 0) ;
[Link] () ;
[Link]
tln ("*** fin
creation
donnez le nom du fichier a creer : [Link]
fichier ***");
donnez un entier : 12
}}
donnez un entier : 85
donnez un entier : 55
donnez un entier : 128
donnez un entier : 47
donnez un entier : 0
*** fin creation
fichier ***
 Création séquentielle d’un fichier
binaire
On peut fournir en argument du constructeur de FileOutputStream un objet de type File à la
place d’un objet de type String car Java dispose d’une classe File permettant de manipuler des
noms de fichiers ou de répertoires.

 Il est possible de doter un flux d’un tampon. Il s’agit d’un emplacement mémoire qui sert à
optimiser les échanges avec le flux.

 Les informations sont d’abord enregistrées dans le tampon, et ce n’est que lorsque ce dernier est
plein qu’il est "vidé" dans le flux.

 Pour doter un flux de type FileOutputStream d’un tampon, on crée un objet de type
BufferedOutputStream en passant le premier en argument de son constructeur.

DataOutputStream sortie = new DataOutputStream ( new BufferedOutputStream

( new FileOutputStream (nomfich))) ;
Liste séquentielle d’un fichier
binaire InputStream Classe abstraite:Classe de base des flux Binaire

Classe dérivée de InputStream: permet de manipuler un

FileInputStream
flux binaire associé à un fichier en lecture.

FileInputStream f = new FileInputStream ("[Link]")

;
La classe FileInputStream: contient des méthodes qui
FileInputStream permettent de lire sur le flux un octet ou un tableau
d’octets.

La classe DataInputStream: contient des méthodes plus

DataInputStream évoluées et qui dispose un constructeur recevant en
argument un objet de tye FileInputStream.

DataInputStream entree = new DataInputStream (f) ;

DataInputStream entree = new DataInputStream

(new FileInputStream ("[Link]"))
;
Liste séquentielle d’un fichier
binaire
import [Link].* ;
public class LisFichierBinaire
{ public static void main (String args[]) throws IOException{
String nomfich ; int n = 0 ;
[Link] ("donnez le nom du fichier a lister’’); nomfich =
[Link]() ; DataInputStream entree = new DataInputStream( new
FileInputStream(nomfich)) ; [Link] ("valeurs lues dans le fichier "
+nomfich);
boolean eof = false ; // sera mis a true par exception
while (eof!=true)
{ try
{ n = [Link] () ;}
catch (EOFException e){ eof = true ; } if
(!eof) [Link] (n) ;
}
[Link] () ;
[Link] ("*** fin liste fichier
***");
}
}
donnez le nom du fichier a lister :
[Link] valeurs lues dans le
fichier [Link] :
12
85
55
128
47 *** fin liste fichier ***
 Liste séquentielle d’un fichier
binaire
On peut fournir en argument du constructeur de FileInputStream un objet de type File à la place
d’un objet de type String car Java dispose d’une classe File permettant de manipuler des noms de
fichiers ou de répertoires.

 Pour doter un flux de type FileInputStream d’un tampon, on crée un objet de type
BufferedInputStream en passant le premier en argument de son constructeur.

DataInputStream sortie = new DataInputStream ( new BufferedInputStream

( new FileInputStream (nomfich))) ;
 Accès directe à un fichier
binaire
pour réaliser l’accès direct à un fichier binaire java dispose une classe spécifique
RandomAccessFile. Cette classe dispose des fonctionnalités des deux classes DataInputStream et
DataOutputStream, en particulier des méthodes reading readFloat, writeInt, writeFloat...

 Les constructeurs de la classe RandomAccesFile besoin de deux paramètres:

 Nom de fichier à accéder.
 Mode d’accès : deux valeurs "r" (lecture seule) ou "rw" (lecture et écriture).

RandomAccesFile entree = new RandomAccesFile(“[Link] ’’, ‘’r’’);

RandomAccessFile dispose d’une méthode spécifique seek permettant d’agir sur le "pointeur de
fichier".

 pointeur de fichier correspond au rang du prochain octet à lire ou à écrire (le premier octet portant
le numéro 0).
Accès directe à un fichier
import [Link].* ;
binaire
public class Accdir{ donnez le nom du fichier a consulter :
public static void main (String args[]) throws IOException { [Link]
String nomfich ; Numero de l’entier recherche : 3
int n, num ; valeur = 55
RandomAccessFile entree ; Numero de l’entier recherche : 5
[Link] ("donnez le nom du fichier a consulter :"); valeur = 47
nomfich = [Link]() ;
Numero de l’entier recherche : 2
entree = new RandomAccessFile (nomfich, "r") ;
valeur = 85
do
Numero de l’entier recherche : 0
{ [Link] ("Numero de l’entier recherche : ") ;
*** fin consultation fichier ***
num = [Link]() ;
if (num == 0) break ;
[Link] (4*(num-1)) ;
n = [Link]() ;
[Link] (" valeur = " + n) ;
}
while (num != 0) ;
[Link] () ;
[Link]
("*** fin
consultation
fichier ***");
}
}
Création d’un fichier
texteProgramme qui lit des nombres entiers au clavier et qui, pour chacun d’entre
eux, écrit une ligne d’un fichier texte contenant le nombre fourni accompagné
de son carré, sous la forme suivante :
12 a pour carrre 144

Writer Classe abstraite: Classe de base des flux texte

Classe dérivée de Writer: permet de manipuler un

FileWriter
flux texte associé à un fichier en écriture.

FileWriter f = new FileWriter ("[Link]")

;
La classe PrintWriter: dispose des méthodes permettent
PrintWriter
de réaliser les formatage de texte.

PrintWriter sortie = new PrintWriter (f) ;

PrintWriter sortie = new PrintWriter
(new FileWriter("[Link]"))
;
Création d’un fichier
import [Link].* ;
texte
public class CreerFichierTexte Donnez le nom du fichier a
{ public static void main (String args[]) throws IOException creer : [Link]
{ String nomfich ; donnez un entier : 5
int n ; donnez un entier : 12
[Link] ("Donnez le nom du fichier a creer : ") ; donnez un entier :
nomfich = [Link]() ; 45 donnez un
PrintWriter sortie = new PrintWriter (new FileWriter entier : 2 donnez un
(nomfich)) ; entier : 0
do
{ [Link] ("donnez un entier : ") ;
n = [Link]() ;
if (n != 0)
{ [Link] (n + " a pour carre " +
n*n) ;
}
}
while (n != 0) ;
[Link] () ;
[Link]
tln ("*** fin
creation
fichier ***"); }}
 Lecture d’un fichier
texte
Pour lire un fichier texte on distingue deux situations :
 On se contente d’accéder aux lignes du fichier (sans chercher à un interpréter le contenu).

 On souhaite pouvoir accéder aux différentes informations présentes dans une ligne.

1 Accès aux lignes d’un fichier texte

 Dans la hiérarchie de la superclasse Reader n’existe pas une classe jouant le rôle symétrique
de PrintWriter.
 Il faut se contenter de la classe FileReader, symétrique de FileWriter. Les méthodes de cette
classe donnent la possibilité d’accéder des caractères, ce qu’il faut prendre en considération la
gestion de la fin de la ligne.

 En couplant la classe FileReader avec la classe BufferedReader qui dispose d’une méthode
readLine, nous allons pouvoir lire chacune des lignes de notre fichier
Lecture d’un fichier
BufferedReader entree = new BufferedReader
texte (new FileReader ("[Link]")) ;
 La méthode readLine de la classe BufferedReader fournit une référence à une
chaîne correspondant à une ligne du fichier
 si aucun caractère n’est disponible (pas même une simple fin de ligne), readLine
fournit la valeur null
import [Link].* ;
public class LecFichierTexte{ Donnez le nom du fichier a
public static void main (String args[]) throws IOException lister : [Link]
{ String nomfich , ligne ; 5 a pour carre 25
[Link] ("Donnez le nom du fichier a lister : ") ; 12 a pour carre 144
nomfich = [Link]() ; 45 a pour carre 2025
BufferedReader entree = new BufferedReader (new FileReader
2 a pour carre 4
(nomfich));
*** fin liste fichier ***
do
{ ligne = [Link]() ;
if (ligne != null) [Link] (ligne) ;
}while (ligne != null) ;
[Link] () ;
[Link]
("*** fin liste fichier
***"); }}
Lecture d’un fichier
texte
2 La classe StringTokenizer
 StringTokenizer, qui permet de découper une chaîne en différents tokens (sous-
chaînes), en se fondant sur la présence de caractères séparateurs qu’on choisit
librement.
 Nous lisons chaque ligne du fichier comme précédemment. Puis nous construisons,
à partir de la ligne lue (ici, ligneLue), un objet de type StringTokenizer :

StringTokenizer tok = new StringTokenizer (ligneLue, " ") ;

Ensuite, nous utilisons les deux méthodes suivantes de la classe StringTokenizer :

 countToken, qui compte le nombre de tokens d’un objet du type

StringTokenizer ;

 nextToken, qui fournit le token suivant s’il existe

 Lecture d’un fichier
2- La classe StringTokenizer
texte
import [Link].* ;
import [Link].* ; // pour StringTokenizer donnez le nom du fichier
public class LecFichierTexte2 { a lister : [Link]
public static void main (String args[]) throws IOException { Nombres et carres
String nomfich ; contenus dans ce fichier
int nombre, carre ;
5 25
[Link] ("donnez le nom du fichier a lister : ") ;
12 144
nomfich = [Link]() ;
45 2025
BufferedReader entree = new BufferedReader (new FileReader (nomfich));
[Link] ("Nombres et carres contenus dans ce fichier") ;
while (true)
{ String ligneLue = [Link]() ;
if (ligneLue == null) break ;
StringTokenizer tok = new StringTokenizer (ligneLue, " ") ;
nombre = [Link] ([Link]()) ;
for (int i=0 ; i<3 ; i++) [Link]() ; //pour sauter : a pour carre
carre = [Link] ([Link]()) ;
[Link] (nombre + " " + carre) ;
}
[Link] () ;
[Link] ("*** fin liste fichier ***");}}
 La gestion des fichiers: la
Classe File
 Les fichiers et les répertoires sont encapsulés dans la classe File du package [Link].

Une instance de la classe File est une représentation logique d'un fichier ou d'un répertoire qui peut
ne pas exister physiquement sur le disque.
 La classe File dispose des nombreuses méthodes permettant de :

 créer, supprimer ou renommer un fichier ou un répertoire,

 tester l’existence d’un fichier ou d’un répertoire,

 obtenir des informations relatives aux protections ou aux dates de modification,

 lister les noms de fichiers d’un répertoire.

 La gestion des fichiers: la
Classe
 Création d’un objet deFile
type File File monFichier = new File
("[Link]") ;
 les méthodes de la classe File

a. Création et suppression
boolean createNewFile ()
Crée un nouveau fichier qui doit ne pas exister ; renvoie true si la création s’est
déroulée convenablement.
boolean delete ()
Essaie de supprimer le fichier ; renvoie true si la suppression a eu lieu. Si le fichier n’existe pas,
renvoie false.
boolean mkdir ()
Crée un répertoire ayant le nom correspondant ; renvoie true si la création s’est déroulée
correctement. Seul le dernier niveau de répertoire peut être créé avec cette méthode.
 La gestion des fichiers: la
Classe
 les méthodes File
de la classe File

boolean mkdirs()
Fonctionne de façon semblable à mkdir, mais en acceptant de créer d’éventuels
niveaux intermédiaires de répertoires.

b. Teste d’existance
boolean exists ()
Fournit true si le fichier correspondant existe.
boolean isFile ()
Fournit true si l’objet correspond à un nom de fichier (indépendamment de l’existence de ce fichier).
boolean isDirectory ()
Fournit true si l’objet correspond à un nom de répertoire (indépendamment de l’existence de ce
répertoire).
 La gestion des fichiers: la
Classe
 les méthodes File
de la classe File
long length()
Fournit la longueur du fichier, en octets (0 s’il n’existe pas ou s’il est vide).
String getName ()
Fournit une chaîne contenant le nom correspondant (sans nom de chemin).
boolean isHidden()
Fournit true si l’objet correspond à un fichier caché.
boolean canRead()
Fournit true si l’objet correspond à un fichier autorisé en lecture.
boolean canWrite()
Fournit true si l’objet correspond à un fichier autorisé en écriture.
boolean canExecute()
Fournit true si l’objet correspond à un fichier programme exécutable.
 La gestion des fichiers: la
Classe File
 les méthodes de la classe File
[Link]ès aux membres d’un répertoire
String [] liste()
Fournit un tableau de chaînes correspondant.
File [] listeFiles()

Fournit les mêmes informations que la méthode précédente, mais sous la

forme plus pratique d’un tableau d’objets de type File.
La gestion des fichiers: la Classe File
(Exemple)
import [Link].*;
public class TesteFichier { Exemple de résultat :
public static void main (String args[])throws IOException{ chemin du fichier : [Link]
int n; Chemin absolu :
File monFichier = new File ("[Link]"); DataOutputStream D:\pr_doct\classeFile\[Link]
sortie = new DataOutputStream(new Droit de lecture : true
FileOutputStream (monFichier)); Droite d'ecriture : false
do { [Link] ("donnez un entier : ") ; Taille de ce fichier en octet:
n = [Link]() ; 20
if (n != 0)
{ sortie. writeInt (n) ;}
}while (n != 0) ;
[Link] () ;
[Link]();
if (![Link]()) {
[Link]("le
fichier "+monFichier+" }
[Link](1);
n'existe pas");
[Link](" Nom du fichier : "+[Link]());
[Link](" Chemin du fichier : "+[Link]());
[Link](" Chemin absolu : "+[Link]());
[Link](" Droit de lecture : "+[Link]());
[Link](" Droite d'ecriture : "+[Link]());
[Link](" Taille de ce fichier en octet: "+[Link]());
}}
 Sérialisation et dé-
sérialisation
 La sérialisation est la technique qui permet de transformer une structure de données complexe en
mémoire vers une représentation linéaire, sous la forme d’une chaîne de caractères, qui peut être
transmise via le réseau ou de le sauvegarder dans un fichier binaire.

 La dé-sérialisation est le procédé inverse, qui prend une donnée linéaire selon un certain format et
reconstruit une structure de données complexe en mémoire isomorphe à celle qui a été sérialisée.
 Sérialisation et dé-
sérialisation
 L'interface Serializable

 Cette interface ne définit aucune méthode mais permet simplement de marquer une classe comme
pouvant être sérialisée.

 Tout objet qui doit être sérialisé doit implémenter cette interface ou une de ses classes mères doit
l'implémenter.

 Si l'on tente de sérialiser un objet qui n'implémente pas l'interface Serializable, une
exception
[Link] est levée.
Exemple d’un objet
Sérialisé public class Personne implements Serializable {
private String nom =
""; private String prenom =
""; private int
taille = 0;
public Personne(String nom, String
prenom, int taille) {
[Link] = nom;
[Link] = taille;
[Link] = prenom;
}
public String getNom() {
return [Link];
}
public void setNom( String
nom) {
[Link] = nom;
}
public int
getTaille() {
return
[Link];
}
public void setTaille( int
taille) {
[Link] =
taille;
}
public String
getPrenom() {
return
[Link];
Sérialisation et dé-
 Sérialisation: Ecrire un objet sérialisé dans un fichier
sérialisation
1 Créer un objet FileOutputStream.
FileOutputStream sortie= new FileOutputStream(‘[Link]’);

2 Créer un objet ObjectOutputStream. Cet objet permet d’écrire des objets, mais
il ne peut pas se connecter directement à un fichier. Il a besoin pour ce la d’un
« intermidiaire », ici un FileOutputStream. on va alors chainer les deux flots,
ObjectOutputStream et FileOutputStream.
ObjectOutputStream sor= new ObjectOutputStream(‘sortie’);
3 Ecrire les objets a sauvegarder dans ‘[Link]’

[Link]
t(personne1);
[Link](personne2)
;
4 …….
Fermer ObjectOutputStream. fermeture du premier flot entraine
[Link](personnen)
La automatiquement celle des
; autres.
[Link]();
 Sérialisation et dé-

sérialisation
La désérialisation: l’interet de sauvegarder un objet est de pouvoir le restaurer le moment venu. Le
processus de désérialisation est très similaire à celui de sérialisation
1 Chainer un objet File InputStream et un objet ObjectInputStream
FileOutputStream entree= new FileOutputStream(‘[Link]’);
ObjectInputStream ent= new ObjectInputStream(‘entree’);
2 À chaque invocation de readObject, l’objet suivant est récupéré.
Object p1=[Link]();
Object
p2=[Link]();
…….
Object pn=[Link]();

3 Convertir les objets:

Personne p11=(Personne) p1;
Personne p22=(Personne)
p2;
4 …….
Personne pnn=(Personne) pn;
Fermer les flots: [Link]();
INTERFACES Partie
12

GRAPHIQUES
INTERFACE
GRAPHIQUE
 Interface
 Présentation
graphique
 AWT était disponible dés la naissance de Java. Cette librairie est un simple
ensemble de classes telles que Button (bouton), TextField (champ textuel),
Label (libellé) et autres.

 Swing est plus évolué que AWT. Elle inclut aussi les boutons, les champs
textuels et d'autres contrôles. Le nom des composants Swing commence
par la lettre J, par exemple JButton, JTextField, JLabel, etc.

 les conteneurs qui sont destinés à contenir d’autres composants,

comme par exemple les fenêtres ;

 les composants atomiques qui sont des composants qui ne peuvent

pas contenir d’autres composants, comme par exemple les boutons.
[Link]
Interface
[Link]

graphique
| |
+--[Link]* composants +--[Link]*
| composants
+--[Link]* conteneurs |+--[Link]* conteneurs
| |
+--[Link] +--[Link]*composants atomiques
| |
+--[Link] +--[Link] panneau utiliser pour dessiner
| |
+--[Link] +--[Link]
| |
+--[Link] +--[Link] bouton
| |
+-- [Link] +--[Link]
| |
+--[Link] +--[Link] case à cocher
| |
+--[Link] fenêtre graphique +--[Link] bouton radio
| |
+--[Link] +--[Link] option d'un menu
| |
+--[Link] boîte de dialogue +--[Link] option d'un menu
|
+--[Link] option d'un menu
|
+--[Link] menu ou option d'un menu
|
+--[Link] étiquette
|
+--[Link]
|
+--[Link] champ de texte
|
+--[Link] boîte de liste
|
+--[Link] boîte de liste combinée
|
+--[Link] panneau de défilement
|
+--[Link] barre de menu
|
+--[Link] menu surgissant
|
+--[Link] barre d'outils
 Interface
 Première fenêtre
graphique
Constructeur sans argument

JFrame

Constructeur avec argument

JFrame fen = new JFrame() ;

JFrame fen = new JFrame("Une fenêtre");
[Link]("Une fenêtre") ;
 Une fenêtre est un conteneur destiné à contenir d'autres composants.
 La méthode getContentPane de la classe JFrame fournit une référence,
de type Container, au contenu de la fenêtre.
 La méthodes add de la classe Container permet d’ajouter un composant
à une fenêtre.
 La méthode remove de la classe Container permet de supprimer un
composant d’une fenêtre.
 Interface
 Première fenêtre
graphique
import [Link].*;
import [Link].* ;
public class Premfen
{ public static void
main (String args[])
{ JFrame fen = new
JFrame() ;
[Link] (300,
150) ;//hauteur
150pixels et
largeur 300 pixels
[Link] ("Ma premiere fenetre") ;//titre de la fenêtre
L’utilisateur
[Link] cette
(true) ;//rendre la fenêtre
fenêtre visible comme n’importe quelle
manipuler
graphique,
} il peut : fenêtre
}
la retailler,
 la déplacer (ici, elle s’est affichée dans le coin haut gauche de l’écran),
 la réduire à une icône.
 Interface
 Première fenêtre
graphique
import [Link].* ; public class Premfen1
public class MaFenetre extends JFrame { public static void main (String args[])
{ public MaFenetre () // constructeur { JFrame fen = new MaFenetre() ;
{ setTitle ("Ma premiere fenetre") ; [Link] (true) ;
setSize (300, 150) ; }
} }
}
 Première fenêtre
Interface
graphique
void setBounds(int x, int y, int largeur, int hauteur)
Modifier la position et la taille d'un composant
void setVisible(boolean b)
Montrer et cacher un composant
void setEnabled(boolean b)
Activer et désactiver un composant
boolean isEnabled()
Connaître l’état (activé ou non) d’un
composant
void setBackground(Color c)
Modifier la couleur de fond d'un composant
void setForeground(Color c)
Modifier la couleur du premier plan d'un
composant
void setSize(int largeur, int hauteur)
Modifier la taille d'un composant
 Interface
 Les composants atomiques
graphique
La classe JComponent est une classe dérivée de la classe
abstraite
Container qui encapsule les composants atomiques d'une interface
graphique. Les principaux composants atomiques offerts par Java sont:
 les boutons,
 les cases à cocher,
 les boutons radio,
 les étiquettes,
 les champs de texte,
 les boîtes de liste,
 les boîtes de liste combinée.
 Interface
 Les composants atomiques
graphique
1- Création d’un bouton et ajout dans la fenêtre

Pour créer un objet bouton on utilise le constructeur de la classe JButton :

JButton monBouton = new JButtton ("ESSAI");

Pour introduire ce bouton dans la fenêtre on utilise La méthode

getContentPane de la classe JFrame qui permet defournir une référence à
ce contenu, de type Container :

Container c = getContentPane() ;

on ajoute ce bouton au contenu de référence c par la méthode add de la classe

Container :

[Link](monBouton) ;
 Interface
 Les composants atomiques
graphique
1- Création d’un bouton et ajout dans la
fenêtre
public class FenBouton
import [Link].* ; { public static void main (String args[]){
public class MaFenetre extends JFrame{ JFrame fen = new MaFenetre() ;
public MaFenetre () // constructeur [Link] (true) ;
{ setTitle ("Ma premiere fenetre") ; }
setSize (300, 150) ; }
JButton monBouton = new JButtton ("ESSAI");
Container c = getContentPane() ;
[Link](monBouton) ;
}
}
 Interface
 Les composants atomiques
graphique
2- Création d’une case à cocher et ajout dans la
fenêtre

Pour créer une case à cocher on utilise le

constructeur de la classe JCheckBox:
PourJCheckBox
introduiremaCase
cette = new
case dans
JCheckBox la fenêtre on
getContentPane ("CASE");
utilise la méthode de la
Conainer: classe JFrame et la méthode add de la classe
getContentPane().add(MaCase) ;

La méthode setSelected de la classe AbstractButton permet de modifier l’état

d’une case à cocher.
[Link](true) ; //coche la case de référence maCase
 Interface
 Les composants atomiques
graphique
3 Création de Bouton Radio
Pour créer une case à cocher on utilise le constructeur de la
classe
JRadioButton:
JRadioButton bRouge = new JRadioButton ( "Rouge");

JRadioButton bVert = new JRadioButton ( "Vert");

Pour obtenir la désactivation automatique d’autres boutons radio d’un même

groupe, il faut de plus :
 créer un objet de type ButtonGroup, par exemple :

ButtonGroup groupe = new ButtonGroup() ;

associer chacun des boutons voulus à ce groupe à l’aide de la méthode add
:

[Link](bRouge) ;

[Link](bVert) ;
 Interface
 Les composants atomiques
graphique
3- Création de Bouton Radio
public class MaFenetre extends JFrame { public class TestRadio{
private JRadioButton bRouge; public static void main (String args[])
private JRadioButton bVert; { MaFenetre fen = new MaFenetre() ;
public MaFenetre () [Link] (true) ;
{ super("Une fenêtre ") ; }
setBounds(10,40,300,200) ; }
bRouge = new JRadioButton("Rouge") ;
bVert = new JRadioButton("Vert") ;
ButtonGroup groupe = new ButtonGroup() ;
[Link](bRouge) ;
[Link](bVert) ;
Container c =
getContentPane() ;
[Link](new FlowLayout()) ;
[Link](bRouge) ;
[Link](bVert) ;
}
}
 Interface
 Les composants atomiques
graphique
3 Création de Bouton Radio
Par défaut, un bouton radio est construit dans l’état non
sélectionné (false). Pour le rendre séléctionné, on peut :

 utiliser la méthode setSelected de la classe AbstractButton:

[Link](true) ;

Ou le 2ème constructeur, de la classe JRadioButton :

JRadioButton bRouge = new JRadioButton ("Rouge", true) ;

 Interface
 Les composants atomiques
graphique
4- Création des étiquettes
Une étiquette de type JLabel permet d’afficher dans un conteneur un texte
(d’une seule ligne) non modifiable.
public class MaFenetre extends JFrame { public class
private JLabel MonTexte; TestEtiquete{ public static
public MaFenetre () void main (String args[]){
{ super("Une fenêtre ") ; MaFenetre fen = new MaFenetre() ;
setBounds(10,40,300,200) ; [Link] (true) ;
MonTexte = new JLabel }
("texte initial") ; }
//création d’une étiquette de référence MonTexte
contenant le texte texte initial
getContentPane().add(MonTexte) ;
[Link]("nouveau texte") ;
//modification du texte de l’étiquette de référence
MonTexte
}
}
 Interface
 Les composants atomiques
graphique
5- Création des champs de texte
Un champ de texte (ou boîte de saisie) de type JTextField est une zone
rectangulaire dans laquelle l’utilisateur peut entrer ou modifier un texte
(d’une seule ligne).
public class MaFenetre extends JFrame { public class TesteChampTexte{
private JTextField MonChamp1 ; public static void main (String
private JTextField MonChamp2 ; args[]){
public MaFenetre () MaFenetre fen = new MaFenetre() ;
{ super("Une fenêtre [Link] (true) ;
") ; }
setBounds(10,40,300,200) ; }
MonChamp1 = new JTextField(20) ;
Monchamp2 = new JTextField("texte initial", 10) ;
Container c= getContentPane();
[Link](new FlowLayout());
[Link](MonChamp1) ;
[Link](MonChamp2) ;
}
}
 Interface
 Les composants atomiques
graphique
6 Création des boites de liste
 La boîte de liste de type JList permet de choisir une ou plusieurs
valeurs dans une liste prédéfinie.
 On crée une boîte de liste en fournissant un tableau de chaînes à son
constructeur, par Exemple :

String[] couleurs = {"rouge", "bleu", "gris", "vert", "jaune", "noir"};

JList maListe = new JList(couleurs) ;

 Après incorporation dans un conteneur, on obtient un

composant se présentant ainsi :
 Interface
 Les composants atomiques
graphique
6 Création des boites de liste
 Initialement, aucune valeur n’est sélectionnée dans la liste. Le cas échéant,
on peut forcer la sélection d’un élément de rang donné par la méthode
setSelectedIndex :
[Link](2) ;
 Il existe trois sortes de boîtes de liste, caractérisées par un paramètre
de type :
Valeur du paramètre de type Type de sélection correspondante
SINGLE_SELECTION Sélection d’une seule valeur

SINGLE_INTERVAL_SELECTION Sélection d’une seule plage de valeurs (contiguës)

MULTIPLE_INTERVAL_SELECTION Sélection d’un nombre quelconque de plages de valeurs

 Pour modifier le type de boîte de liste, on la

utilise méthode
setSelectionMode d’en-tête :
[Link] (SINGLE_SELECTION) ;
 Interface
 Les composants atomiques
graphique
6 Création des boites de liste
 Pour récupérer l’élément sélectionné dans une boîte de liste simple on
utilise la méthode getSelectedValue. Son type de retour est Object.
String ch = (String) [Link]();
//cast obligatoire
 Pour les autres types de boîte de liste, on utilise la
méthode
getSelectedValues qui fournit un tableau d’objets.
Object[] valeurs = [Link]();
for (int i=0 ;i<[Link] ;i++)
[Link]((String) valeurs[i]) ;
//cast obligatoire
 Par défaut une boîte de liste ne possède pas de barre de défilement.
On peut lui en ajouter une en introduisant la liste dans un panneau de
défilement de type JScrollPane (classe dérivée de la classe JComponent) :
JScrollPane defil = new JScrollPane (maliste);
 Interface
 Les composants atomiques
graphique
6 Création des boites de liste

 En suite, Il faut ajouter (par add) au conteneur concerné le panneau

de défilement et non pas la liste elle-même; par exemple, pour un conteneur
de type JFrame :
getContentPane().add(defil) ;

 Par défaut, la liste affichera alors huit valeurs (si elle en contient moins, la
barre de défilement n’apparaîtra pas). On peut modifier ce nombre par la
méthode setVisibleRowCount :

[Link](3) ;
 Interface
 Les composants atomiques
graphique
6- Création des boites de liste

public class MaFenetre extends JFrame { public class TestBoiteListe{

private JList maListe; public static void main (String args[]){
private JScrollPane defil; MaFenetre fen = new MaFenetre() ;
public MaFenetre () { [Link] (true) ;
super("Une fenêtre avec une boite de liste ") ; }
setBounds(10,40,300,200) ; }
String[] couleurs = {"rouge", "bleu", "gris", "vert",
"jaune", "noir"};
JList maListe = new JList(couleurs) ;
JScrollPane defil = new JScrollPane(maListe) ;
//la liste de référence MaListe affiche 8 valeurs. Si elle
en contient moins, la barre de défilement n'apparaît pas.
[Link](4) ;
//seules 4 valeurs de la liste sont visibles à la fois
getContentPane().add(defil) ;
//ajoute le panneau de défilement au contenu de la
fenêtre
}}
 Interface
 Les composants atomiques
graphique
7 Création des boites de liste combiné
 La boîte de liste combinée (boîte combo) de type JComboBox associe
un champ de texte et une boîte de liste à sélection simple. Tant que le
composant n'est pas sélectionné, seul le champ de texte s'affiche:

 Lorsque l'utilisateur sélectionne le champ de texte, la boîte de

liste s'affiche :
 Interface
 Les composants atomiques
graphique
7- Création des boites de liste
combiné
public class MaFenetre extends JFrame { public class TestCombox{
private JComBox maCombo; public static void main (String args[]){
public MaFenetre () MaFenetre fen = new MaFenetre() ;
{ super("Une fenêtre ") ; [Link] (true) ;
setBounds(10,40,300,200) ; }
String[] couleurs = {"rouge", "bleu", "gris", "vert", }
"jaune", "noir"};
maCombo = new
JComboBox(couleurs) ;
[Link](2) ;
Container c=getContentPane();
[Link](new FFlowLayout());
[Link](maCombo);
//sélection préalable de l’élément
de rang 2
}} visibles on utilise la méthode
 Pour modifier le
[Link](4)
nombre de ; //au maximum 4 valeurs sont affichées
valeurs
setMaximumRowCount
.
 Interface
 Les composants atomiques
graphique
7- Création des boites de liste combiné
 Pour rendre le champs de texte associé à une boite combo editable on utilise la
méthode setEditable.
[Link](true) ;
 La méthode getSelectedItem permet de fournir la valeur sélectionnée. Son
résultat est de type Object.
String ch = (String) [Link]();
 Pour ajouter un objet à la fin de la liste combo on utilise la méthode addItem
[Link]("orange") ;
 Pour ajouter un objet dans une position bien déterminée à la liste combo
on utilise la méthode insertItemAt
[Link]("orange", 2) ;
 Pour supprimer un objet de la liste combo on utilise la méthode removeItem
[Link]("gris") ;
 Interface
 Les gestionnaires de mise en forme
graphique
Pour chaque conteneur (fenêtre, boîte de dialogue, …), Java permet de choisir
un gestionnaire de mise en forme (en anglais "Layout manager") responsable
de la disposition des composants.

 BorderLayout,

 FlowLayout

 CardLayout

 GridLayout,

 BoxLayout

 GridBagLayout

La méthode setLayout de la classe Container permet d'associer un gestionnaire

de mise en forme à un conteneur.
 Interface
 Les gestionnaires de mise en forme
graphique
1- BorderLayout
 Pour Le gestionnaire de mise en forme BorderLayout permet de placer
chaque composant dans une zone géographique.
 L'emplacement d'un composant est choisi en fournissant en argument de
la méthode add de la classe Container l'une des constantes entières
suivantes (on peut utiliser indifféremment le nom de la constante ou sa
valeur) :
Constante symbolique Valeur
[Link] "North"
[Link] "South"
[Link] "East"
[Link] "West"
[Link] "Center"

 La classe BorderLayout dispose de deux constructeurs :

 public BorderLayout() ;
 public BorderLayout(int hgap, int vgap)
 Interface
 Les gestionnaires de mise en forme
graphique
1- BorderLayout
import [Link].* ; public class
import [Link].* ; TestBorderLayout{ public static void
public class MaFenetre extends JFrame { main (String args[])
public MaFenetre () { { MaFenetre fen = new MaFenetre() ;
super("Une fenetre") ; setSize(300, [Link] (true) ;
200) ; }
Container c = getContentPane() ; }
[Link](new BorderLayout()) ; //inutile
[Link](new JButton("UN")) ;
//bouton placé au centre par défaut
[Link](new JButton("DEUX"), "North") ;
[Link](new JButton("TROIS"), "South") ;
[Link](new JButton("QUATRE"), "West") ;
[Link](new JButton("CINQ"), "East") ;
}}
Le gestionnaire de mise en forme BorderLayout ne tient pas compte de la
taille souhaitée des composants, qui peut être imposée par la méthode
setPreferredSize de la classe JComponent.
 Interface
 Les gestionnaires de mise en forme
graphique
2- FlowLayout
 Le gestionnaire de mise en forme FlowLayout permet de disposer
les composants les uns à la suite des autres, de gauche à droite.

 La classe FlowLayout dispose trois constructeurs :

 public FlowLayout() ;

 public FlowLayout(int align)

[Link]

[Link]

[Link]

 public FlowLayout(int
align, int hgap, int
vgap)
 Interface
 Les gestionnaires de mise en forme
graphique
2- FlowLayout

import [Link].* ; public class TestFlowLayout{

import [Link].* ; public static void main (String args[]) {
public class MaFenetre extends JFrame { MaFenetre fen = new MaFenetre() ;
public MaFenetre () { [Link] (true) ;
super("Une fenetre") ; setSize(300, 200) ; }
Container c= getContentPane() ; }
[Link](new
FlowLayout([Link])) ;
[Link](new JButton("UN")) ;
[Link](new JButton("DEUX")) ; } }

Le gestionnaire de mise en forme FlowLayout tient compte, dans la mesure du

possible, de la taille souhaitée des composants, qui peut être imposée par
la méthode setPreferredSize de la classe Jcomponent.
 Interface
 Les gestionnaires de mise en forme
3- CardLayout
graphique
Le gestionnaire de mise en forme CardLayout permet de disposer les
composants suivant une pile, de telle façon que seul le composant supérieur soit
visible à un moment donné.
import [Link].* ; public class TestCardLayout{
import [Link].* ; public static void main (String args[])
public class MaFenetre extends JFrame { { MaFenetre fen = new MaFenetre() ;
public MaFenetre () { [Link] (true) ;
super("Une fenetre") ; setSize(300, }
200) ; }
Container c= getContentPane() ;
CardLayout pile = new CardLayout(30, 20) ;
//30 pixels de part et d'autre et 20 pixels en
haut et en bas
[Link](pile) ;
//changement de gestionnaire de mise en
forme
[Link](new JButton("UN"), "bouton1") ;
//la chaîne "bouton1" permet d'identifier le composant
au sein du conteneur
[Link](new JButton("DEUX"), "bouton2") ;
[Link](new JButton("TROIS"), "bouton3") ;
}}
 Interface
 Les gestionnaires de mise en forme
3- CardLayout
graphique
Par défaut, le composant visible est le premier ajouté au conteneur

[Link](c) ; : affiche le composant suivant .

[Link](c) ; : affiche le composant précédent

[Link](c) ; : affiche le premier composant

[Link](c) ; : affiche le dernier composant

[Link](c,"bouton3");: affiche le composant identifié par la chaîne

"bouton3 "
 Interface
 Les gestionnaires de mise en forme
4- GridLayout
graphique
Le gestionnaire de mise en forme GridLayout de disposer les
permet
composants les uns à la suite des autres sur une grille régulière,
chaque composant occupant une cellule de la grille.

public GridLayout(int rows, int cols) ; : rows et cols

définissent respectivement le nombre de lignes et de colonnes de la grille.

public GridLayout(int rows, int cols, int hgap, int vgap) ; : hgap et vgap
définissent les espaces entre les composants.
 Interface
 Les gestionnaires de mise en forme
4- GridLayout
graphique
import [Link].* ; public class TestGridLayout{
import [Link].* ; public static void main (String args[])
public class MaFenetre extends JFrame { { MaFenetre fen = new MaFenetre() ;
public MaFenetre () { [Link] (true) ;
super("Une fenetre") ; setSize(300, }
200) ; }
Container c = getContentPane() ;
[Link](new GridLayout(2, 2,10,10)) ;
//changement de gestionnaire de mise en
forme
[Link](new JButton("UN")) ;
[Link](new JButton("DEUX")) ;
[Link](new JButton("TROIS")) ;
[Link](new JButton("QUATRE")) ;
}}
 Interface
 Les gestionnaires de mise en forme
5 BoxLayout
graphique
Le gestionnaire BoxLayout permet de disposer des composants suivant une
seule ligne ou une seule colonne.

Le composant Box est un conteneur:

 dont le gestionnaire est BoxLayout
 qui est enfant de Container, donc n’est pas dans Swing.

On crée un "box horizontal" avec la méthode statique createHorizontalBox :

Box ligne = [Link] () ; // box horizontal

De la même manière, on crée un "box vertical" avec la méthode

statique
createVerticalBox :

Box colonne = [Link] () ; // box vertical

 Interface
 Les gestionnaires de mise en forme
graphique
5- BoxLayout
BoxLayout

Horizontal

BoxLayout
Verticala

BoxLayout
Vertical

JPanel
 Interface
 Les gestionnaires de mise en forme
graphique
6- Un programme sans gestionnaire de mise en forme
Il est possible de n'associer aucun gestionnaire
de mise en forme à un conteneur. Les
méthode composants
setBounds de la classe
sont Component.
alors ajoutés au conteneur
import [Link].* ; à l'aide de public class
la TestSetBounds{
import [Link].* ; public static void main (String args[])
public class MaFenetre extends JFrame { { MaFenetre fen = new MaFenetre() ;
public MaFenetre () { [Link] (true) ;
super("Une fenetre") ; setSize(300, }
200) ; }
Container c = getContentPane() ;
[Link](null) ;
//changement de gestionnaire de
mise en forme
JButton bouton1 = new
JButton("UN") ;
[Link](bouton1) ;
[Link](40, 40, 80, 30) ;
//le coin supérieur gauche du bouton
est placé au pixel de
coordonnées 40, 40 par rapport au coin supérieur gauche
de la fenêtre et les dimensions du bouton sont de 80 * 30
pixels
}}
 Interface
 Les gestionnaires de mise en forme
graphique
7- Une classe Insets pour gérer les marges

La méthode getInsets de la classe Container permet de définir les quatre

marges (haut, gauche, bas et droite) d'un conteneur.

Elle retourne un objet de type Insets défini par quatre champs publics de
type entier initialisés par le constructeur suivant :

public Insets(int top, int left, int bottom, int right)

 Interface
 Les gestionnaires de mise en forme
graphique
6- Une classe Insets pour gérer les marges
import [Link].* ; public class
import [Link].* ; TestInsetGridLayout{ public static
public class MaFenetre extends JFrame { void main (String args[])
public MaFenetre () { { MaFenetre fen = new MaFenetre() ;
super("Une fenetre") ; setSize(300, [Link] (true) ;
200) ; }
Container contenu = getContentPane() ; }
[Link](new BorderLayout(10, 10)) ;
[Link](new JButton("UN")) ;
[Link](new JButton("DEUX"), "North") ;
[Link](new JButton("TROIS"), "South") ;
[Link](new JButton("QUATRE"), "West") ;
[Link](new JButton("CINQ"), "East") ;
}
//redéfinition de la méthode getInsets afin de définir de
nouvelles marges pour la fenêtre
public Insets getInsets() {
Insets normal = [Link]() ;
//récupération des marges par défaut de la fenêtre
return new Insets([Link]+10, [Link]+10,
[Link]+10, [Link]+10) ;
//création d'un nouvel objet de type Insets pour modifier les
marges de la fenêtre
}}
GESTION DES
ÉVÉNEMENTS
 Gestion des
 Introduction
événements
Un clic souris, la frappe d’une touche au clavier ou le changement de la taille
d’une fenêtre sont des exemples d’événements.
Les événements Java sont classés en deux catégories :
1 les événements de bas niveau (clavier, opérations sur les fenêtres)

2 les événements sémantiques ou de haut niveau (mouvements des

scrollbars, clic sur un objet bouton): il s’agit d’événements spécifiques,
liés à des composants swing ou awt spécifiques.
Un événement dépend du composant qui l’a généré. On appelle source d’un
événement l’objet qui l’a généré.

Exemple :

 L’événement émis suite à un clic souris dans une fenêtre est de type MouseEvent.

 L’événement émis suite à un clic souris sur un bouton est de type ActionEvent. .. .
 Gestion des
 Traiter un événement
événements
Un composant ne traite pas forcément lui même les événements qu’il génère.
Il délègue ce traitement à des objets particuliers appelés écouteurs (un
composant peut être son propre écouteur).

Un écouteur est un objet qui capte des événements se produisant sur un autre
objet (ou d’un groupe d’objets, par exemple, un groupe d’éléments de menu).

En fonction des événements qu’ils traitent, un écouteur doit implémenter une

interface particulière, dérivée de l’interface EventListener, qui correspond à
une catégorie d’événements.

Pour traiter un événement de type XXXEvent, un écouteur doit implémenter

l’interface XXXListener.
 Gestion des
 Traiter un événement
Exemple:
événements
L’interface MouseListener correspond à une catégorie d’événements souris de
type MouseEvent. Elle comporte cinq méthodes correspondant chacune à un
événement souris particulier.
public interface MouseListener extends EventListener {
public void mousePressed(MouseEvent e) ;
//appelé lorsqu’un bouton de la souris est pressé sur un composant
//l’argument e de type MouseEvent correspond à l’objet événement généré

public void mouseReleased(MouseEvent e) ;

//appelé lorsqu’un bouton de la souris est relâché sur un composant

public void mouseClicked(MouseEvent e) ;

//appelé lors d’un clic souris sur un composant (la souris n’a pas été déplacée
entre l’appui et le relâchement du bouton)
public void mouseEntered(MouseEvent e) ;
//appelé lorsque la souris passe de l’extérieur à l’intérieur d’un composant
public void mouseExited(MouseEvent e) ;
//appelé lorsque la souris sort d’un composant (la souris passe de l’intérieur à
l’extérieur du composant)
}
 Gestion des
 Intercepter un évènement
événements
Lorsqu’un composant veut intercepter un événement de type XXXEvent, il
doit le préciser dans son constructeur en appelant la méthode
addXXXListener(XXXListener objetEcouteur), où l’argument objetEcouteur
correspond à l’objet écouteur chargé de traiter l’événement.
Pour savoir quels événements sont susceptibles d’être générés par un
composant donné, il faut rechercher toutes les méthodes de la forme
addXXXListener définies dans la classe du composant et dans ses classes
ascendantes.
Exemple : La classe Component définit notamment les méthodes suivantes :
public void addFocusListener(FocusListener l) ;
//prise et perte du focus (à un moment donné, un seul composant est sélectionné,
on dit qu’il a le focus)
public void addKeyListener(KeyListener l) ;
//événements clavier
public void addMouseListener(MouseListener l) ;
//événements souris
public void addMouseMotionListener (MouseMotionListener l) ;
//événements liés au déplacement de la souris
 Gestion des
 Intercepter un évènement
import [Link].* ;
événements
//L’écouteur d’événements souris doit implémenter
import [Link].* ; l’interface MouseListener qui correspond à une
import [Link].* ; catégorie d’événements souris.
import public class EcouteurSouris implements
[Link].* ; MouseListener {
public class MaFenetre extends JFrame { //redéfinition de la méthode appelée lors d’un
public MaFenetre () { clic souris
super("Une fenetre qui traite les clics public void mouseClicked(MouseEvent e) {
souris") ; [Link]("clic dans la
setSize(300, 200) ; fenetre"); }
addMouseListener(new //la redéfinition des autres méthodes est "vide"
EcouteurSouris()); public void mousePressed(MouseEvent e) { }
//la fenêtre fait appel à un écouteur public void mouseReleased(MouseEvent e) { }
d’événements souris pour traiter les clics souris ppublic void mouseEntered(MouseEvent e) { }
}} } ublic void mouseExited(MouseEvent e) { }
p
ublic class MonProgEvtClic1 {
public static void main(String args[]) {
Mafenetre fen = new MaFenetre() ;
f [Link](true) ; }
}
 Gestion des
 Intercepter un évènement
événements
import [Link].* ; import [Link].* ; public class MonProgEvtClic2 {
import [Link].* ; import [Link].* ; public static void main(String args[]) {
public class MaFenetre extends JFrame implements MaFentre fen = new MaFenetre() ;
MouseListener { [Link](true) ;
public MaFenetre () { }
super("Une fenetre qui traite les clics souris") ; }
setSize(300, 200) ;
addMouseListener(this);
//la fenêtre est son propre écouteur d’événements souris }
public void mouseClicked(MouseEvent e) {
int x = [Link]() ;
int y =
[Link]() ;
//coordonnées du curseur de la souris au moment du clic
[Link]("clic dans la fenetre au point de
coordonnees " + x + ", " + y); }
public void mousePressed(MouseEvent e) { }
public void mouseReleased(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
}
 Gestion des
 La notion d’adaptateur
événements
Pour chaque interface XXXListener possédant plusieurs méthodes, Java
fournit une classe particulière XXXAdapter, appelée adaptateur, qui
implémente toutes les méthodes de l’interface avec un corps vide.

Pour définir un écouteur d’événements de type XXXEvent, il suffit alors de

dériver l'écouteur de la classe XXXAdapter et de redéfinir uniquement les
méthodes voulues.
import [Link].* ; public class EcouteurSouris extends
import [Link].* ; MouseAdapter {
import [Link].* ; //redéfinition uniquement de la méthode appelée
import lors d’un clic souris
[Link].* ; public void mouseClicked(MouseEvent e) {
public class MaFenetre extends JFrame { [Link]("clic dans la fenetre") ;
public MaFenetre
super("Une fenetre()qui
{ traite les clics souris"); }}
setSize(300, 200) ; public class MonProgEvtClic2 {
addMouseListener(new EcouteurSouris()); public static void main(String args[]) {
} MaFentre fen = new MaFenetre() ;
} [Link](true) ;
}}
 
Exemple La notio
Gn dea’ sdtaipotanteudr es événements
Un bouton ne peut déclencher qu’un seul événement de type ActionEvent. L’interface
ActionListener ne comporte qu’une seule méthode actionPerformed.
import [Link].* ;import [Link].* ; public class EcouteurFermer implements
import [Link].* ;import [Link].* ; ActionListener {
class MaFenetre extends JFrame implements public void actionPerformed(ActionEvent
ActionListener { e)
private JButton MonBouton1, MonBouton2 ; {
public MaFenetre () { [Link](0);
super("Une fenetre avec deux boutons") ; setSize(300, 200); }}
Container c = getContentPane() ; public class MonProgEvtBouton1
[Link]( new FlowLayout()); { public static void main(String
MonBouton1 = new JButton("Bouton 1") ; args[]) { Mafenetre fen = new
[Link](MonBouton1) ; MaFenetre() ; [Link](true) ; }
MonBouton2 = new JButton("Bouton 2") ; }
[Link](MonBouton2) ;
[Link](this);
[Link](new EcouteurFermer());
[Link](this); }
public void actionPerformed(ActionEvent e) {
if([Link]() == MonBouton1)
[Link]("action sur le bouton 1") ;
if([Link]() == MonBouton2)
[Link]("action sur le bouton 2")
;}}
LES MENUS ET LES
BARRES D'OUTILS
 Les menus et les barres
Une fenêtre d'outils
de type JFrame est composée de composants atomiques,
mais aussi de composants qui lui sont propres comme les menus et les
barres d'outils.

1. Les principes des menus déroulants

Dans les menus déroulants usuels font intervenir trois sortes d’objets :

1. un objet barre de menu de type JMenuBar ;

2. différents objets menu, de type JMenu, visibles dans la barre de

menu ;

3. pour chaque menu, les différentes options, de type JMenuItem,

qui le constituent.
 Les menus et les barres
d'outils
La création d’un objet barre de menus se fait ainsi :

JMenuBar barreMenus = new JMenuBar() ;

Cette barre sera rattachée à une fenêtre fen par :
[Link](barreMenus);
//rattache l’objet
barreMenus à la fenêtre fen
Les différents objets menus sont créés par appel d’un constructeur
de, JMenu :

JMenu couleur = new JMenu ("Couleur") ;

// crée un menu de nom Couleur

Chaque objet menu est ajouté à la barre par add (il apparaît dans
l’ordre où il a été ajouté) :

[Link](couleur) ; // l’ajoute à barreMenus

 Les menus et les barres
d'outils
Les différentes options d’un menu sont créées par appel d’un constructeur
de JMenuItem :

JMenuItem rouge = new JMenuItem ("Rouge") ;

// crée une option de nom Rouge

Chaque option est ajoutée à un menu par add. Par

exemple : [Link](rouge) ; // l’ajoute au

menu couleur
Exemple
Ecrire un programme Java qui permet de créer
une fenêtre dotée par une barre de menus
comportant deux menus : Couleur (formé des
options Rouge et Vert) et Dimensions (formé des
options Hauteur et Largeur) :
 Les menus et les barres
 Événements générés
d'outils
Chaque action sur une option (JMenuItem) génère un événement Action
qu’on peut traiter en associant un écouteur à l’objet correspondant.
La méthode getActionCommand permet de fournir la chaîne de commande
associée à l’option. Par défaut, ils’agit du nom de l’option (fournie au
constructeur de JMenuItem)
La méthode setActionCommand permet de modifier la chaîne de
commande associée à l’option .
Exemple
Implémenter l’interface ActionListner dans le programme précédent pour afficher
les actions d’utilisateur sur les options
 Les menus et les barres
 Les différentes sortes d'options
d'outils
Les options de type JMenuItem sont les options les plus courantes
dans un menu, mais il existe deux autres types d'options :
1. Des options cases à cocher de type JCheckBoxMenuItem
2. Des options boutons radio de type JRadioButtonMenuItem.

Exemple

Modifier le programme précédent pour afficher la fenetre suivante :

 Les menus et les barres
 Composition des options
d'outils
Jusqu'à présent, un menu était formé d'une simple liste d'options. En
fait, une option peut à son tour faire apparaître une liste de sous-
options. Pour ce faire, il suffit d'utiliser dans un menu une option de
type JMenu (et non plus de type JMenuItem). Cette démarche peut être
répétée autant de fois que voulu.

Exemple
Écrire le programme qui permet d’afficher la fenêtre suivante :
 Les menus et les barres
 Barre d’outils
d'outils
Une barre d'outils de type JToolBar est un ensemble de boutons
regrouper linéairement sur un des bords de la fenêtre. En général,
ces
boutons comportent plutôt des icônes que des libellés.

Exemple

Écrire le programme qui permet d’afficher la fenêtre suivante :

LES BOITES DE
DIALOGUE
 Les boites de
 Boite de dialogue
dialogue
La boîte de dialogue est un conteneur. Elle permet de regrouper n'importe
quels composants dans une sorte de fenêtre qu'on fait apparaître
ou
disparaître.

Java propose un certain nombre de boîtes de dialogue standard obtenues à l'aide

de méthodes de classe de la classe JOptionPane :
 boîtes de message,
 boîtes de confirmation,
 boîtes de saisie
 boîtes d'options.
 La classe JDialog permet de construire des boîtes de
dialogue personnalisées.
 Les boites de
 Les boîtes de message
dialogue
Une boîte de message fournit à l'utilisateur un message qui reste affiché
tant que l'utilisateur n'agit pas sur le bouton OK. Elle est construite à
l'aide de la méthode de classe showMessageDialog de la classe
JOptionPane.
[Link](fen, "Message") ;
Exemple
Modifier le programme précédent pour afficher la fenêtre suivante :
 Les boites de
 Les boîtes de message
dialogue
Dans l'exemple précédent, nous n'avons défini que le contenu du
message. Il existe une variante de la méthode showMessageDialog qui
permet aussi de choisir le titre de la boîte et le type d'icône parmi la
liste suivante (les paramètres sont des constantes entières de la classe
JOptionPane).

Paramètre Type d'icône

JOptionPane.ERROR_MESSAGE Erreur
JOptionPane.INFORMATION_MESSAG Information
E Avertissemen
JOptionPane.WARNING_MESSAGE t Question
JOptionPane.QUESTION_MESSAGE Aucune icône
JOptionPane.PLAIN_MESSAGE
 Les boites de
 Les boîtes de message
dialogue
Exemple

[Link](fen, "Erreur", d'avertissement",

"Message JOptionPane.ERROR_MESSAGE) ;
 Les boites de
 Les boîtes de confirmation
dialogue
Une boîte de confirmation offre à l'utilisateur un choix de type oui/non.
Elle est construite à l'aide de la méthode de classe
showConfirmDialog de la classe JOptionPane.
[Link](fen, "Voulez-vous continuer");

Exemple
 Les boites de
 Les boîtes de confirmation
dialogue
Dans l'exemple précédent, nous n'avons défini que la question posée à
l'utilisateur. Il existe une variante de la méthode showConfirmDialog
qui permet aussi de choisir le titre de la boîte et la nature des
boutons qui s'y trouvent parmi la liste suivante (les paramètres sont
des constantes entières de la classe JOptionPane).

Paramètre Type de boite

JOptionPane.DEFAULT_OPTION (-1) Erreur
JOptionPane.YES_NO_OPTION (0) boutons YES et NO
JOptionPane.YES_NO_CANCEL_OPTION (1) boutons YES, NO et CANCEL
JOptionPane.OK_CANCEL_OPTION (2) boutons OK et CANCEL
 Les boites de
 Les boîtes de confirmation
Exemple
dialogue
[Link](fen, "voulez-vous continuer",
"INCIDENT MAJEUR", JOptionPane.YES_NO_OPTION ) ;

La valeur de retour de la méthode showConfirmDialog précise l'action effectuée

par l'utilisateur sous la forme d'un entier ayant comme l'une
des
valeur constantes suivantes de la classe JOptionPane :
 YES_OPTION (0), OK_OPTION (0),
 NO_OPTION (1), CANCEL_OPTION (2),
 CLOSED_OPTION (-1).
 Les boites de
 Les boîtes de saisie
dialogue
Une boîte de saisie permet à l'utilisateur de fournir une information
sous la forme d'une chaîne de caractères. Elle est construite à l'aide de
la méthode de classe showInputDialog de la classe JOptionPane.
[Link] (fen, "donnez un texte") ;
Exemple

La valeur de retour de la méthode showInputDialog est soit un objet de

type String contenant le texte fournit par l'utilisateur, soit la valeur null
si l'utilisateur n'a pas confirmé sa saisie par le bouton OK.
 Les boites de
 Les boîtes de saisie
dialogue
Dans l'exemple précédent, nous n'avons défini que la question posée à
l'utilisateur. Il existe une variante de la méthode showInputDialog qui
permet aussi de choisir le titre de la boîte et le type d'icône.
Paramètre Type d'icône
JOptionPane.ERROR_MESSAGE Erreur
JOptionPane.INFORMATION_MESSAG Information
E Avertissemen
JOptionPane.WARNING_MESSAGE t Question
JOptionPane.QUESTION_MESSAGE Aucune icône
JOptionPane.PLAIN_MESSAGE
[Link](
fen,
"Entrer votre nom",
"CONTROLE D'IDENTITE",
JOptionPane.WARNING_ME
SSAGE);
 Les boites de
 Les boîtes d’options
dialogue
Une boîte d'options permet à l'utilisateur de choisir une valeur parmi une
liste de valeurs, par l'intermédiaire d'une boîte combo. Elle est
construite à l'aide de la méthode de classe showInputDialog de la classe
JOptionPane.
Soit le tableau de chaînes couleurs suivant:
String[] couleurs = { "rouge", "vert", "bleu", "jaune", "orange", "blanc"} ;

[Link] (
fen, /*fenetre d’affichage*/
"choisissez une couleur", /*texte*/
"BOITE D’OPTIONS", /*titre*/
JOptionPane.QUESTION_MESSAGE, /* type d’icône, */
null, /* icône supplémentaire (ici aucune) */
couleurs, /* tableau de chaînes présentées dans la boîte combo */
couleurs[1]) ; /* rang de la chaîne sélectionnée par défaut */
 Les boites de
 Les boîtes d’options
dialogue
Exemple

La valeur de retour de la méthode showInputDialog est soit un objet de

type Object contenant la valeur sélectionnée par l'utilisateur, soit la
valeur null si l'utilisateur n'a pas confirmé sa saisie par le bouton OK.
COLLECTIONS Partie
13

DANS JAVA
 Collections dans
 Une collection est Java
un objet qui regroupe d’autre objets en une seule
unité.

 Ces objets proposent une solution au stockage de données et permettent

une manipulation de celles-ci

 Les classes et interfaces se trouvent dans le paquetage : [Link].

 Premières versions de Java (avant JDK 5.0):

 Tableaux

 Vector : tableaux dynamiques (listes)

 Hashtable : tables associatives

 A partir de Java 2, existence d'une infrastructure pour la gestion de

collections ( dans le package [Link]) (après JDK 5.0).
 Collections dans
Java
 Cette infrastructure offre une architecture unifiée pour représenter et
manipuler les collections.
 Composée de 3 parties :
 Une hiérarchie d'interfaces permettant de représenter les collections
sous forme de types abstraits.
 Des implémentations de ces interfaces.

 Implémentation de méthodes liées aux collections (recherche, tri,

etc.)
 Les avantages des collections sont:
 Améliorer la qualité et la performance des applications.

 Réduire l'effort lors de l'implémentation.

 Faciliter l'apprentissage de API
nouvelles (Application
Programmable Interface).
 Réduire le coût de conception de nouvelles API.
 Collections dans
Java
 Les interfaces sont organisées on deux catégories : Collection && Map

 Collection: un groupe d'objets où la duplication peut-être autorisée.

 Set: un ensemble ne contenant que des valeurs et ces valeurs ne sont

pas dupliquées. Par exemple l'ensemble A = {1,2,4,8}. Set hérite donc de
Collection, mais n'autorise pas la duplication. SortedSet est un Set trié.
 Collections dans
Java
 List: hérite aussi de collection, mais autorise la duplication.
Dans

cette interface, un système d'indexation a été introduit pour

permettre l'accès (rapide) aux éléments de la liste.

 Map: est un groupe de paires contenant une clé et une valeur associée à

cette clé. Cette interface n'hérite ni de Set ni de Collection. La raison

est que Collection traite des données simples alors que Map des

données composées (clé,valeur). SortedMap est un Map trié.

 Collections dans
Java
 Description des interfaces : l’interface Collection
public Interface Collection{
// les opérations de base
int size(); //nombre d'éléments
boolean isEmpty(); //test de l'absence d'éléments
boolean contains(Object element); //test d'appartenance
boolean add(Object element); //ajouter un élément: Optional
boolean remove(Object element); //supprimer un élément :Optional
Iterator iterator(); //pour le parcours (cf Iterator)
int hashCode();
boolean equals(Object element);
//les operations booleans
boolean containsAll(Collection c); //appartenance collective
boolean addAll(Collection c); // ajouter plusieurs éléments :Optional
boolean removeAll(Collection c); // supprimer plusieurs éléments :Optional
boolean retainAll(Collection c); //intersection :Optional
void clear(); // tout supprimer : Optional
// Array Operations
Object[] toArray(); //transformation en tableau
Object[] toArray(Object a[]); //tableau de même type que a
}
 Collections dans
Java
 Les interfaces contiennent des méthodes optionnelles. La définition de
ces dernières n’est pas obligatoire, elles sont définies en cas de besoin.

 Il y a des opérations réalisées sur un seul objet ou bien sur une collection
(un ensemble d'objets).
 add (remove) permet d'ajouter (resp. de retirer) un élément. Quand
à addAll (removeAll) permet d'ajouter (resp. de retirer même si les
éléments sont dupliqués dans la collection originale) une collection.

 contains (containsAll) permet de vérifier si un objet (resp. les

éléments d'une collection) est présent dans la collection.

 size, isEmpty et clear, permettent respectivement de donner la

taille de la collection, de vérifier si la collection est vide et
finalement d'effacer le contenu de la collection.
 Collections dans
 retainsAll se Java
comporte comme le résultat de l'intersection de
deux ensembles. Si A={1,2,5,8} et B={3,8} alors A = {8}.

 equals permet de tester si deux objets sont égaux.

 hashCode retourne le code de hachage calculé pour la collection.

 toArray retourne les éléments de la collection sous le format d'un

tableau.

 toArray(Object a[]) permet de préciser le type du tableau à

retourner. Si le tableau est grand les éléments sont rangés dans ce
tableau, sinon un nouveau tableau est crée pour recevoir les
éléments de la collection.
 Collections dans
Java
 L'interface collection est dotée d'une instance d'une classe qui
implante l'interface Iterator. C'est l'outil utilisé pour parcourir une
collection. L'interface Iterator contient ce qui suit:

public Interface Iterator{

boolean hasNext();
Object next();
void remove(); //
Optional
}

 hasNext permet de vérifier s'il y a un élément qui suit.

 next permet de pointer l'élément suivant.

 remove permet de retirer l'élément courant.

 Collections dans
Java
 Description des interfaces : l’interface LIST
 Liste est une collection ordonnée. Elle permet la duplication des
éléments. L'interface est renforcée par des méthodes permettant
d'ajouter ou de retirer des éléments se trouvant à une position donnée.
public Interface List extends Collection{
// Positional Access
Object get(int index);
Object set(int index, Object element); // Optional
void add(int index, Object element); // Optional
Object remove(int index); // Optional
boolean addAll(int index, Collection c); // Optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator listIterator();
ListIterator listIterator(int index);
// Range-view
List subList(int fromIndex, int
toIndex); }
 Collections dans
Java
 Les méthodes de l'interface List permettent d'agir sur un élément se
trouvant à un index donné ou bien un ensemble d'éléments à partir d'un
index donné dans la liste.

 get (remove) retourne (resp. retirer) l'élément se trouvant à la

position index. set (add & addAll) modifie (resp. ajouter) l'élément
(resp. un seul ou une collection) se trouvant à la position index.

 indexOf (lastIndexOf) recherche si un objet se trouve dans la liste et

retourner son (resp. son dernier) index.

 subList permet de créer un sous liste d'une liste.

 Collections dans
 Pour parcourir uneJava
liste, il a été défini un itérateur spécialement pour la
liste(ListIterator).
public Interface ListIterator extends Iterator{
boolean hasNext();
Object next();
boolean hasPrevious();
Object previous();
int nextIndex();
int previousIndex();
void remove(); //Optional
void set(Object o); // Optional
void add(Object o); //
Optional
}

 ListIterator permet donc de parcourir la liste

dans les deux directions
et de modifier un élément (set) ou d'ajouter
un nouveau élément.
 hasNext permet de vérifier s'il y a un
élément qui suit.
 next permet de pointer l'élément courant.
 Collections dans
Java l’interface set sont : ArrayList (tableau à taille
 Les classes implémentées
variable), LinkedList (listechaînée) et Vector
La classe Array List
 La classe ArrayList offre plus de souplesse que les tableaux d’objets
dans la mesure où sa taille (son nombre d’éléments) peut varier au fil de
l’exécution (comme celle de n’importe quelle collection).

 Construction: Comme toute collection, un vecteur dynamique peut être

construit vide ou à partir d’une autre collection c :

Après JDK 5.0 Avant JDK 5.0

vecteur dynamique vide
ArrayList <E> v1 = new ArrayList <E> () ; ArrayList v1 = new ArrayList () ;
vecteur dynamique contenant tous les éléments de la collection c
ArrayList <E> v2 = new ArrayList <E>(c) ; ArrayList v2 = new ArrayList (c) ;
 Collections dans
 Exemple: Voici unJava
programme créant un vecteur contenant dix objets
de type Integer, illustrant les principales fonctionnalités de la classe
ArrayList :
import [Link].* ; /* modification d’elements de position donnee */
public class Array1{ [Link] (2, new Integer (1000)) ;
public static void [Link] (5, new Integer (2000)) ;
main (String [Link] ("En D : contenu de v = " + v) ;
args[]){ }
}
ArrayList <Integer> v = new ArrayList <Integer> () ;
[Link] ("En A : taille de v = " + [Link]() ) ;
/* on ajoute 10 objets de type Integer */
for (int i=0 ; i<10 ; i++)
[Link] (new Integer(i)) ;
[Link] ("En B : taille de v = " + [Link]() ) ;
/* affichage du contenu, par acces direct (get) a
chaque element */
[Link] ("En B : contenu
de v = ") ; for (Integer e : v)
[Link] (e + " ") ;
[Link] () ;
/* suppression des elements de position donnee */
[Link] (3) ;
[Link] (5) ;
[Link] (5) ;
[Link] ("En C : contenu de v = " + v) ;
/* ajout d’elements a une position donnee */
[Link] (2, new Integer (100)) ;
[Link] (2, new Integer (200)) ;
[Link] ("En D : contenu de v = " +
v) ;
 Collections dans
La classe Vector
Java
 Les vecteurs sont des objets de type Vector. La gestion des vecteurs est
assez similaire à la gestion des ArrayList.
Vector liste = new Vector() ;
Méthode Description

add(objet) Ajoute un élément objet en fin de liste.

add(indice, objet) Insère un élément objet dans la liste, à l’indice spécifié en paramètre.
addElement(objet) Ajoute un élément objet en fin de liste et augmente sa taille de un.
elementAt(indice) Retourne l’élément stocké à l’indice spécifié en paramètre.
clear() Supprime tous les éléments de la liste.
Retourne l’indice dans la liste du premier objet donné en paramètre, ou
indexOf(objet)
–1 si objet n’existe pas dans la liste.
Retourne l’indice dans la liste du dernier objet donné en paramètre, ou –
lastIndexOf(objet)
1 si objet n’existe pas dans la liste.
remove(indice) Supprime l’objet dont l’indice est spécifié en paramètre
Supprime tous les éléments compris entre les indices i (valeur
removeRange(i, j)
comprise) et j (valeur non comprise).
setElementAt(objet, i) Remplace l’élément situé en position i par l’objet spécifié en paramètre.
size() Retourne le nombre d’éléments placés dans la liste.
 Collections dans
Java
 Description des interfaces : l’interface Set

 C'est une interface identique à celle de Collection. De plus cette interface

n’accepte pas deux objets égaux (au sens de equals). Deux
implémentations possibles:

 TreeSet: les éléments sont rangés de manière ascendante.

 HashSet: les éléments sont rangés suivant une méthode de hachage.

THRE Partie
14

ADS
 Définitio
n
 Les threads en Java sont des unités d'exécution parallèles dans un
programme Java.
 Ils d'exécuter plusieurs tâches en même temps
permettent dans un seul qui peut
programme, améliorer les performances
 Lesce threads peuvent et êtrela créés en réactivité de
implémentant l'interface
l'application.
[Link]
ou en étendant la classe [Link].
 Il est également possible de gérer et synchroniser les threads pour
contrôler leur exécution et éviter les problèmes de concurrence.
 Le principal avantage des threads est de pouvoir répartir différents
traitements d'un même programme en plusieurs unités distinctes
pour permettre leurs exécutions "simultanées".
Définitio
n
 Sur une machine monoprocesseur, c'est le système d'exploitation
qui alloue du temps d'utilisation du CPU pour accomplir les
traitements de chaque threads à "tour de rôle" (un parallélisme
simulé).

 Sur une machine multiprocesseur, le système d'exploitation

peut répartir l'exécution sur plusieurs cœurs (un
parallélisme vrai).
 Rôle des
threads
 Les threads permettent d'exécuter plusieurs tâches en parallèle
dans un seul programme, ce qui peut améliorer les performances
de l'application en utilisant efficacement les ressources système.
 Les threads peuvent également être utilisés pour des tâches de
fond, telles que la mise à jour de la base de données ou le
traitement de données, qui peuvent s'exécuter en parallèle avec
d'autres tâches sans perturber l'interface utilisateur.
 Les threads peuvent également aider à améliorer la réactivité de
l'application en permettant à des tâches de se dérouler en arrière-
plan, ce qui permet à l'interface utilisateur de rester réactive
pendant que les tâches sont en cours d'exécution.
 Les threads peuvent être synchronisés pour garantir la coordination
entre les tâches et éviter les problèmes de concurrence. En
résumé, les threads sont un outil essentiel pour créer des
Création des
Threads
 Les threads peuvent être créés comme instance d'une classe
dérivée de la classe Thread ou de l’interface Runnable.
 Elles sont lancées par la méthode start() , qui demande à
l'ordonnanceur de thread de lancer la méthode run() du
thread.
 Cette méthode run() doit être implantée dans le programme.
Création des Threads – La classe
Thread
Les fonctionnalités clés de la classe Thread incluent :
 Définir un nouveau thread en implémentant l'interface
Runnable ou en étendant la classe Thread elle-même.
 Contrôler l'exécution du thread en utilisant les méthodes
start(), sleep(), interrupt(), join(), yield(), etc.
 Obtenir des informations sur le thread en utilisant les méthodes
getName(), getId(), getPriority(), isAlive(), getState(), etc.
 Synchroniser les threads en utilisant les méthodes wait(),
notify(), notifyAll(), etc.
 Gérer les exceptions dans les threads en utilisant les
méthodes setUncaughtExceptionHandler(),
getUncaughtExceptionHandler(), etc.
Création des Threads – L’interface
Runnable
interface Runnable
{
public abstract void run() ;
}

Un objet « Runnable » est un objet que l’ on peut lancer en

faisant run()...
Création des
Threads
Donc comme nous avons vu pour créer des Threads il y a deux
méthodes, dont un point commun : « écrire une méthode run() qui
fait ce que doit faire le thread. »
 Méthode 1 : Dériver une classe de Thread.
 Méthode 2 : implémenter l’ interface Runnable.
Création des
Threads
Méthode 1 : Dériver une classe
de Thread
Création des
Threads
Méthode 1 : Dériver une classe (Exempl
de Thread e)
Création des
Threads
Méthode 2 : Implémenter l’interface
Runnable
Création des
Threads
Méthode 2 : Implémenter l’interface Runnable
(Exemple)
Création des
Threads
Quelle méthode
choisir ?
Création des
Threads
Quelle méthode
choisir ?
LE THREAD
COURANT
Lorsque vous exécutez votre programme, un thread
est lancé . Essayons ce code :

L’exécution
donne :

Main est le thread principal de notre

application
RÉALISATION
D’UN
o
THREAD
La réalisation d’un Thread se fait très simplement en concevant une
sous-classe de la classe Thread (appartient au package [Link])
o Cette classe doit être dotée d’une méthode nommée run() qui est
appelée lors du démarrage du Thread
o Pour lancer un Thread, il faudra appelée la méthode start() à
partir d’un objet issu de la sous-classe de Thread qu’on a crée
EXEMP
LE
Si on teste ce code
plusieurs
COMMENT ÇA
MARCHE
o Remarquer que l'ordre d'exécution est souvent aléatoire, car
Java utilise un ordonnanceur.
o si vous lance plusieurs threads dans une application, ceux-ci ne s'exécutent
pas toujours en même temps !
o En fait, l'ordonnanceur gère les threads de façon aléatoire : il va en faire
tourner un pendant un certain temps, puis un autre, puis revenir au
premier, etc., jusqu'à ce qu'ils soient terminés.
o Lorsque l'ordonnanceur passe d'un thread à un autre, le thread
interrompu est mis en sommeil tandis que l'autre est en éveil.
 LES ÉTATS
DES THREAD
New : lorsqu'un nouveau thread est créé, mais avant que sa méthode start
n'ait été appelée.
Runnable : lorsqu'un thread est prêt à s'exécuter et attend d'être
sélectionné pour exécution par le système d'exploitation.
Running : lorsqu'un thread est en train d'exécuter sa méthode run.
Blocked : lorsqu'un thread est en attente pour accéder à une ressource
partagée qui est déjà en cours d'utilisation par un autre thread.
Waiting : lorsqu'un thread est en attente d'une autre condition
spécifique, comme la fin d'un autre thread ou la disponibilité d'une
ressource.
Timed Waiting : lorsqu'un thread est en attente d'une autre condition
spécifique pendant une période de temps spécifiée.
Terminated : lorsqu'un thread a terminé son exécution ou a été interrompu
en raison d'une exception.
CONTRÔLER LE
DÉROULEMENT D’UN
Plusieurs méthodes peuvent être invoquées pour contrôler le déroulement
THREAD
d’un Thread :
wait() : mise en attente du Thread
sleep(int) : interrompt le déroulement pendant une durée qui peut être
spécifiée en paramètre
yield() : interrompt le déroulement afin de laisser du temps pour
l’exécution des autres Threads
Stop() : arrêter le thread
Quand plusieurs Threads font appel, en même temps, à un seul objet il
peut y avoir alors des comportements imprévisibles résultants de conflits
d’accès à cette ressource.
Exemple : Retraits simultanés sur un compte bancaire. Plusieurs personnes
retirent, en même temps, dans des agences différentes une
somme correspondant au solde d’un même compte. Il y a alors, un
risque que ce compte passe au rouge.
Pour éviter ce conflit , il faut que le compte soit verrouillé du début à la
fin d’un retrait. Toute autre opération simultanée est alors interdite.
Pour poser un verrou sur un objet, on déclare des méthodes synchronisée,
on utilise pour cela le mot clé synchronized.
SYNCHRONISER
LES THREAD
La synchronisation est un mécanisme qui permet de contrôler
l'accès concurrentiel à une ressource partagée dans un
environnement multithreadé. La synchronisation est nécessaire
pour éviter les erreurs de concurrence telles que les incohérences
de données qui peuvent se produire lorsque plusieurs threads
accèdent simultanément à une même ressource.

Java fournit plusieurs mécanismes pour la synchronisation,

notamment les blocs synchronized, les objets
[Link] et les objets
[Link]
EXEMP
LE
Dans cet exemple, la méthode increment est marquée comme
synchronized, ce qui signifie qu'elle ne peut être exécutée par un
seul thread à la fois. Si plusieurs threads essaient d'appeler
increment en même temps, seul un thread à la fois sera autorisé
à entrer dans la méthode et à incrémenter le compteur. Les
autres threads seront bloqués jusqu'à ce que la méthode soit
terminée et qu'ils puissent y entrer à leur tour.
En utilisant la synchronisation, nous garantissons que le compteur
ne sera jamais mis à jour de manière incorrecte par plusieurs
threads simultanément, ce qui pourrait entraîner des
incohérences de données.