Programmation Objet24 Udm

Université des Montagnes
Langage Java
(Programmation Orientée Objets)
Master Génie Informatique
Dr.Ing. Rodrigue Carlos Nana Mbinkeu
Membre du groupe de recherche en Informatique

Dbgroup, University of Modena, Italy
www.dbgroup.unimo.it
page personnelle: http://www.dbgroup.unimo.it/~nana/
Website: www.udesmontagnes.org
20/04/2011 1
Programmation Orientée Objets: Concepts généraux
Le cours sera basé principalement sur le langage JAVA avec une section spéciale sur
le langage PHP.
• Variables, structure de contrôle
• Objets et Classes: Constructeur et Destructeur, attributs, méthodes
• Méthodes auxiliaires et reutilisabilité
• Héritage , polymorphisme et les interfaces
• Thread (l’exécution parallèle)
• Swing (interfaces graphiques)
• JDBC (Java DataBase Connexion)
• Introduction au PHP
• UML(Diagramme de Classes et de Séquence) et Modèles de conception (MVC)

20/04/2011 2
PhD. Ing. Rodrigue Carlos Nana Mbinkeu
Programmation Orientée Objets: Avant propos
Dans ce cours, vous apprendrez à manier la Programmation Orientée Objet, ou POO

pour les intimes, dans le cadre des langages Orientés Objets Java et PHP.
Loin d'être aussi complexe qu'elle peut le laisser transparaître, la POO peut se maîtriser
rapidement.
Si la programmation dite procédurale est constituée de procédures et fonctions sans

liens particuliers agissant sur des données dissociées pouvant mener rapidement à des
difficultés en cas de modification de la structure des données, la programmation objet,
pour sa part, tourne autour d'une unique entité : l'objet.
20/04/2011 3
Programmation Orientée Objets: notion d’objet
Avant de rentrer plus avant dans le sujet qui nous intéresse, nous allons commencer par définir un
certain nombre de concepts fondamentaux:
L’objet
Un objet est avant tout une structure de données. Autrement, il s'agit d'une entité chargée de gérer
des données, de les classer, et de les stocker sous une certaine forme. En cela, rien ne distingue
un objet d'une quelconque autre structure de données. La principale différence vient du fait que
l'objet regroupe les données et les moyens de traitement de ces données.
Un objet rassemble de fait deux éléments de la programmation procédurale :
Les champs(seront appelés propriétés ou attributs dans un objet) :

Les champs sont à l'objet ce que les variables sont à un programme : ce sont eux qui ont en charge
les données à gérer. Tout comme n'importe quelle autre variable, un champ peut posséder un type
quelconque défini au préalable : nombre, caractère, ..., ou même un type objet.
Les méthodes :
Les méthodes sont les éléments d'un objet qui servent d'interface entre les données et le
programme. Sous ce nom obscur se cachent simplement des procédures ou fonctions destinées à
traiter les données. Les champs et les méthodes d'un objets sont ses membres.
Si nous résumons, un objet sert à stocker des données dans des champs(attributs) et à les gérer au
travers de ses méthodes.
20/04/2011 4
Avec la notion d'objet, il convient d‘introduire la notion de classe.
Ce que l'on a pu nommer jusqu'à présent objet est une classe d'objet. Il s'agit donc du
type à proprement parler. L'objet en lui-même est une instance de classe, plus simple-
ment un exemplaire d'une classe, sa représentation en mémoire.
Par conséquent, on déclare comme type une classe, et on déclare des variables de ce
Type appelées des objets.
Exemple:
Personne etu;
‘etu’ est un objet de la classe Personne.
20/04/2011 5
Une fois qu'une classe est créée, on peut créer autant d'objets de cette classe qu'on
veut et les manipuler comme s'ils étaient les éléments du problème qu'on tente de
résoudre.
Ampoule amp = new Ampoule();

amp.allumer();
amp est un objet de la classe Ampoule ou de type Ampoule
20/04/2011 6
Programmation Orientée Objets: durée de vie des objets
Environnement et durée de vie des objets
Techniquement, les spécificités de la programmation orientée objet se résument au typage abstrait des
données, à l'héritage et au polymorphisme, mais d'autres particularités peuvent se révéler aussi importantes.
Le reste de cette section traite de ces particularités.
L'une des particularités les plus importantes est la façon dont les objets sont créés et détruits. Où se trouvent
les données d'un objet et comment sa durée de vie est-elle contrôlée ? Différentes philosophies existent. En
C++, qui prône que l'efficacité est le facteur le plus important, le programmeur a le choix. Pour une vitesse
optimum à l'exécution, le stockage et la durée de vie peuvent être déterminé quand le programme est écrit, en
plaçant les objets sur la pile (ces variables sont parfois appelées automatiques ou de portée) ou dans l'espace
de stockage statique. La vitesse d'allocation et de libération est dans ce cas prioritaire et leur contrôle peut
être vraiment appréciable dans certaines situations. Cependant, cela se fait aux dépends de la flexibilité car il
faut connaître la quantité exacte, la durée de vie et le type des objets pendant qu'on écrit le programme. Si le
problème à résoudre est plus général, tel que de la modélisation assistée par ordinateur, de la gestion
d'entrepôts ou du contrôle de trafic aérien, cela se révèle beaucoup trop restrictif.
La deuxième approche consiste à créer les objets dynamiquement dans un pool de mémoire appelé le
segment. Dans cette approche, le nombre d'objets nécessaire n'est pas connu avant l'exécution, de même que
leur durée de vie ou leur type exact. Ces paramètres sont déterminés sur le coup, au moment où le programme
s'exécute. Si on a besoin d'un nouvel objet, il est simplement créé dans le segment au moment où on en a
besoin. Comme le stockage est géré de manière dynamique lors de l'exécution, le temps de traitement requis
pour allouer de la place dans le segment est plus important que le temps mis pour stocker sur la pile (stocker
sur la pile se résume souvent à une instruction assembleur pour déplacer le pointeur de pile vers le bas, et une
autre pour le redéplacer vers le haut). L'approche dynamique fait la supposition généralement justifiée que les
objets ont tendance à être compliqués, et que le surcoût de temps dû à la recherche d'une place de stockage
et à sa libération n'aura pas d'impact significatif sur la création d'un objet. De plus, la plus grande flexibilité qui
en résulte est essentielle pour résoudre le problème modélisé par le programme.
20/04/2011 7
Programmation Orientée Objets: durée de vie des objets(2)
Une autre particularité importante est la durée de vie d'un objet. Avec les langages qui autorisent la création
d'objets dans la pile, le compilateur détermine combien de temps l'objet est amené à vivre et peut le détruire
automatiquement. Mais si l'objet est créé dans le segment, le compilateur n'a aucune idée de sa durée de vie.
Dans un langage comme le C++, il faut déterminer dans le programme quand détruire l'objet, ce qui peut
mener à des fuites de mémoire si cela n'est pas fait correctement (et c'est un problème courant en C++). Java
propose une fonctionnalité appelée ramasse-miettes (garbage collector) qui découvre automatiquement
quand un objet n'est plus utilisé et le détruit. Java propose donc un niveau plus élevé d'assurance contre les
fuites de mémoire. Disposer d'un ramasse-miettes est pratique car cela réduit le code à écrire et, plus
important, le nombre de problèmes liés à la gestion de la mémoire (qui ont mené à l'abandon de plus d'un
projet C++).
20/04/2011 8
Programmation Orientée Objets: persistance
Quand un objet est créé, il existe aussi longtemps qu'on en a besoin, mais en aucun cas il continue d'exister
après que le programme se termine. Bien que cela semble logique de prime abord, il existe des situations où il
serait très pratique si un objet pouvait continuer d'exister et garder son information même quand le
programme ne tourne plus. A l'exécution suivante du programme, l'objet serait toujours là et il aurait la même
information dont il disposait dans la session précédente. Bien sûr, on peut obtenir ce comportement en
écrivant l'information dans un fichier ou une base de données, mais dans l'esprit du tout objet, il serait
pratique d'être capable de déclarer un objet persistant et que tous les détails soient pris en charge.
Java fournit un support pour la « persistance légère », qui signifie qu'on peut facilement stocker des objets sur
disque et les récupérer plus tard. La raison pour laquelle on parle de « persistance légère » est qu'on est
toujours obligé de faire des appels explicites pour le stockage et la récupération.
20/04/2011 9
Programmation Orientée Objets: Programme en java
class Salut{
public static void main(String[] args){
system.out.println(“Salut !”);
}
}
Comment rendre les instructions plus sophistiquées compréhensive par l’ordinateur?
Compilateur et Interpréteur sont des traducteurs de langage de programmation de haut niveau en

séries d’instructions-machine directement exécutables par l’ordinateur.
La différence réside dans la manière dont la traduction est réalisée :
le compilateur traduit les programmes dans leur ensemble : tout le programme doit être fourni en
bloc au compilateur pour la traduction.
L’interpréteur traduit les programmes instruction par instruction dans le cadre d’une interaction
continue avec l’utilisateur.
JAVA utilise les deux!
20/04/2011 10
POO: compilation d’un programme java
L’ interpréteur Java s’appelle la machine virtuelle Java (Java Virtual Machine(JVM))
20/04/2011 11
POO: notion de byte code
Bytecodes Java ⇔ “langage intermédiaire” entre compilation et exécution :
Langage dans lequel est compilé un programme Java :
-> javac Salut.java produit Salut.class contenant des bytecodes.
Pas vraiment “humainement lisible” et dans ce sens, il ressemble à du code assembleur. .

mais attention, les bytecodes sont interprétés par la machine virtuelle et donc pas
executés directement par le processeur.
-> C’est à la machine virtuelle de traduire ces bytecodes en code machine : java Salut
-> La machine virtuelle va ouvrir le fichier Salut.class et interpréter les bytecodes contenus
Indépendance de la plateforme
Le bytecode rend le programme indépendant de la plateforme:

possibilité de démarrer le programme sur un autre processeur sans recompilation à
condition que la JVM soit déjà installée.
20/04/2011 12
POO: EDI
Avec un environnement de développement intégré (EDI), par exemple Eclipse ou
Netbeans, le programmeur n’appelle pas explicitement les commandes javac ou java,
mais elles sont appelées par l’EDI.
La phase de Compilation se fait à la volée par l’EDI (il y a donc bel et bien une
compilation qui est faite implicitement !) lorsque des changements ont été effectués sur
les fichiers sources.
La phase d’Interprétation se lance graphiquement à l’aide du bouton Run. L’EDI lance

l’interprétation (c’est-à-dire la commande java !) lors du clic sur le bouton Run. Le
résultat apparait dans une console intégrée à l’EDI.
20/04/2011 13
POO: Base du langage Java
Structure des programmes JAVA
Les programmes Java se composent de:
• Déclaration de classes et d’interface,

Les classes définissent des variables qui fournissent un accès par nom aux données, des
méthodes qui effectuent des actions consistant en opération sur les données et des
constructeurs qui créent des instances de classes qu’on appelle des objets. Les interfaces
définissent des collections de méthodes implémentées par des classes. Elles servent aussi
à définir des constantes, valeurs de données qui ne peuvent pas être modifiées.
Les programmes Java sont écrits en utilisant une ou plusieurs unités de compilation,
qui sont des fichiers de code source java. Chaque fichier de code source est constitué du
nom de la classe ou de l’interface (suivi de l’extension ‘.java’ ).
Chaque fichier de code source ne peut contenir plus d’une classe ou d’une interface de
type public. Si une classe ou une interface est déclarée publique, le nom de fichier du code
source doit être celui de la classe ou de l’interface suivi de l’extension .java . S’il n’existe
pas de classe ou d’interface publique, le non de fichier peut être différent.
20/04/2011 14
POO: Base du langage Java(2)
Identification des paquetages
Les classes et les interfaces Java sont organisées en paquetage qui leur fournissent un
contexte de nom. En d’autre termes, les paquetages permettent à différents
programmeurs (ou le même) de créer des classes et des interfaces de même nom.
Les paquetages sont identifiés par l’instruction package, qui doit apparaître en première
instruction dans le fichier de code source:
package NomPaquetage;
Si l’instruction package est omise, les classes et les interfaces déclarées dans le paquetage
sont intégrées au paquetage par défaut sans nom.
Outre leur utilisation comme contexte de nommage; les paquetages sont utilisés pour
classer les classes et les interfaces en relation en une seule unité d’API dont l’acces peut
être contrôlé.
Importation de classe et d’interface d’autres paquetages
L’instruction import est utilisé pour referencer des classes et des interfaces déclarées dans
d’autres paquetages(sans avoir à specifier leur nom à chaque reference). L’instruction
import peut se presenter sous trois formes:
• import NomPaquetage.NomClass;
• import NomPaquetage.NomInterface;
• import NomPaquetage;
20/04/2011 15
La méthode main()
La méthode main () est utilisée comme point d’entrée d’un programme applicatif java.
Tous les programmes doivent posséder une méthode main() pour pouvoir s’exécuter.
NB: le paquetage java.lang est toujours importé par défaut. Il est inutile de l’inclure dans
une instruction import.
Par exemple, si le nom du programme est MyProgram, la classe MyProgram doit etre
définie dans un fichier MyProgram.java et disposer d’une méthode main() correctement
définie, dont la forme est ma suivante:

// instructions
}
La méthode main posséde un argument: un tableau d’arguments String. Cet argument
args peut etre désigné sous les formes:
String[] args, String []args, String args[].
Le tableau args est utilisé pour accéder aux arguments de la ligne de commande d’un
programme. Par exemple, pour exécuter le programme MyProgram, il faut saisir :
java MyProgram
Supposons que vous vouliez transmettre les arguments 2 et 3 au programme. L’appel se
ferait ainsi:
java MyProgram 2 3
20/04/2011 16
Le programme ArgsTest montre comment se fait l’acces aux arguments de la ligne de
commande à l’aide du tableau args.
class ArgsTest{
for(int i=0;i<args.length;i++){
System.out.println(‘ args[‘+i+’]=’+args[i]);
}
}
}
java ArgsTest This is a test
Il affiche les resultats suivants :

args[0] = This args[1]=is args[2]=a args[3]=test
Commentaires, Java offre 3 styles de commentaires:
/* Cela est un commentaire sur plusieyr lignes */
// Cela est un commentaire sur une seule ligne
/** Cela est un commentaire javadoc sur plusieurs lignes */

20/04/2011 17
Identificateur et mots clés
Voici des exemples d’identificateur Java valides:
• myIdentifier
• $my_identifier
• $123
Voici des exemples d’identificateur Java incorrects:
• 1badIdentifier
• bad-too
• %badID
Types primitifs et valeurs littérales

Java définit 8 types primitifs. Les variables de ces types ne font pas reference à des
objets. Les types primitifs sont:
byte, short, long, float, double, char et boolean.
20/04/2011 18
POO: Opérateurs et affectations
Opérateurs de Java
Les opérateurs de JAVA tirent leurs origine de C et C++. Si vous êtes programmeurs C ou
C++, préparez vous à de bonnes et de mauvaises nouvelles. La bonne nouvelle est que de
nombreux opérateurs de Java se comportent comme ils le font en C et C++; la mauvaise
est que ce n’est pas le cas pour tous, ce qui peut désarçonner parfois.
Opérateurs arithmétiques unaires
++x (préfixe)
x++ (suffixe)
--x (préfixe)
x-- (suffixe)
exemple:
x=10;
y=++x; // y vaut 11
x=10;
y=x++; // y vaut 10
x=10;
y=--x; // y vaut 9
20/04/2011 19
POO: Opérateurs et affectations(2)
Opérateurs arithmétiques binaires
+ (addition), - (soustraction), * (multiplication), / (division) et % (modulo)
Les opérateurs binaires sont assez simples: ils effectuent un calcul élémentaire sur deux
valeurs numériques. Quelques cas particuliers doivent être pris en considération:
• les opérations effectues sur des opérandes de types différents;
• les arrondis résultats d’une division entière;
•La division par zéro;
• les opérations de modulo;
• les opérations entrainant un dépassement supérieur ou inferieur;
• les opérations entrainant le lancement d une exception.
20/04/2011 20
Promotion numérique
Quand les opérations binaires sont appliquées à des arguments numériques/entiers ou

en virgule flottante, une promotion numérique est effectuée avant d’executer
l’opération. Elle consiste en une conversion de la valeur des opérandes dans un type
commun. Les règles de cette conversion sont les suivantes:
• Si un des opérandes est de type double, l autre est converti en double;
• Si un des opérandes est de type float, l’autre est converti en float;
• Si un des opérandes est de type long, l’autre est converti en long ;
• Sinon les deux opérandes sont convertis en valeurs de type int.
NB: Si un des opérandes est un objet de type String , l’autre est converti en String, si c’
est un objet alors la méthode toString sera appelée.
20/04/2011 21
Division entière et division par zéro
Java comme de nombreux langages, supportent les opérations de division(/) sur les
valeurs entières(long, int, short, char et byte). Pour renvoyer le résultat d’une opération
comme 4/3 sous forme de valeur entière, il arrondit à l’entier le plus proche de zéro, ce
qui signifie tronquer la partie fractionnaire du résultat.
10 / 3 donne 3
-10 / 3 donne -3
10/-3 donne -3
11/3 donne 3
NB: division par zéro d’un entier entraine le lancement de l’exception
ArithmeticException.
Opération modulo
L’ opérateur modulo %, ou reste de la division.
11 % 3 donne 2
-11% 3 donne -2
11%-3 donne 2
-11%-3 donne -2
20/04/2011 22
Dépassement de capacité
Un dépassement de capacité numérique se produit quand le résultat d’un calcul est
plus grand que la plus grande valeur acceptable d’un type donné, ou plus petit que la
plus petite valeur possible. On peut déterminer si une opération risque d’entrainer un
dépassement de capacité en calculant le résultat et en comparant le nombre d’octets
obtenus au nombre d’octets correspondants au type.
Opérateur de comparaison
Les opérateurs de comparaison servent à comparer des valeurs primitives ou des
references aux obejts. Ils sont classés en trois sous groupes:
Les operateurs de relation, d’égalité , et instanceof
Opérateur de relation
(supérieur à), > (inferieur à), <= (inferieur ou égal à) et >= (supérieur ou égal à)
Opérateur d’égalité
== (égal ) et != (non égal ). Ils peuvent être utilisés sur les 8 types primitifs et sur les
références à des objets. Ils renvoient une valeur booléenne. S’ils sont utilisés sur des
valeurs primitives, les règles suivantes s’appliquent:
20/04/2011 23
Opérateur d’égalité
• les valeurs numériques ne peuvent pas être comparées à des valeurs booléennes.
Une telle comparaison entraine une erreur de compilation;
• La promotion numérique se produit avant comparaison des valeurs numériques. Ce

qui permet la comparaison entre tous les types numériques.
NB: Quand les références à des objets sont comparées les operateurs == et != vérifient
si les objets A et B sont une même instance et pas s’ils ont la même valeur.
Par exemple, supposons que les objets A et B soient de la même classe et qu’ils aient
exactement les mêmes valeurs de champs. Si ces objets sont distincts(situés à des
emplacements de mémoire différents), alors A == B renverra false, et A!=B, la valeur
true.
La comparaison de deux objets se fait grâce à la méthode ‘equals()’. Cette méthode est
définie dans la classe Object. Elle permet de dire si deux objets ont la même valeur.
20/04/2011 24
Exemple 1:
class EqualString11
{
public static void main(String args()){
String s = `àb``;
String s1 = s + ``cd``;
String s2 = `àbcd``;
System.out.println(s1);
System.out.println(s1==s2);
}
}
class EqualString22
{
public static void main(String args()){
String s = `àb``;
String s1 = s + ``cd``;
String s2 = `àbcd``;
System.out.println(s1.equals(s2));
}}
20/04/2011 25
Opérateur instanceof
L’operateur instanceof est un operateur binaire qui détermine si une référence à un

objet(l’opérande de gauche) est une instance de la classe, de l’interface ou du tableau
du type spécifié dans l’opérande de droite.
L’operateur instanceof renvoie la valeur booléenne true si l’opérande de gauche fait

référence à un objet de classe C(ou du tableau de type T), de valeur non null, et que
l’une des conditions suivantes est vérifiée(condition non exhaustive):
• l’opérande de droite est une classe C’, et C est une sous classe de C’;
• l’opérande de droite est un interface I et C implémente I;
• l’opérande de droite est un tableau de type T’, l’opérande est un tableau de type T, et
T est une sous classe ou une sous-interface de T’ ou gal à T’.
instanceof renvoie false si aucune des conditions susmentionnées n’est vérifiées ou si

l’opérande de gauche est null.
20/04/2011 26
Opérateur instanceof
Import java.util.*;
class Instance
{
Public static void main(String args())
{
String s = `àbcd``;
Vector v = new Vector();
v.add(s);
Object o = v.elementAt(0);
System.out.println(s instanceof String);
System.out.println(s instanceof Object);
System.out.println(o instanceof String);
System.out.println(o instanceof Object);
System.out.println(o instanceof Vector);
}
}
20/04/2011 27
Opérateur de projection de type
L’operateur de projection (type) est utilisé pour convertir des valeurs numériques d’un
type vers un autre type ou pour modifier la référence à un objet en un type compatible.
Conversion élargie et réduites
Une conversion élargie est une conversion vers un type numérique plus important, par
exemple lorsqu’une valeur byte est promue en type int. Une conversion réduite est une
conversion vers un type numérique inferieur, par exemple de long en short. Dans ce cas
la conversion doit se faire de façon explicite :
double d = 123.456
short t = (short) d; // c’est une conversion réduite
20/04/2011 28
Conversion élargie et réduites
Quand la projection de type est utilisée sur les références aux objets, les règles
suivantes s’appliquent:
1. Toute référence à un objet peut être projetée dans une référence à un objet de
classe Object.
2. Une référence à un objet peut être projetée dans une référence à un objet de
classe C’ si la classe de l’objet est une sous classe de C’.
Exemple:
String s = `àbcd``;
String obj = s;
String str = (String) obj;
Operateur ternaire
operande1 ? Operande2 : Operande3
Si la condition est vraie alors l’operande2 est évaluée au cas contraire c’est
l’operande3 qui est évaluée.
20/04/2011 29
POO: Déclaration et Contrôle d’accés
Les déclarations sont essentielles à l’écriture d’un programme Java. Vous devez savoir
comment déclarer les classes, les interfaces, les variables, les méthodes et les
constructeurs pour pouvoir briquer le titre de programmeur Java. Si les déclarations de
base vous sont sans doute déjà familières, vous tomberez malgré tout sur des points
inconnus ou que vous avez déjà oubliés.
Déclaration et utilisation des variables

Une déclaration de variable sert a identifier le type associé à la variable. Elle peut aussi
servir à initialiser une variable à une valeur particulière de ce type. Les variables
peuvent être déclarées d’un type primitif ou du type d’un objet.
Exemple:
Personne p; //déclaration avec type d’un objet
int i; // déclaration avec type primitif
Les tableaux
Les tableaux sont des objets Java. D’un point de vue technique, les tableaux de java
sont toujours à une dimension. Les tableaux a 2 dimensions sont des tableaux de
tableaux.
Les dimensions d’un tableau peuvent être spécifiées à droite de son type ou à droite de
son identificateur.
20/04/2011 30
POO: Déclaration et Contrôle d’accés(2)
Par exemple, toutes les déclarations de tableau suivantes sont équivalentes:
String[] s;
String []s;
String s[];
String s [];
Pour les tableaux multidimensionnel, on a :
String []s[];
String [][]s;
String s[][];
Remarquez que les dimensions du tableau ne sont pas spécifiées. Un tableau est crée
de deux manières. La plus simple consiste à utiliser un initialiseur de tableau pour le
créer et initialiser ses éléments:
String[] s = { ‘abc’, ‘def’, ‘ghi’}
Les tableaux multidimensionnels peuvent être initialisés en imbriquant les initialiseurs
de tableaux:
int[][] i = {{1, 2, 3}, {4, 5, 6} }
La technique illustrée ci-dessus est pratique pour les tableaux de petites tailles. Pour en créer de
plus grand, il faut utiliser new, suivi du type du tableau et d’un ou de plusieurs groupe de
crochets. La longueur d’une dimension du tableau est indiquée par un entier entre les crochet:
String s = new String[100];
String s = new String[20][30];
20/04/2011 31
Lres objets sont créés à l’aide de l’operateur new et du constructeur de la classe de
l’objet. Par exemple, si un objet est de classe C, on utilise un constructeur de la forme
suivante:
new C(listeArguments)
La liste des arguments doit correspondre aux paramètres effectivement déclarés pour le
constructeur utilisé. Quand un objet est créé, il est habituellement (pas toujours)
affecté à une variable:
C myC = new C (listeArguments);
Les champs et les méthodes de l’objet peuvent ensuite être référencés en utilisant la
variable. Par exemple si C comporte un champ f1 et une méthode m1, on peut accéder
à f1 par myC.f1 et appeler m1 par myC.m1(listeArguments)
Dans certains cas, il n’est pas nécessaire d’enregistrer l’objet nouvellement créé avant
d’y accéder. Par exemple, vous pouvez utiliser new C().m1() pour appeler la méthode
m1 d’un nouvel objet C.
Les mots clés this et super permettent de faire référence à l’instance de l’objet en
cours. Si this est utilisé dans un constructeur, il fait référence à l’objet créé. Quand il est
utilisé dans une méthode non statique, il fait référence à l’objet dont la méthode est
utilisée. Il ne faut pas utiliser this dans une méthode statique, car ces dernières sont
associées à la classe elle-même et pas à une instance de la classe. Le mot clé super
indique la superclasse de l’instance de l’objet en cours.
20/04/2011 32
Variables locales
Les variables locales sont déclarées et initialisées de la même manière que les variables
de champ, mais elles ne peuvent utiliser que le modificateur final, qui identifie les
variables accessibles à partir de classes locales intérieure.
NB: Le modificateur final indique une valeur de variable définitive, qui ne peut plus
être modifiée une fois qu’elle a été attribuée.
Variable de champ
Les variables de champ déclarés avec la syntaxe suivante:
modificateur type déclarateur;
Les modificateurs valides sont des modificateurs d’accés: public, protected et private;
et les modificateurs spéciaux: final, static, transient et volatile.
20/04/2011 33
Déclaration et utilisation des méthodes
Les méthodes sont déclarées selon la syntaxe suivante.
modificateur valeurRetour nomMéthode(listeParametre) throws Clause

{
// corps de la méthode
}
Une méthode peut posséder un modificateur d’accès quelconque (public, protected,
private ou accès de paquetage) ou des modificateurs spéciaux (abstract, final, native,
static ou synchronized).
Le type de valeur de retour d’une méthode peut être:
void: la méthode ne renvoie pas de valeur.

Type primitif: les types primitifs peuvent être utilisés comme type de retour de la
méthode.
Type d’objet: une méthode peut renvoyer une référence à un objet d’une classe ou
interface quelconque.
Type de tableau: Une méthode peut renvoyer une référence à un tableau Java. Le type
renvoyé est spécifié comme le type du tableau.
20/04/2011 34
Déclaration et utilisation des méthodes
Une liste de paramètre de méthode est une liste de déclaration de paramètres séparés
par des virgules, chaque déclaration identifiant le type du paramètre et un nom de
référence. Un paramètre peut être référencé n’importe ou dans la méthode.
La clause throws d’une méthode identifie tous les types d’exception vérifiées qui
peuvent être lancés durant l’exécution d’une méthode. Cela comprend des exceptions
lancées par d’autres méthodes appelées par la méthode. Exemple d’appel de méthode:
variable.nomMethode(listeArguments)
Les mots clés this et super peuvent être utilisés à la place d’un nom de variable.
La signature d’une méthode se compose du nom de la méthode et de l’ensemble des

types de déclarations de ses paramètres. Il est illégal dans une classe de déclarer deux
méthodes ayant la même signature.
Les méthodes statiques sont des méthodes qui s’appliquent à la classe dans son
ensemble et pas simplement à une de ses instances. Les méthodes statiques sont
appelées de la même manière que les autres. Mais comme elles ne sont pas associées à
une instance de la classe, il est plus logique d’y faire référence en utilisant le nom de la
classe au lieu d’un nom de variable.
20/04/2011 35
Transmission des arguments
Un argument transmis à une méthode peut être une valeur primitive ou une référence
à un objet.
dans le premier cas, une copie de la valeur primitive est effectuée et mise à la
disposition de la méthode. La valeur d’origine n’est pas modifiée par les opérations qui
peuvent affecter l’argument dans la méthode.
Exemple:
class PassedValue{
public static void main(String args[]){

StaticClass.display(‘Exemple de résultat’);
}
}
class StaticClass{
Static void display(String s){

System.out.println(‘StaticClass: ’ + s);
}
}
20/04/2011 36
Transmission des arguments(suite)
Un argument transmis à une méthode peut être une valeur primitive ou une référence
à un objet.
dans le deuxième cas, une copie de la référence à l’objet est effectuée. Les
modifications à la référence de l’objet se produisant durant l’exécution de la méthode
n’affectent pas la référence de l’objet d’origine. Mais les modifications effectuées sur
l’objet lui-même dans la méthode affectent l’objet d’origine.
Exemple:
class PassedReference{
Vector v = new Vector();
v.add(new String(‘a’));
v.add(new String(‘b’));
System.out.println(v);
modifyReference(v);
modifyReferenceObject(v);
}
// suite de la definition de la classe à la page sivante
20/04/2011 37
Transmission des arguments(suite)
static void modifyReference(Vector v) {
v = new Vector();
v.add(new String(‘1’));
v.add(new String(‘2’));
static void modifyReferenceObject(Vector v) {
v.removeAllElements();
v = new Vector();
v.add(new String(‘n’));
v.add(new String(‘m’));
}
} // fin de la définition de la classe
20/04/2011 38
Modificateurs d’accès
Java propose trois modificateurs d’accès(public , protected et private) et un accès par
défaut (accès de paquetage) .
public permet l’accès à une classe ou à une interface en dehors de son paquetage. Il
permet aussi l’accès à une variable, une méthode ou un constructeur à partir de tout
emplacement d’où l’on peut accéder à sa classe.
protected permet l’accès à une variable, une méthode ou un constructeur à partir de

classes ou d’interface du même paquetage ou de sous-classes de la classe dans laquelle
il est déclaré.
private interdit l’accès à une variable, une méthode ou un constructeur à partir d’autres
classes que celle ou il est déclaré.
Accès de paquetage il se produit lorsque public , protected ou private ne sont pas

spécifiés. Il s’applique aux classes, interfaces, variables, méthodes et constructeurs. Il
permet l’accès à l’élément déclaré à partir de toute classe ou interface du même
paquetage.
20/04/2011 39
Modificateurs d’accès
Abstract le modificateur abstract est utilisé pour identifier des classes et des méthodes
abstraites. Une classe abstraite reporte son implémentation dans ses sous-classes et ne
peut pas avoir d’instances. Les classes abstraites peuvent définir des méthodes
abstraites. Une méthode abstraite est une méthode dont l’implémentation est différée
Abstract class Meeting{
abstract void formatDate();
final, il est utilisé pour indiquer qu’un élément déclaré ne peut pas être changé. Quand
il est utilisé sur une classe, il empêche toute extension de la classe. Utilisé sur une
variable de champ , il indique qu’elle ne peut pas être modifiée une fois qu’une valeur
lui a été attribuée. Les variables de type final servent à créer des constantes.
static, il est utilisé pour indiquer qu’une variable, une méthode s’applique à une classe
dans son ensemble.
20/04/2011 40
Exemple:
class StaticApp{
static String s = ‘ce code est partout’;

String t= ‘ce code est limité’;
}
display(s);
StaticApp app = new staticApp();
App.display(app.t)
}
static void display(String s){

System.out.println(s);
}
20/04/2011 41
Le modificateur native est utilisé pour identifier une déclaration de méthode native.
Les méthodes natives sont écrites dans d’autres langages que Java. L’interface JNI(Java
Native Interface) permet aux programmes Java d’accéder aux méthodes natives
disponibles dans les bibliothèques dynamiques partagées. Les méthodes de type native
sont déclarées avec la syntaxe suivante:
modificateur native typeRetour nomMethode(listeParametres) throws Clause
{
// corps de la méthode
}
Exemple:
class HelloWorld {
static {
System.loadLibrary("HelloWorld");
}
private native void print();
public static void main(String[] args) {

new HelloWorld().print();
}
}
20/04/2011 42
POO: Contrôle du deroulement et gestion des exceptions
Instruction de sélection
Java comporte deux instructions, if et switch, permettant de sélectionner des chemins
d’exécution différents.
NB: L’instruction if est utilisée quand il n’y a qu’une alternative, alors que switch peut
être utilisée quand il y’a de nombreux choix différents.
L’instruction if est utilisée quand il n’y a qu’une alternative, alors que switch peut être
utilisée quand il y’a de nombreux choix différents.
L’instruction if de Java est identique à son homonyme en C ou C++. Sa syntaxe est la

suivante:
if(expression booléenne) instruction1;
ou
if(expression booléenne) instruction1; else instruction2;
Dans la première forme, si l’expression booléenne est vraie, instruction1 est exécutée.
Sinon, l’exécution se poursuit à l’instruction qui suit l’instruction if.
Dans la deuxième forme, si l’expression booléenne est vraie, instruction1 est exécutée.
Sinon, l’instruction2 est exécutée.
20/04/2011 43
POO: Contrôle du deroulement et gestion des exceptions(2)
Instruction if, Exemple:
if(i < 3) System.out.println(‘i est supérieur à 3’);

else
System.out.println(‘i est inférieur à 3’);
Dans les deux formes de l’instruction if, un bloc d’instruction peut être substitué à
l’instruction1 et instruction2. Les instructions if peuvent être imbriquées.
Exemple:
if(s.equals(‘ajouter’)){
String text = textArea.getText();
if(!text.equals(‘ ’)) text += ‘\n’ + textField.getText();
else
text = textField.getText();
textArea.setText(text);}
else
if(s.equals(‘effacer’))
textArea.setText(‘ ’);
20/04/2011 44
L’instruction switch provient aussi de C ou C++. Sa syntaxe est la suivante:
switch(expression entiére) {
case n1: instructions
case n2: instructions

.
.
case nm: instructions
default: instructions
}
L’expression entiére doit pouvoir etre evaluée en valeur de type int ou pouvoir etre
promue dans ce type(c’est-à-dire byte, char ou short). Les étiquettes des instructions
case(n1,n2,…..,nm) doivent être des expressions costantes pouvant être evaluées par le
compilateur. L’étiquette default est facultative.
20/04/2011 45
Exemple:
class SwitchText{
n =3;
switch(n) {
case 1: System.out.println(1);
default: System.out.println(‘default’);
}
}
}
Resultat:
3
4
5
default
20/04/2011 46
Exemple:
class SwitchText{
n =3;
switch(n) {
case 1: System.out.println(1); break;
default: System.out.println(‘default’);}
}}
Resultat:
3
L’instruction break est utilisé pour transférer l’exécution hors d’un bloc d’instruction.
Elle peut être utilisée avec ou sans label, l’instruction break entraine le transfert du
contrôle de l’exécution hors de l’instruction switch, for, do ou while qui la contient
directement. Utilisé avec un label, elle transfère le contrôle vers l’instruction dont
l’étiquette correspond.
20/04/2011 47
Instruction d’itération
Java propose 3 types d’instruction d’itération: for, while et do. Elles servent à répéter
l’exécution d’une instruction ou d’un bloc d’instruction jusqu’à ce qu’une condition de
fin se produise.
Exemple:
n = 5;
for(int i=0; i<n; ++i){
j= i%2;
System.out.println(‘i = ’+ i + ’ j= ’ + j );
}
Syntaxe de l’instruction for:
for(initialisation; expression booléenne; itération)

bloc d’instruction
20/04/2011 48
Instruction continue
Il ressemble à l’instruction break en ce qu’elle sert à modifier l’exécution des
instructions for, do et while. Elle peut de même être utilisé avec ou sans label. Si elle est
utilisé sans label, elle entraine la fin de l’exécution en cours du bloc qui la contient.
Exemple:
n = 5;
for(int i=0; i<n; ++i){
j= i%2;
if(j == 1) continue;
System.out.println(‘i = ’+ i + ’ j= ’ + j );
}
class continueTest{
public static void main(String[] args)
{ outerloop: for(int i = 0; i < 5; ++i)
{ innerloop: for(int j = 0; j < 5; ++j)
{ if((i+j) % 5 == 0) continue outerloop;
if((i+j) % 5 == 3) continue innerloop;
System.out.println(‘i = ’+i+’, j = ‘ + j);}
}
}}
20/04/2011 49
Instruction while
L’instruction while, comme l’instruction for, répète l’exécution d’une instruction ou d’un
bloc d’instructions.
while(expression booléenne)
instruction;
ou
while(expression booléenne)
{
instructions
}
Exemple:
class WhileTest{
{ boolean finished = false;
while(!finished)
{ double d = Math.random();
if(d > 0.5) finished = true;
System.out.println(d);}
}
}}
20/04/2011 50
Instruction do
do instruction while(expression booléenne)

instruction;
ou
do
{
instructions
} while(expression booléenne)
Exemple:
class DoTest{
{ boolean finished = false;
do { double d = Math.random();
if(d > 0.5) finished = true;
System.out.println(d);} while(!finished);
}
}}
20/04/2011 51
Exception
Java offre un excellent support des erreurs d'exécution et de gestion des exceptions, qui
permet aux programmes de vérifier les conditions anormales et d’y réagir avec un
impact réduit sur le déroulement du programme. Il permet d’ajouter facilement le code
de gestion des erreurs et exception aux méthodes existantes.
Les exceptions sont générées par le système d'exécution Java en réaction a des erreurs
détectés au chargement des classes ou lors de l’exécution de leurs méthodes.
Les exceptions a l’exécution sont des objets des classes:

1. java.lang.RuntimeException
2. Java.lang.Error
3. ou de leur sous-classes
Les exceptions peuvent aussi être lancées directement par le code java utilisant
l’instruction throw.
Les exceptions lancées par les programmes utilisateurs ne sont généralement pas des
objets d’une sous-classe de RuntimeException; On parle alors d’exception contrôlées ou
de programme.
20/04/2011 52
Exception
Les exceptions, de programme et à l’exécution, doivent être interceptées pour être

traitées par le code de gestion des exceptions. Si une exception lancée n’est pas
interceptée, son thread se termine et un message d’erreur s’qffiche sur la console Java.
L’instruction throw
Les exceptions sont lancées par l’instruction throw. Sa syntaxe est la suivante:
throw Expression;
Exemple: throw new TestException ();
Expression doit être une instance de la classe java.lang.throwable
Quand une exception est lancée, l’exécution ne se poursuit pas après l’instruction
throw, mais dans le code qui intercepte l’ exception.
20/04/2011 53
Exception
La clause throws (avec un s sur throw) d’une méthode liste les types d’exceptions
pouvant être lancées durant l’exécution d’une méthode.
public void ExampleMethod() throws ExampleException {
// corps de la methode
Si la méthode est susceptible de générer plus d’une exception, on peut avoir par
exemple:
Public void TextMethode(int i) throws TestException1, TestException2 {
if( i == 1) throw new TestException1();

if( i== 2) throw new TestException2();
20/04/2011 54
Exception
Si une exception de programme peut être lancée durant l’exécution d’une méthode,
cette dernière doit intercepter l’exception ou la déclarer dans sa clause throws. Cette
règle s’applique même si l’exception est lancée dans d’autres méthodes appelées dans
l’exécution de la méthode.
Supposons par exemple que la méthode A de l’objet X appelle la méthode B de l’objet Y

qui appelle la méthode C de l’objet Z.
Si la méthode C lance une exception; elle doit être interceptée par la méthode C ou
déclarée dans sa clause throws. Si elle n’est pas interceptée dans C, elle doit être
interceptée par la méthode B ou déclarée dans sa clause throws. Pareil pour la suite de
B à A.
20/04/2011 55
Exception
Instruction try – catch – finally
try {
// instructions pouvant générer une exception
} catch(Paramètre) {
// instructions pour la gestion de l’exception
} finally {
/* instructions qui doit s’exécuter indépendamment qu’il y ait exception ou pas.

En cas d’exception; le bloc d’instruction finally s’exécute après le catch. */
20/04/2011 56
POO: Classe et Héritage
Java et la programmation orientée Object
Une des nombreuses caractéristiques de Java est son support complet de la
programmation orientée objet. Java fournit tous les points essentiels:
1. Réutilisation des objets
2. Hiérarchie des classes
3. Héritage
4. Encapsulation
5. Polymorphisme
6. Liaisons dynamiques
Composition et réutilisation des objets

Composer ou créer un objet à partir d’autres est le cœur de la programmation orientée
objet. Cela permet de construire des objets plus complexes en partant de blocs de
construction plus simples.
Classification et Héritage
La réutilisation des objets ne se limite pas à leur composition. Elle exploite aussi une
capacité puissante de la programmation orientée objet connue sous le nom d’héritage.
l’héritage permet non seulement aux objets d’être utilisés en tant que tels; mais il
autorise la création de nouveaux objets obtenus par extension et façonnage d’objets
existants.
20/04/2011 57
POO: Classe et Héritage(2)
Polymorphisme
Le polymorphisme est la capacité à prendre plusieurs formes. Dans la programmation
orientée objet, cela fait référence à la capacité qu’ont les objets à disposer de plusieurs
méthodes de même nom, mais avec différents types d’arguments.
Déclaration des classes
Les classes sont déclarées par la syntaxe suivante:
modificateurs class NomClass extends Clause implements Clause {
// corps de la classe
Les modificateurs et les clauses extends et implements sont facultatives. S’ils sont
présents, ils sont utilisés ainsi:
20/04/2011 58
Modificateurs
Une classe de sommet peut être déclarée avec les modificateurs public, final ou
abstract. L’ accès à une classe publique peut se faire de l’ extérieure de son paquetage.
Si une classe n’est pas déclarée comme publique, seules les classes et les interfaces
faisant partie du même paquetage peuvent y accéder. Une classe finale ne peut être
étendue; cela génère une erreur de compilation. Une classe abstraite déclare une ou
plusieurs méthodes abstraites. Comme une méthode abstraite doit être remplacée par
une méthode qui a du corps(pour être utilisable), sa déclaration implique qu’elle sera
étendue par une ou plusieurs classes qui fourniront l’implémentation des méthodes
abstraites. Une classe ne peut pas être à la fois final et abstraite.
Clause extends
Elle se compose du mot clé extends suivi du nom de la classe étendue par la classe
déclarée. La classe identifiée dans la clause extends est dite clase parent ou superclasse
direct de la classe déclarée. Une classe ne peut avoir qu’un parent. Si la clause extends
est omise, la classe étend par défaut java.lang.Object .
20/04/2011 59
Clause implements
Elle identifie les interfaces implémentées par une classe. Elle se compose du mot clé
implements suivi par une liste de noms d’interfaces séparés par des virgules. Pour
qu’une classe implémente une interface, elle doit fournir une méthode de même
signature que chacune des méthodes définies dans l’interface et héritées de toutes les
interfaces étendues par l’interface.
Clause extends
Elle se compose du mot clé extends suivi du nom de la classe étendue par la classe
déclarée. La classe identifiée dans la clause extends est dite clase parent ou superclasse
direct de la classe déclarée. Une classe ne peut avoir qu’un parent. Si la clause extends
est omise, la classe étend par défaut java.lang.Object . Une classe abstraite doit fournir
des méthodes abstraites. Une classe non abstraite doit fournir des méthodes non
Abstraites. Si une classe doit implémenter une interface cette dernière doit être
identifiée dans la clause implements de la classe ou d’une de ses superclasses.
NB: Le corps de la classe déclare des membres (variables de champ et méthodes), des
constructeurs et des initialiseurs. Les membres de classe peuvent aussi être des classes
ou des interfaces intérieures.
20/04/2011 60
Construteurs
Les objets sont des instances de classes crées en utilisant des constructeurs.
modificateurs NomClass(arguments) throws {
//corps du constructeur
Les modificateurs, les arguments et la clause throws sont facultatifs. Les modificateurs
valides sont : public, protected, private .
Si aucun modificateur n’est indiqué, le constructeur n’est accessible que dans le
paquetage où il est déclaré.
NB: une différence importante entre les constructeurs et les méthodes est que les
premiers ne sont pas hérités. Chaque classe doit définir son propre constructeur.
20/04/2011 61
this() et super()
Dans certains cas, il peut être souhaitable de définir plusieurs constructeurs, chacun
utilisant un sous ensemble des arguments servant à créer un objet.
Un constructeur prend tous les arguments et fournit le code de création de l’objet,
tandis que les autres utilisent une liste partielle d’arguments, fournissent des valeurs
par défaut et appellent le constructeur principal.
NB: si this() apparait dans un constructeur, il doit en être la première instruction.

Si this() ou suoer() est utilisé dans un constructeur , il doit être la première instruction.
Ce qui signifie que l’un ou l’autre peut être utilisé, mais pas les deux à la fois.
Si aucun n’est indiqué, le compilateur fournit un appel super() (sans arguments)

implicite. Ce qui entraine la création de la partie de la superclasse d’un objet avant la
classe elle-même. Si une superclasse ne comporte pas de constructeur sans paramètre,
un appel explicite de constructeur doit être effectué dans les constructeurs de ses sous-
classes.
20/04/2011 62
public class Box{
double x,y,width, height;
public Box(double x, double y, double width, double height){

this.x = x;
this.y=y;
this.width = width;
this.height = height;
public Box(double x, double y){

this(x, y, 10, 10);
}
public Box(){
this(1, 1);
}
}
20/04/2011 63
import java.awt.Color;
public class MyBox extends Box{
Color outerColor;
Color innercolor;
public MyBox(double x, double y, double width, double height,

Color outer, Color inner){
super(x,y,width,height);
this.outerColor = outer;
this.innerColor = inner;
}
public MyBox(Color outer, Color inner){

super(10, 10, 100, 100);
}
public MyBox(){
super();
}
}
20/04/2011 64
Dans d’autres cas, au lieu d’appeler le constructeur de la même classe que l’objet en
création, il faut appeler le constructeur de sa superclasse. Pour cela, il faut utiliser
l’instruction d’appel de constructeur de superclasse, super().
La classe MyBox étends la classe Box et permet de spécifier les couleurs de contours et
de l’intérieur. Le premier constructeur utilise super(x, y, width, height) pour appeler le
constructeur de la superclasse Box et initialiser la position et les dimensions.
20/04/2011 65
Vehicule
Spatial Aquatique
Aéronautique Terrestre
Automotrice
Motricité
humaine
2 roues 4 roues
Voiture Camion
20/04/2011 66
public class Terrestre extends Vehicule{}
public class Automotrice extends Terrestre{}
Vehicule
Terrestre
Automotrice
20/04/2011 67
Déclaration des interfaces
Une interface définit une collection de méthodes implémentées par une classe. Elle
peut aussi être utilisée pour définir des constantes, des classes et des interfaces
intérieures. La syntaxe d’une déclaration d’interface est la suivante:
modificateurs interface Nominterface extends Clause{
// corps de l’interface
}
Une interface peut utiliser les modificateurs: public et abstract. Cependant, l’utilisation
de abstract est redondante: toutes les interfaces sont abstraites, car elles ne déclarent
que les méthodes abstraites. Une interface publique est accessible en dehors de son
paquetage.
La clause extends se compose du mot clé extends suivi d’une liste des interfaces
étendues, séparées par des virgules. Une interface qui en étend d’autres hérite de
toutes leurs constantes et méthodes.
20/04/2011 68
Surcharge de méthode
Le polymorphisme a déjà été mentionné comme une caractéristique importante des

langages de programmation orientée objet. La surcharge de méthode est le mode
d’implémentation principal du polymorphisme dans Java. Elle consiste à utiliser le
même nom de méthode avec différents types d’arguments et de type de retour dans la
même classe. Les méthodes surchargées peuvent avoir des types de retour différents.
Mais il est illégal de définir deux méthodes ayant les mêmes arguments et un type de
retour différent.
Les méthodes surchargées doivent avoir le même nom, mais des arguments différents.
Remplacement de méthodes
Quand une classe étend sa superclasse, elle hérite de toutes ses méthodes non privées.
Dans certains cas, il peut être souhaitable de redéfinir certaines méthode de même
nom avec des arguments différents, c’est la surcharge. Si les arguments sont les mêmes
, c’est du remplacement. Les règles suivantes s’appliquent au remplacement:
20/04/2011 69
Remplacement de méthodes
1. Les méthodes remplaçantes (de la sous-classe) et remplacée (de la superclasse)

doivent renvoyer le même type.
2. L’ accessibilité de la méthode remplaçante ne doit être plus restrictives que celle

de la méthode remplacée.
3. La clause throws de la méthode remplaçante ne doit spécifier que les exceptions

qui se trouvent dans la clause throws de la méthode remplacée.
4. Toute exception lancée par la méthode remplaçante puisse être lancée par la
méthode remplacée. L’exception doit donc être une sous-classe d’une exception
lancée par la méthode remplacée.
20/04/2011 70
POO: Threads
Fonctionnement du multithread
Les programmes multithread supportent plus d’un thread d’exécution simultané: c’est-à-dire qu’ils
sont capables d’exécuter en même temps plusieurs séquences d’instructions, chacune disposant de
son propre contrôle de déroulement . Ces suites d’instructions exécutées indépendamment sont
appelées des threads. Dans un système monoprocesseur seul un thread s’exécute à un instant donné,
mais le processeur permute rapidement entre plusieurs threads pour donner l’illusion qu’ils
s’exécutent en même temps. Dans ce type de système cette simultanéité est logique. Sur les systèmes
multiprocesseurs , plusieurs threads s’exécutent effectivement en même temps; la simultanéité est
physique. La caractéristique importante des programmes multithread est qu’ils supportent la
simultanéité logique en plus de la simultanéité physique.
Multiprogrammation vs Multithread
De nombreux langages de programmation gèrent la multiprogrammation, qui est l’exécution logique
simultanée de plusieurs programmes. Par exemple, un programme peut demander au système
d’exploitation d’exécuter les programmes A, B, et C en créant un processus séparé chacun. Ces
programmes peuvent s’exécuter en parallèle , suivant les possibilités offertes par le système
d’exploitation sous-jacent.
Le multithread diffère de la multiprogrammation en ce qu’il offre la simultanéité dans le contexte d’un
processus unique, alors que la multiprogrammation offre la simultanéité entre processeurs.
Les threads ne sont pas des processus complets en eux même ; ils sont un déroulement de contrôle
indépendant qui se produit dans un processus.
20/04/2011 71
POO: Threads(2)
Programme 1 Processeur 1
. .
. . Multiprogrammation
. .
.
Programme n Processeur m
Thread 1-1
Programme 1 Processeur 1
Thread 1-j
. .
. . Multithreading
. .
.
Thread n-1
Programme n Processeur m
Thread n-j
20/04/2011 72
POO: Threads(3)
Création de Thread
Java offre le support du multitread en natif, centré sur la classe java.lang.Thread. La classe Thread offre
la capacité de créer des objets disposant chacun de leur propre déroulement de contrôle. Le support
minimum du multithread exigé par a classe Thread ou d’autres classes supportant le multithread est
spécifié dans l’interface:
java.lang.Runnable
Elle définit une méthode importante: run()

Qui fournit le point d’entrée d’un nouveau thread. La classe Object supporte le multithread
par des méthodes: wait(), notify(), notifyAll()
Qui permettent aux threads de suspendre leur exécution pour attendre des ressources de
traitement, et d’être informé du moment ou ils peuvent la reprendre, lorsque les
ressources deviennent disponibles. D’autres classes du paquetage java.lang .
Java propose deux approches pour la création de threads:
1. La première consiste à créer une sous-classe de la classe Thread et à remplacer la

méthode run() pour donner un point d’entrée d’exécution du thread. A la création
d’une instance de la sous classe de thread, il faut appeler la méthode start() pour que
le thread s’exécute de manière indépendante. La méthode start() est héritée de la
classe Thread. Elle initialise l’objet Thread et appelle la méthode run(). (Voire exemple 1)
20/04/2011 73
POO: Threads(4)
Création de Thread
2. L’autre méthode de création de thread java consiste à déclarer une classe qui
implémente l’interface java.lang.Runnable. Il se compose d’une seule méthode run(),
que votre classe doit remplacer. La methode run() fournit le point d’entrée de
l’exécution du thread. Pour qu’un objet de votre classe s’exécute comme un thread
indépendant, il faut le transmettre en argument à un constructeur de la classe
Thread.(Voire exemple 2).
20/04/2011 74
POO: Threads(5)
public class Thread1 extends Thread{
Static String message[] ={‘’ Java‘’, ‘’est’’, ‘’un langage’’, ’’nouveau’’, ’’et’’, ’’interessant.’’}
Thread1 thread1 = new Thread1(‘’ Thread1: ‘’);

thread1.start();
thread2.start();
boolean thread1IsAlive = true;
boolean thread2IsAlive= true;
do{
if(thread1IsAlive && !thread1.IsAlive())
{ thread1IsAlive = false;
System.out.println(‘’ Thread1 est mort‘’);
}
}
}while(thread1IsAlive II thread2IsAlive);
} // fin du main
Public Thread1(String id){ super(id); }
public void run(){

String name = getName();
for(int i = 0; i < message.length; ++i)
{ randomWait();
System.out.println(name + message[i]); }
20/04/2011 75
POO: Threads(6)
void randomWait(){
try{
sleep((long)(3000 * Math.random()));
} catch(InterruptedException x){
System.out.println(‘’Interrompu ‘’);
}
}
}
L’approche de création de threads de l’exemple 1, est très simple. Elle a cependant l’inconvénient
d’exiger que les objets Thread se trouvent dans la hiérarchie des objets en dessous de la classe
Thread. Dans certains cas, par exemple les applets, cette restriction peut parfois être limitative.
20/04/2011 76
POO: Threads(7)
public class Thread2{
static void main(String args[]){
Thread1 thread1 = new Thread(new MyClass(‘’ Thread1: ‘’));

Thread1 thread2 = new Thread(‘new MyClass(’ Thread2: ‘’));
thread1.start();
thread2.start();
do{
}
}
} // fin du main
20/04/2011 77
POO: Threads(8)
public class MyClass implements Runnable{
static String message[] ={‘’ Java‘’, ‘’est’’, ‘’un langage’’, ’’nouveau’’, ’’et’’, ’’interessant.’’}
String name;
public MyClass(String id){
this.name = id;
}
public void run(){

String name = getName();
for(int i = 0; i < message.length; ++i)
{ randomWait();
System.out.println(name + message[i]); }
void randomWait(){
try{
}
}
20/04/2011 78
POO: Threads(9)
Etats des threads
Prêt. Lorsque un thread est crée, il ne commence pas tout de suite son exécution. Il faut d’abord
appeler la méthode start(); le planificateur de thread doit ensuite allouer un temps de processeur. Un
thread peut aussi entrer en état prêt si, après une précédente exécution, arrêté pour un temps , il
redevient prêt pour reprendre son exécution.
En exécution. Les threads étant faits pour être exécutés, cet état signifie qu’il est effectivement en
train de s’exécuter. Il peut quitter cet état pour plusieurs raisons que nous expliquerons plus tard.
En attente. Un thread en exécution peut affecter plusieurs actions qui entrainent sa mise en attente.
Mort. Les threads sont qualifiés de mort quand leur traitement est terminé.
En attente
prêt En exécution mort
20/04/2011 79
POO: Threads(10)
Un thread commence par être en état prêt, puis il entre en état d’exécution quand le planificateur de
thread le programme. Il peut être préempté par d’autres threads et remis en état prêt ou en attente.
Pour qu’il s’exécute à nouveau, il doit revenir à l’état prêt. Au final , le thread termine son exécution et
passe à l’état mort.
Planification
L’examen du diagramme d’état de la figure précédente pet amener à se poser la question de savoir ce
qui faire passer un thread d’un état à l’autre.
Un thread passe sans arrêt de l’état prêt à l’état d’exécution et réciproquement, car le multithread
exige un partage du temps d’exécution entre les threads, en fonction de la disponibilité du ou des
processeurs du système. La méthode utilisée pour déterminer quel thread doit s’exécuter à un instant
donné est la planification(Scheduling). Elle est exécutée par le système d’exécution Java. Elle
programme l’exécution des threads en fonction de leur priorité. Les threads de haute priorité sont
exécutés avant ceux de priorité faible. Les threads de même priorité ont la même chance de
s’exécuter. Ces règles définissent la planification des threads mais les détails dépendent de la
plateforme. La plupart des systèmes d’exploitation supportent une des deux approches courantes de
planification des threads:
Préemption: le thread de plus ahute priorité continue à s’exécuter jusqu’à sa mort, une mise en
état d’attente ou la préemption par un thread de plus haute priorité. Ce dernier cas peut résulter
d’une baisse de priorité du thread ou de la création d’un thread de plus haute priorité.
20/04/2011 80
POO: Threads(11)
Découpage de temps: un thread de plus haute priorité s’exécute sur une tranche de temps
définie, puis entre en état prêt. Le planificateur de thread détermine alors s’il doit remettre en état
d’exécution ou en planifier d’autre.
NB: La priorité d’un thread est une valeur entière comprise entre MIN_PRIORITY et MA_PRIORITY. Ces
constantes sont définies dans la classe Thread. La priorité d’un thread est définie à sa création; elle est
la même que celle du thread créateur. La priorité par défaut d’un thread est NORM_PRIORITY. La
méthode setPriority() permet de modifier la priorité d’un thread.
La manière la plus simple pour qu’un thread entre dans l’ état prêt est qu’il appelle la méthode yield()
. C’est une méthode statique de la classe Thread qui renvoie le thread à l’état prêt. Il passe alors en
état d’exécution, à la discrétion du planificateur.
Sommeil et Réveil
Comme le montrent les deux exemples, un thread peut etre en etat d’attente en appelant sa méthode
sleep().
Un autre thread peut réveiller le thread en attente en appelant la méthode interrupt() du thread
endormi, ce qui le remet en état prêt.
20/04/2011 81
POO: Threads(12)
Java permet de coordonner les actions de plusieurs threads à l’aide des méthodes et des instructions
synchronisées. Les méthodes synchronisées servent à coordonner l’accès aux objets partagés entre
threads. Elles sont déclarées par le mot clé synchronized. Une seule méthode synchronisée est
appelée sur un objet donné, elle cherche à acquérir le verrou sur cet objet. Si elle réussit, aucune
autre méthode synchronisée ne peut être appelée sur cet objet tant qu’il n’est pas libéré. Le verrou est
libéré automatiquement quand la méthode s’achève. Il peut aussi l’être si une méthode synchronisée
exécute certaines méthodes, comme wait().
20/04/2011 82
POO: Threads(8)

thread1.start();
thread2.start();
do{
}
}
} // fin du main
Public Thread3(String id){ super(id); }
public void run(){ SynchronizedOutput.displayList(getName(), message); }
20/04/2011 83
POO: Threads(8)
void randomWait(){
try{
}
}
} // fin de la classe Thread3
Class SynchronizedOutput{
public static synchronized void displayList(String name, String List){
for(int i=0; i.list.length;++i){
Thread3 t =(Thread) Thread.currentThread();

Tt.randomWait();
System.out.println(name + list[i]);
}
}
20/04/2011 84
POO: Threads(9)
L’instruction synchronized
L’instruction synchronized est identique à une méthode synchronisée en ce qu’elle sert à acquerir un
verrou sur un objet avant d’effectuer une action. Elle différe par le fait qu’elle peut etre utilisée sur le
verrou de tout objet; La méthode synchronisée ne pouvant s’appliquer que sur le verrou de son objet.
Une autre différence est que l’instruction s’applique à un bloc d’instruction, et pas à toute une
méthode. La syntaxe de l’instruction synchronized est la suivante:
synchronized(objet){
Instruction(s)
Les instructions entre accolades ne sont exécutées que lorsque le thread actuel acquiert le verrou de
l’objet ou de la classe entre parenthése.
20/04/2011 85
POO: Threads(10)

thread1.start();
thread2.start();
do{
}
}
} // fin du main
public Thread1(String id){ super(id); }
20/04/2011 86
POO: Threads(11)
public void run(){
synchronized(System.out){
for(int i=0; i < message.length; ++i){
randomWait();
Systm.out.println(getName() + message[i]);
}
void randomWait(){
try{
}
}
20/04/2011 87
POO: Les Collections
Les collections
Les collections sont des objets qui permettent de gérer des ensembles d'objets. Ces ensembles de
données peuvent être définis avec plusieurs caractéristiques : la possibilité de gérer des doublons, de
gérer un ordre de tri, etc. ...
Chaque objet contenu dans une collection est appelé un élément.
Cette section contient plusieurs concepts :
Présentation du framework collection
Dans la version 1 du J.D.K., il n'existe qu'un nombre restreint de classes pour gérer des ensembles de
données :
Vector
Stack
Hashtable
Bitset
20/04/2011 88
POO: Les Collections(2)
Les interfaces à utiliser par des objets qui gèrent des collections sont :
Collection : interface qui est implémentée par la plupart des objets qui gèrent des
collections
Map : interface qui définit des méthodes pour des objets qui gèrent des collections sous la
forme clé/valeur
Set : interface pour des objets qui n'autorisent pas la gestion des doublons dans
l'ensemble
List : interface pour des objets qui autorisent la gestion des doublons et un accès direct à
un élément
SortedSet : interface qui étend l'interface Set et permet d'ordonner l'ensemble
SortedMap : interface qui étend l'interface Map et permet d'ordonner l'ensemble

Certaines méthodes définies dans ces interfaces sont dites optionnelles : leur définition est
donc obligatoire mais si l'opération n'est pas supportée alors la méthode doit lever une
exception particulière. Ceci permet de réduire le nombre d'interfaces et de répondre au
maximum de cas.
20/04/2011 89
Le framework propose plusieurs objets qui implémentent ces interfaces et qui peuvent
être directement utilisés :
HashSet : HashTable qui implémente l'interface Set

TreeSet : arbre qui implémente l'interface SortedSet
ArrayList : tableau dynamique qui implémente l'interface List
LinkedList : liste doublement chaînée (parcours de la liste dans les deux sens) qui
implémente l'interface List
HashMap : HashTable qui implémente l'interface Map
TreeMap : arbre qui implémente l'interface SortedMap
Le framework définit aussi des interfaces pour faciliter le parcours des collections et leur
tri :
Iterator : interface pour le parcours des collections

ListIterator : interface pour le parcours des listes dans les deux sens et modifier les
éléments lors de ce parcours
Comparable : interface pour définir un ordre de tri naturel pour un objet
Comparator : interface pour définir un ordre de tri quelconque
20/04/2011 90
Les interfaces des collections
Le framework de java 2 définit 6 interfaces en relation directe avec les collections qui sont
regroupées dans deux arborescences :
Le JDK ne fourni pas de classes qui implémentent directement l'interface

Collection.
Le tableau ci dessous présente les différentes classes qui implémentent les

interfaces de bases Set, List et Map :
20/04/2011 91
Set
List Map
collection
collection avec collection sous la
d'éléments
doublons forme clé/valeur
uniques
ArrayList, Vector
Tableau redimensionnable
(JDK 1.1)
Arbre TreeSet TreeMap

Liste chaînée LinkedList
HashMap,
Collection utilisant une table de
HashSet HashTable (JDK
hashage
1.1)
Classes du JDK 1.1 Stack
20/04/2011 92
L'interface Collection
Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon
assez générale. Elle est la super interface de plusieurs interfaces du framework.
Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de
l'interface Collection. Cette interface est une des deux racines de l'arborescence des
collections.
Cette interface définit plusieurs méthodes :
boolean add(Object) ajoute l'élément fourni en paramètre à la collection. La valeur de

retour indique si la collection a été mise à jour
boolean addAll(Collection) ajoute à la collection tous les éléments de la collection fournie

en paramètre
void clear() supprime tous les éléments de la collection boolean contains(Object) indique
si la collection contient au moins un élément identique à celui fourni en paramètre
boolean containsAll(Collection) indique si tous les éléments de la collection fournie en

paramètre sont contenus dans la collection
boolean isEmpty() indique si la collection est vide

20/04/2011 93
L'interface Collection
Iterator iterator() renvoie un objet qui permet de parcourir l'ensemble des éléments de la
collection
boolean remove(Object) supprime l'élément fourni en paramètre de la collection. La

valeur de retour indique si la collection a été mise à jour
boolean removeAll(Collection) supprime tous les éléments de la collection qui sont

contenus dans la collection fournie en paramètre
int size() renvoie le nombre d'éléments contenu dans la collection
Object[] toArray() renvoie d'un tableau d'objets qui contient tous les éléments de la
collection
Cette interface représente un minimum commun pour les objets qui gèrent des collections : ajout d'éléments,
suppression d'éléments, vérifier la présence d'un objet dans la collection, parcours de la collection et quelques
opérations diverses sur la totalité de la collection.
Ce tronc commun permet entre autre de définir pour chaque objet gérant une collection, un constructeur pour cet
objet demandant un objet de type Collection en paramètre. La collection est ainsi initialisée avec les éléments
contenus dans la collection fournie en paramètre.
20/04/2011 94
public interface Collection {
// Basic Operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element); // Optional
boolean remove(Object element); // Optional
Iterator iterator();
int hashCode();
boolean equals(Object element);
// Bulk Operations
boolean containsAll(Collection c);
boolean addAll(Collection c); // Optional
boolean removeAll(Collection c); // Optional
boolean retainAll(Collection c); // Optional
void clear(); // Optional
// Array Operations
Object[] toArray();
Object[] toArray(Object a[]);
}
20/04/2011 95
retainsAll se comporte comme le résultat de l'intersection de deux ensembles.
Si A={1,2,5,8} et B={3,8} alors A = {8}.
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.
Collection collection = ...;

Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
Object element = iterator.next();
if (removalCheck(element)) {
iterator.remove();
}
}
20/04/2011 96
Les collections vues comme des ensembles réalisent les 3 opérations mathématiques sur des
ensembles: ‘union: add et addAll’, ‘intersection: retainAll’ , ‘différence: remove et removeAll’
Set C'est une interface identique à celle de Collection. 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.
import java.util.*;
public class SetExample {
public static void main(String args[]) {
Set set = new HashSet(); // Une table de Hachage
set.add("Bernadine");
set.add("Elizabeth");
set.add("Gene");
set.add("Elizabeth");
set.add("Clara");
System.out.println(set);
Set SetTrie = new TreeSet(set); // Un Set trié
System.out.println(sortedSet);} }
[Gene, Clara, Bernadine, Elizabeth]

[Bernadine, Clara, Elizabeth, Gene]
20/04/2011 97
POO: Les Collections(9a)
import java.util.*;
public class TestHashSet {
Set set = new HashSet();

set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();

while (iterator.hasNext())
System.out.println(iterator.next());
}
}
Résultat :
AAAAA
DDDDD
BBBBB
CCCCC
20/04/2011 98
POO: Les Collections(9b)
import java.util.*;
public class TestTreeSet {
Set set = new TreeSet();

set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();

while (iterator.hasNext())
System.out.println(iterator.next());
}
}
Résultat :
AAAAA
BBBBB
CCCCC
DDDDD
20/04/2011 99
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.
Elle permet aussi de travailler sur des sous listes. On utilise le plus souvent des ArrayList sauf s'il y a
insertion d'élément(s) au milieu de la liste. Dans ce cas il est préférable d'utiliser une LinkedList pour
éviter ainsi les décalages.
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);
}
20/04/2011 100
import java.util.*;
public class ListExample {
List list = new ArrayList();
list.add("Bernadine"); Resultat de l’exécution du programme
list.add("Elizabeth");
list.add("Gene"); Bernadine, Elizabeth, Gene, Elizabeth, Clara]
list.add("Elizabeth");
list.add("Clara"); 2: Gene
System.out.println(list);
System.out.println("2: " + list.get(2));
0: Bernadine
System.out.println("0: " + list.get(0));
LinkedList queue = new LinkedList(); [Clara, Elizabeth, Gene, Elizabeth, Bernadine]
queue.addFirst("Bernadine");
queue.addFirst("Elizabeth");
[Clara, Elizabeth, Gene]
queue.addFirst("Gene");
queue.addFirst("Elizabeth");
queue.addFirst("Clara");
System.out.println(queue);
queue.removeLast();
queue.removeLast();
System.out.println(queue); } }
20/04/2011 101
Map C'est un ensemble de paires, contenant une clé et une valeur. Deux clés ne peuvent être égales
au sens de equals. L'interface interne Entry permet de manipuler les éléments d'une paire comme
suit:
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}
getKey & getValue retournent respectivement la clé et la valeur associée à cette clé. setValue permet
de modifier une valeur d'une paire.
20/04/2011 102
Map
getKey & getValue retournent respectivement la clé et la valeur associée à cette clé. setValue permet
de modifier une valeur d'une paire.
import java.util.*;
public class MapExample {
Map map = new HashMap();
Integer ONE = new Integer(1);
for (int i=0, n=args.length; i<n; i++) {
String key = args[i];
Integer frequency = (Integer)map.get(key);
if (frequency == null) {
frequency = ONE;
} else {
int value = frequency.intValue();
frequency = new Integer(value + 1);
}
map.put(key, frequency);
}
System.out.println(map);
Map sortedMap = new TreeMap(map);
System.out.println(sortedMap);
} }
20/04/2011 103
POO: Les Collections(13a)
import java.util.*;
public class TestTreeMap {
public static void main(String[] args) {
TreeMap arbre = new TreeMap();

arbre.put(new Integer(3), "données 3");
Set cles = arbre.keySet();

Iterator iterator = cles.iterator();
while (iterator.hasNext()) {
System.out.println(arbre.get(iterator.next()));
}
}
}
Résultat :
données 1
données 2
données 3
20/04/2011 104

Programmation Objet24 Udm

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programmation Objet24 Udm

Cargado por

Copyright:

Formatos disponibles

Université des Montagnes

Master Génie Informatique

Dr.Ing. Rodrigue Carlos Nana Mbinkeu

Membre du groupe de recherche en Informatique

page personnelle: http://www.dbgroup.unimo.it/~nana/

• Variables, structure de contrôle

• Objets et Classes: Constructeur et Destructeur, attributs, méthodes

• Méthodes auxiliaires et reutilisabilité

• Héritage , polymorphisme et les interfaces

• Thread (l’exécution parallèle)

• Swing (interfaces graphiques)

• JDBC (Java DataBase Connexion)

• UML(Diagramme de Classes et de Séquence) et Modèles de conception (MVC)

Dans ce cours, vous apprendrez à manier la Programmation Orientée Objet, ou POO

Si la programmation dite procédurale est constituée de procédures et fonctions sans

Un objet rassemble de fait deux éléments de la programmation procédurale :

Les champs(seront appelés propriétés ou attributs dans un objet) :

Avec la notion d'objet, il convient d‘introduire la notion de classe.

‘etu’ est un objet de la classe Personne.

Ampoule amp = new Ampoule();

amp est un objet de la classe Ampoule ou de type Ampoule

public static void main(String[] args){

Compilateur et Interpréteur sont des traducteurs de langage de programmation de haut niveau en

La diﬀérence réside dans la manière dont la traduction est réalisée :

JAVA utilise les deux!

L’ interpréteur Java s’appelle la machine virtuelle Java (Java Virtual Machine(JVM))

Langage dans lequel est compilé un programme Java :

-> javac Salut.java produit Salut.class contenant des bytecodes.

Pas vraiment “humainement lisible” et dans ce sens, il ressemble à du code assembleur. .

Le bytecode rend le programme indépendant de la plateforme:

La phase d’Interprétation se lance graphiquement à l’aide du bouton Run. L’EDI lance

Structure des programmes JAVA

Les programmes Java se composent de:

• Déclaration de classes et d’interface,

Importation de classe et d’interface d’autres paquetages

public static void main(String[] args){

public static void main(String[] args){

Il affiche les resultats suivants :

// Cela est un commentaire sur une seule ligne

/** Cela est un commentaire javadoc sur plusieurs lignes */

Voici des exemples d’identificateur Java incorrects:

Types primitifs et valeurs littérales

Opérateurs arithmétiques unaires

+ (addition), - (soustraction), * (multiplication), / (division) et % (modulo)

• les opérations effectues sur des opérandes de types différents;

• les arrondis résultats d’une division entière;

•La division par zéro;

• les opérations de modulo;

• les opérations entrainant un dépassement supérieur ou inferieur;

• les opérations entrainant le lancement d une exception.

Quand les opérations binaires sont appliquées à des arguments numériques/entiers ou

• Si un des opérandes est de type double, l autre est converti en double;

• Si un des opérandes est de type float, l’autre est converti en float;

• Si un des opérandes est de type long, l’autre est converti en long ;

• Sinon les deux opérandes sont convertis en valeurs de type int.

Les operateurs de relation, d’égalité , et instanceof

• La promotion numérique se produit avant comparaison des valeurs numériques. Ce

L’operateur instanceof est un operateur binaire qui détermine si une référence à un

L’operateur instanceof renvoie la valeur booléenne true si l’opérande de gauche fait

• l’opérande de droite est un interface I et C implémente I;

instanceof renvoie false si aucune des conditions susmentionnées n’est vérifiées ou si

Conversion élargie et réduites

operande1 ? Operande2 : Operande3