Java Notions Fondamentales Open Classroom

Univerité hassan ii
de casablanca
Ecole supérieure de technologie
Programmation
orientée objet
Avec java
Préparé par :
Larbi Hassouni
HASSOUNI Larbi Présentation de Java

1
Sources principales :
Sites :
1. www.oracle.com (le plus complet et le plus à jour : c'est la principale source)
2. http://deptinfo.unice.fr/~grin/
Livres :
1. Au cœur de Java 2 : Notions fondamentales (Cay S.Horstmann & Gary Cornell)
2. Au cœur de Java2 : Foctions avancées(Cay S.Horstmann & Gary Cornell)
3. BIG Java (Cay S.Horstmann)
4. Java How to program (Deitel)
5. Beginning Java 2 (Ivor Horton)
6. Practical Database Programming with Java (Ying Bai)
7. Data Structures & Algorithms in JAVA (MICHAEL T. GOODRICH, ROBERTO TAMASSIA)
8. Objetc-Oriented Data Structures Using Java (NELL DALE, DANIEL T.JOYCE, CHIP
WEEM)
9. Conception et programmation orientée objet (Bertrand Meyer)
10. Java En Concentré (David Flanagan)
HASSOUNI Larbi Présentation de Java 2
1
Technologie JAVA
• La technologie Java est développée par SUN Microsystems™

en 1995 et comporte principalement de trois composantes:
 Un langage de programmation
 Une plateforme , environnement logiciel dans lequel les
programmes java s'exécutent.
 Une API (Application Programming Interface)
• La technologie Java est utilisée dans de nombreux domaines

d’application et en particulier dans:
 Les serveurs d’applications (Java EE)
 Les téléphones portables
 Les cartes à puces(JME)

3
Exemple de programme en
Le code de la classe doit être
enregistré dans un fichier de JAVA Tout code java doit être défini à
même nom (casse comprise) l'intérieur d'une classe
que la classe
1
3
HelloWorld.java
public class HelloWorld {
public static void main(String[ ] args) { La description

de la
for(int i = 1; i <= 5; i++) { classe est
effectuée à
if(i%2 == 1){ l'intérieur d'un
4 System.out.println("Hello World !"); 2 bloc
Le point
} {}
d'entrée
pour }
l'exécution }
est la }
méthode
main()
Compilation : javac HelloWorld.java Exécution : java HelloWorld.

Hello World !
----------- ----------- Hello world !
---------- javac ---------- java Hello World !
HelloWorld.java HelloWorld.class 4
2
Compilation d’un code source
♠ Un code source ne peut pas être exécuté directement par

un ordinateur
♠ Il faut traduire ce code source dans un langage que

l’ordinateur (le processeur de l'ordinateur) peut comprendre
(langage natif)
♠ Un compilateur est un programme qui effectue cette

traduction

5
Compilation en Java → bytecode
♠ En Java, le code source n’est pas traduit directement

dans le langage de l’ordinateur
♠ Il est d’abord traduit dans un langage appelé «bytecode»,

langage d’une machine virtuelle (JVM ; Java Virtual
Machine) définie par Sun
♠ Ce langage (bytecode) est indépendant de l’ordinateur qui

va exécuter le programme

6
3
La compilation fournit du bytecode
Programme écrit en Java Programme source

UneClasse.java
Compilateur
Programme en bytecode, Bytecode

indépendant de l'ordinateur UneClasse.class
7
Compilation avec javac

Sun fournit le compilateur javac avec le JDK
javac HelloWorld.java
crée un fichier « HelloWorld.class » qui contient le

bytecode, situé dans le même répertoire que le fichier «
.java »
On peut désigner le fichier à compiler par un chemin

absolu ou relatif :
javac SousRep/HelloWorld.java

8
4
Le langage Java
Un langage compilé & interprété
• Compilation d'un programme JAVA : génération de byte-code
public class Test { 01100001

public static void main(String[ ] args) 11100000 javap –c Test
{ 11111010
javac Désassemble Test.class
for (int i = 0; i < 10; i++) 11101...
System.out.println("Hello " + i); ...
}
0 iconst_0
}
1 istore_1
Test.class 2 goto 30
5 getstatic #10 <Field
Test.java byte-code java.io.PrintStream
code source 8 new #5 <Class
java.lang.StringBuffer
11 dup
12 ldc #1 <String "Hello ">
….
27 iinc 1 1
• Le byte-code est : 30 iload_1
31 bipush 10
– proche d'un langage machine 33 if_icmplt 5
– indépendant de la platforme d'exécution (matériel + OS) 36 return

9
Exécution du bytecode
Le bytecode doit être exécuté par une JVM
Cette JVM n'existe pas ; elle est simulée par un programme

qui :
– lit les instructions (en bytecode) du programme .class,
– les traduit dans le langage natif du processeur de

l’ordinateur
– lance leur exécution

10
5
Exécution avec java
♠Sun fournit le programme java qui simule une JVM

Nom d’une classe
♠ java HelloWorld (pas d'un fichier) ;
pas de suffixe .class !
interprète le bytecode de la méthode main() de la classe
HelloWorld
♠ HelloWorld.class doit être dans le répertoire courant ou

dans un des emplacements indiqués par une option
-classpath ou par la variable CLASSPATH

11
Les JVM
♠ Les systèmes qui veulent pouvoir exécuter un

programme Java doivent fournir une JVM
♠ A l'heure actuelle, tous les systèmes ont une JVM

(Linux, Windows, MacOs,…)
♠ Il existe aussi depuis peu quelques JVM « en dur »,

sous forme de processeurs dont le langage natif est le
bytecode ; elles sont rarement utilisées

12
6
Le bytecode peut être exécuté par
n'importe quelle JVM
Bytecode
UneClasse.class
WRITE ONCE
RUN EVERYWHERE
JVM sous Unix, JVM sous Linux,

processeur SPARC processeur Intel
JVM sous Windows, JVM sous MacOS,

HASSOUNI Larbi
processeur Intel Présentation de Javaprocesseur Motorola
13
Avantages de la JVM pour Internet
♠ Grâce à sa portabilité, le bytecode d'une classe peut

être chargé depuis une machine distante du réseau, et
exécutée par une JVM locale
♠ La JVM fait de nombreuses vérifications sur le bytecode

avant son exécution pour s’assurer qu’il ne va effectuer
aucune action dangereuse
♠ La JVM apporte donc

– de la souplesse pour le chargement du code à exécuter
– mais aussi de la sécurité pour l'exécution de ce code

14
7
Une certaine lenteur...
♠ Les vérifications effectuées sur le bytecode et l'étape

d'interprétation de ce bytecode (dans le langage natif du
processeur) ralentissent l'exécution des classes Java
♠ Mais les techniques « Just In Time (JIT) » ou « Hotspot »

réduisent ce problème :
Elles permettent de ne traduire qu'une seule fois en code
natif les instructions qui sont exécutées

15
Java et les autres langages
♠ Java est devenu en quelques années un des langages de

développement les plus utilisés, surtout pour les applications
qui ont besoin d'une grande portabilité ou d'une grande
souplesse sur Internet
♠ Pour les applications qui nécessitent une très grande

rapidité d'exécution, on préfère encore les langages C, C++,
ou le bon vieux Fortran
(qui a des bibliothèques très utilisées pour le calcul
scientifique)

16
8
Spécifications de Java
♠ Java, c’est en fait
– le langage Java : http://java.sun.com/docs/books/jls/
– une JVM : http://java.sun.com/docs/books/vmspec/
– les API : Ensemble de classes prédéfinies et réparties

sur plusieurs packages
♠ Java n’est pas normalisé ; son évolution est gérée par le

JCP (Java Community Process ; http://www.jcp.org/)
dans lequel Oracle tient une place prépondérante

17
Plate-forme Java
API (Application Programming Interface) :

bibliothèques de classes standard
18
9
3 éditions de Java
♠ Java SE : Java Standard Edition ; JDK = J2SE

Development Kit, aussi appelé SDK (Software
Development Kit) pour certaines versions
Fournit les compilateurs, outils, runtimes, et APIs pour
écrire, déployer, et exécuter des applets et applications
♠ JavaEE : Enterprise Edition qui ajoute les API pour écrire

des applications installées sur les serveurs dans
des applications distribuées : servlet, JSP, EJB,…
♠ JavaME : Micro Edition, version allégée de Java pour écrire

des programmes embarqués (cartes à puce/Java
card, téléphones portables,…)

19
Votre environnement de
développement
♠ Éditeur de texte NotePad
♠ Compilateur (javac)
♠ Interpréteur de bytecode (java)
♠ Aide en ligne sur le JDK (sous navigateur Web)
♠ Générateur automatique de documentation (javadoc)
♠ Testeur pour applet (appletviewer)
♠ Débogueur (jdb)
20
10
Votre environnement de
développement
♠ Nombreux IDE (Integrated Development Environment)
JDeveloper
Oracle
Java Studio WebSphere Studio JBuilder
Creator Application Developper Borland
Sunsoft (VisualAge) IBM
♠ Des environnements open-source ou freeware
Eclipse NetBeans BlueJ Emacs + JDE

www.eclipse.org www.netbeans.org www.bluej.org http://sunsite.auc.dk/jde
21
Variables d’environnement
♠ PATH : doit inclure le répertoire qui contient les utilitaires

Java (javac, java, javadoc,…)
♠ CLASSPATH : indique le chemin de recherche des classes

de l’utilisateur
♠ Le débutant ne doit pas avoir de variable CLASSPATH

22
11
Une classe Point
/** Modélise un point de coordonnées x, y */
public class Point {
private int x, y;
public Point(int x, int y) { // un constructeur
this.x = x;
this.y = y;
}
public double distance(Point p) { // une méthode

return Math.sqrt((this.x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
public static void main(String[] args) {

Point p1 = new Point(1, 2);
System.out.println("Distance : " + p1.distance(p2));
}
}HASSOUNI Larbi Présentation de Java
23
2 classes dans 1 fichier

private int x, y;
public Point(int x1, int y1) {
x = x1; y = y1;
}
public double distance(Point p) {

return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
}
Fichier Point.java
/** Teste la classe Point */
class TestPoint {
}
}
24
12
Compilation et exécution de la
classe Point
La compilation du fichier Point.java

javac Point.java
fournit 2 fichiers classes : Point.class et TestPoint.class
On lance l’exécution de la classe TestPoint qui a une

méthode main()
java TestPoint

25
2 classes dans 2 fichiers

private int x, y;
public Point(int x1, int y1) { Fichier Point.java
x = x1; y = y1;
}
public double distance(Point p) {

return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
}
/** Pour tester la classe Point */

class TestPoint { Fichier TestPoint.java
}
} HASSOUNI Larbi Présentation de Java
26
13
Architecture d’un
programme source Java
♠ Programme source Java = ensemble de fichiers « .java »
♠ Chaque fichier « .java » contient une ou plusieurs

définitions de classes
♠ Au plus une définition de classe public par fichier « .java »

(avec nom du fichier = nom de la classe publique)

27
Chargement dynamique des classes
♠ Durant l’exécution d’un code Java, les classes (leur

bytecode) sont chargées dans la JVM au fur et à mesure des
besoins
♠ Une classe peut être chargée:
– depuis la machine locale (le cas le plus fréquent)
– depuis une autre machine, par le réseau
– par tout autre moyen (base de données,…)

28
14
Types de programmes Java
On peut développer trois types de programmes avec java
1- Applications indépendantes (ou stand alone)
2- Applets exécutées dans l’environnement/JVM

d’un navigateur Web et chargées par une page
HTML
3- Allications Client/Serveur qui s'exécutent sur un
serveur d'application

29
Application indépendante
♠ Application doit posséder une classe principale
– classe possédant une méthode de signature
Tableau de chaînes de caractères
(équivalent à argc, argv du C)
public static void main(String[] args)
♠ Cette méthode sert de point d’entrée pour l’exécution de

l’application
♠ Lancement de l’application s’effectue en exécutant la méthode main de

la classe principale de l’application; par exemple :
java TestPoint
lance l’interprétation du code de la méthode main() de la classe

principale TestPoint qui se trouve dans le fichier TestPoint.class

30
15
Applet
♠ Classe ne possédant pas de méthode main()
• Hérite de java.awt.Applet ou javax.swing.JApplet
• Son bytecode réside sur un serveur http
• Elle est véhiculée vers un client http (navigateur Web) via une
page HTML qui contient son url
• Lorsqu’un navigateur compatible Java (avec sa propre

machine virtuelle java (JVM)) reçoit cette page HTML, il
télécharge le code de la classe et l’exécute sur le poste client
– l’applet doit posséder un certain nombre de méthodes pour

permettre cette exécution :
init(), start(), stop(), paint(), destroy()

31
import java.awt.*;
Exemple d’applet
import java.applet.*;
public class Checkerboard extends Applet {
/* This applet draws a red-and-black checkerboard.
It is assumed that the size of the applet is 160 by 160 pixels.
*/
public void paint(Graphics g) {
int row; // Row number, from 0 to 7
int col; // Column number, from 0 to 7
int x,y; // Top-left corner of square
for ( row = 0; row < 8; row++ ) {
for ( col = 0; col < 8; col++) {
x = col * 80; y = row * 80;
if ( (row % 2) == (col % 2) )
g.setColor(Color.red);
else
g.setColor(Color.black);
g.fillRect(x, y, 80, 80);
}
} // end for row
} // end paint()
} // end class Checkerboard
32
16
Exemple de page Web qui contient
une applet
<html>
<head>
<title>Utilsation des applets</title>
</head>
<body>
<h1 align = "center">Utilisation des applets</h1>
<p align=center>
<applet code="Checkerboard.class"
height=640 width=640>
</applet>
</p>
</body>
<html>
33

34
17
Étapes pour l’exécution d’une applet
1. Demande chargement page Web

Qui contient une applet html
html
Client 2. Chargement de la page Web Serveur
http html
3. Demande chargement de l’applet
Navigateur HTTP
intégrant une référencée dans la page
machine .class
virtuelle Java 4. Chargement du bytecode de
La classe .class
3. Exécution de l’applet
dans la JVM du client
Présentation de Java
HASSOUNI Larbi
35
Exécution de l'applet
♠ Le navigateur a sa propre machine virtuelle
♠ Un programme Java spécial démarré par le navigateur va

lancer certaines méthodes de la classe Applet :
init(), start(), stop(), destroy(), paint()
♠ init() est exécuté seulement quand l’applet

est lancée pour la première fois
♠ paint() dessine l'applet dans la page Web

36
18
Utilité des applets
♠ Les applets permettent de faire des pages Web plus
riches (grâce aux possibilités offertes par Java)
♠ La page Web peut contenir

– des animations ou des mises en forme
complexes pour mettre en valeur certaines
informations
– des résultats de calculs complexes
– des informations « dynamiques » (pas connues

au moment où la page Web statique est créée)
trouvées en interrogeant une base de données
– ….
37
19
ELEMENTS DE BASE
DU LANGAGE JAVA
Préparé par Larbi Hassouni
HASSOUNI Larbi Eléments de base du langage 11
1
Identificateurs Java
● Identificateurs
– Sont des tokens qui représentent les noms des variables, méthodes,
classes, etc.
– Exemples d’identificateurs : taux, main, System, out.

● doit respecter les règles suivantes:
1. Il doit consister en une suite illimitée de caractères unicodes qui commence
par une lettre, le signe $ ou le trait de soulignement (_).
[a..z, A..Z, $, _]{a..z, A..Z, $, _, 0..9, Unicode}

2. Il ne doit pas être un mot clé, une valeur booléenne (true ou false) ou le mot
réservé null
● Les identificateurs Java sont sensibles à la casse.

– Cela signifie que les lettres majuscules et minuscules ne sont pas
considérés identiques dans un identificateurs.
Par conséquent les identificateurs TAUX , Taux, taux ne sont pas

identiques.
Conventions pour les identificateurs
Les noms des classes commencent par une majuscule . Si le nom est
formé de plusieurs mots, la première lettre de chaque mot doit être en
majuscule.
Exemple : Object , System , Scanner , ExempleDeNomDeClasse
Les variables et les méthodes commencent par une minuscule . Si le

nom est formé de plusieurs mots, la première lettre de chaque mot doit
être en majuscule à l’exception du 1er mot.
Exemple : tauxTva, unEtudiant, exempleDeNomDeVariable
Les noms des constantes sont en majuscules. Si le nom est formé de

plusieurs mots, ils sont séparés par le caractère souligné « _ » :
Exemple : TAILLE_ECRAN , EXEMPLE_DE_CONSTANTE
1
Mots clés Java
● Les mots clés sont des identificateurs prédéfinis qui ont une signification
spécifique en Java.
● Vous ne pouvez pas utiliser un mot clé comme nom de variable, classe,
methode ... etc.
● La liste des mots clés est fournie ci-dessous.
abstract, boolean, break, byte, case, catch, char, class,
continue, default, do, double, else, extends, final, finally,
float, for, if, implements, import, instanceof, int, interface,
long, native, new, null, package, private, protected,
public, return, short, static, super, switch, synchronized,
this, throw, throws, transient, try, void, volatile, while
Commentaires Java
● Commentaires ?
– Ce sont des notes écrites pour documenter le programme.
– Ils n’ont aucun effet sur le déroulement du programme.
● Il existe 3 types de commentaires en Java
– Commentaires sur une seule ligne (style C++)

Comme en C++, ces commentaires commencent par un double stalsh
(//), et sétendent sur une seule ligne.
Exemples:
//Commentaires sur toute la ligne
int i; //Commentaire jusqu’à la fin de la ligne
– Commentaires sur plusieurs lignes (style C)

Comme en C, ces commentaires commencent par /* et se terminent
par */. Ils peuvent s’étendre sur plusieurs lignes.
Exemple:
/*Ce type de commentaire peuvent s’étendre sur une ligne
ou plusieurs
HASSOUNI Larbi lignes */ Eléments de base du langage 15
2
Commentaires Java
– Commentaires pour l’outil Javadoc, qui sont utilisés pour générer une
documentation HTML sur le programme.
Ces commentaires commencent par /** et se terminent par */
Ils peuvent s’étendre sur plusieurs lignes.
Ils peuvent contenir certaines balises pour ajouter davantage

d’informations aux commentaires.
Exemple:
/**
Ceci est un exemple de commentaires javadoc\n qui génére une
documentation HTML. Il utilise les balises comme:
@author MOHA ayoub
*/
Variables
Définition: Une variable est une donnée représentée par un identificateur
Vous devez explicitement donner un nom et un type à chaque variable que vous
voulez utiliser dans le programme.
Le nom d’une variable doit être un identificateur autorisé.
Le nom d’une variable est utilisé pour référencer la donnée que la variable
contient.
Le type d’une variable détermine quelles sont les valeurs que la variable peut
contenir et quelles opérations peuvent être effectuées sur la variable.
3
Variables
Pour donner à une variable un nom et un type, nous écrivons une
déclaration de variable de la manière suivante :
<type> <nomDeLaVariable>
Exemple : double tauxTva;
En plus du nom et du type, une variable à un domaine de visibilité et un

SCOPE
La partie du programme où le nom d’une variable peut être utilisé par son
simple nom (sans qualificatif) est appelé scope de la variable
Types de données
(Data Types)
Chaque variable doit avoir un type de donnée.
Le type de donnée d’une variable détermine l’ensemble des valeurs que la variable
peut contenir.
Il détermine également le type d’opérations qui peuvent être effectuées sur elle.
Par exemple:
Une variable de type int ne peut contenir que des valeurs entières (négatives ou
positives).
Sur une variable entière nous pouvons effectuer des opérations arithmétiques
(addition, soustraction …etc)
4
Types de données
Le langage Java contient deux catégories de types de données:
Types primitifs
Type référence
Une variable de type primitif contient une valeur simple

(nombre, caractère, ou booléen).
Une variable de type référence contient la référence (ou adresse) d’un

objet(voir classes).
Types de données
Types primitifs
Une variable de type primitif contient une valeur simple

(nombre, caractère, ou booléen).
Cette valeur est stockée en mémoire sur un nombre de bits

déterminé et selon un format bien précis.
Exemple:
Une variable de type int mémorise sa valeur sur 32 bits et utilise
la représentation en complément à 2
Une variable de type char mémorise sa valeur sur 16 bits et

utilise le format Unicode
A variable of primitive type contains a value of a particular

size and format.
5
Plus grandes valeurs des types primitifs
public class MaxVariablesDemo

{
public static void main(String args[])
{
//integers
byte largestByte = Byte.MAX_VALUE;
short largestShort = Short.MAX_VALUE;
int largestInteger = Integer.MAX_VALUE;
long largestLong = Long.MAX_VALUE;
//real numbers
float largestFloat = Float.MAX_VALUE;
double largestDouble = Double.MAX_VALUE;
//other primitive types

char aChar = 'S';
boolean aBoolean = true;
Plus grandes valeurs des types primitifs
//Display them all.
System.out.println("The largest byte value is " + largestByte + ".");

System.out.println("The largest short value is " + largestShort + ".");
System.out.println("The largest integer value is " + largestInteger + ".");
System.out.println("The largest long value is " + largestLong + ".");
System.out.println("The largest float value is " + largestFloat + ".");
System.out.println("The largest double value is " + largestDouble + ".");
if (Character.isUpperCase(aChar))
{
System.out.println("The character " + aChar + " is uppercase."); }
else
{
System.out.println("The character " + aChar + " is lowercase.");
}
System.out.println("The value of aBoolean is " + aBoolean + ".");
} //fin de main
} //HASSOUNI
fin de la Larbi
classe Eléments de base du langage 23
6
Types de données primitifs
MotClé Description-Taille/Format Intervalle
Entiers
byte Entier signé sur 1octet en Cà2 -27 (-128) à + 27-1(127)
short Entier signé sur 2 octets en Cà2 -215(-32768)à + 215-1
int Entier signé sur 4 octets en Cà2 -231 à + 231-1
long Entier signé sur 8 octets en Cà2 -263 à + 263-1
Réels
Réel en virgule flottante simple -3.4..e38 à -1.4..e-45 à
float
précision sur 4 octets (IEEE 754) 1.4..e-45 à 3.4..e38
Réel en virgule flottante double -1.7…e308 à -4.9…e-324
double 4.9…e-324 à 1.7…e308
précision sur 8 octets (IEEE 754)
Autres types
Un seul caractère sur 2 octets Code unicode de
char
(Unicode) 0 à 65535
boolean
HASSOUNI Larbi Valeur boolèene sur 1de
Eléments bitbase du langage
true or false 24
Types Références
La valeur d’une variable de type référence est une référence (adresse de) à la
valeur à ou à l’ensemble des valeurs représenté par la variable.
Objet
Nom d’objet Référence Ou
tableau
Une variable référence contient l’adresse d’un objet ou d’un tableau.
Une référence est appelé Pointeur ou adresse dans les autres langages(C, …)
Le Langage Java n’autorise pas l’utilisation explicite des pointeurs.
Les tableaux, Classes, et Interfaces sont des types Références.
7
Constantes ou Valeurs Litterals
Il est possible d’écrire directement une constante dans

votre programme.
Par exemple, pour assigner la valeur 20 à une variable de
type entier, vous pouvez écrire :
I = 20 ;
20 est une valeur littérale.
Le compilateur attribue a la valeur 20 le type int par défaut.
Le tableau de la page suivante présente différents type de
valeurs littérales.
Constantes numériques
Une constante «entière» est de type long si elle est suffixée par «L»
et de type int sinon
Une constante «flottante» est de type float si elle est suffixée par
«F» et de type double sinon
Exemples
35 //Constante de type int
2589L // constante de type long
37.266D // constante de type double
4.567e2 // 456,7 de type double
.123587E-25F // de type float
8
Constantes de type caractère
Une constante de type char est un caractère Unicode entouré par 2 simples
quotes ‘’
Exemples :
'A' 'a' 'ç' '1' '2'
\ caractère d’échappement pour introduire caractères spéciaux

'\t' tabulation
'\n' nouvelle ligne
'\r' retour chariot retour arrière
'\f' saut de page
…
'\\' '\‘' '\"'
’\u03a9’ ( \u suivi du code hexadécimal à 4 chiffres d’un caractère

Unicode)
'α'
Autres constantes
Constantes de Type booléen
false
true
Constante référence
null //Référence inexistante

//(indique qu’une variable de type non primitif ne référence rien)
Constante de type String
String n’est pas un type primitif, c’est une classe, et donc un type référence
Une constante de type String est une suite de caractères délimités par deux
guillemets(" ")
Exemple: " Ceci est une constante de type String "
9
Noms de variables
En Java, le nom d’une variable doit respecter les règles suivantes:
1. Il doit être un identificateur autorisé (voir identificateurs)

2. Il doit être unique dans son Scope.
Une variable peut avoir le même nom que d’autres variables déclarées dans
des Scopes différents.
Scope d’une variable
Le Scope d’une variable:

1. Définit la région du programme à partir de laquelle il est
possible de référencer la variable par son simple nom
2. Détermine l’instant où le système réserve de la mémoire
pour la variable et l’instant où il libère la mémoire occupée
par la variable.
Le Scope est différent du domaine de visibilité.

Le domaine de visibilité s’applique uniquement aux variables
membres et détermine si la variable peut ou non être utilisée
en dehors de la classe dans laquelle elle a été déclarée. La
visibilité est positionnée par un modificateur d’accès (Voir
Classes)
10
Scope d’une variable
L’endroit de la déclaration d’une variable dans un programme établit son scope

et la place dans une des quatre catégories suivantes:
1. Variable membre (member variable)
2. Variable locale (local variable)
3. Paramètre de méthode (method parameter)
4. Paramètre de gestionnaire d’exception (exception-handler parameter)
Variable membre
(member variable)
Une variable membre est un membre d’une classe ou d’un objet.
Elle est déclarée à l’intérieur d’une classe mais en dehors de toute méthode ou
constructeur.
Son scope est toute la classe dont elle est membre.
Nous étudierons en détail les variables membres dans une leçon ultérieure.
11
Variable locale
(local variable)
Une variable locale est déclarée dans un bloc de code.
Un bloc de code est délimité par les accolades ({}).
Le Scope d’une variable locale s’étend de l’endroit où elle est déclarée jusqu’à la
fin du bloc où elle est déclarée.
Toutes les variables déclarées dans la méthode main sont des variables locales.
Le Scope de ces variables s’étend de leur lieu de déclaration jusqu’à la fin de la
méthode main indiquée par l’accolade fermante }.
Paramètre de méthode
(method parameter)
Les paramètres de méthodes sont les argument formels des méthodes et

constructeurs.
Les paramètres sont utilisés pour passer des valeurs aux méthodes et aux
constructeurs.
Le Scope d’un paramètre est la méthode (ou constructeur) entière pour

laquelle il est défini.
12
Paramètres de gestionnaire d’exception
(exception-handler parameter)
Les paramètre de gestionnaire d’exception sont similaires aux paramètres

de méthode mais sont paramètres d’un gestionnaire d’exception et non
d’une méthode ou d’un constructeur.
Le Scope d’un paramètre de gestionnaire d’exception est le bloc de code

encadré par les accolades {} qui vient après l’instruction catch.
Nous étudierons en détails ces paramètres dans la section : Gestion des

erreurs à l’aide des exceptions.
Exemples de variables locales

Considérons le code ci-dessous:
if (...)
{
int i = 17; ...
}
System.out.println(« La valeur de i = " + i); // erreur
La dernière ligne de ce programme générera une erreur de compilation parce

que la variable locale i est utilisé en dehors de son Scope.
Le Scope de la variable i est le bloc de code compris entre { et }.

La variable i n’existe plus après l’accolade fermante }.
Pour remédier au problème:

-il faut soit déplacer la déclaration de la variable i en dehors du bloc de code de
l’instruction if,
-ou déplacer l’appel de la méthode println à l’intérieur du bloc du code de

l’instruction if.
13
Initialisation de variable
Une variable locale ou variable membre peut être initialisée par une
instruction d’affectation lors de sa déclaration.
Le type de la variable doit être compatible avec le type de la valeur qui lui
est affectée.
L’exemple ci-dessous montre des exemples d’initialisation de variables:
//Entiers
byte largestByte = Byte.MAX_VALUE;
short largestShort = Short.MAX_VALUE;
int largestInteger = Integer.MAX_VALUE;
long largestLong = Long.MAX_VALUE;
//Nombres réels
float largestFloat = Float.MAX_VALUE;
double largestDouble = Double.MAX_VALUE;
//Autres types primitifs
char aChar = 'S';
boolean aBoolean = true;
Les paramètres des méthodes et des gestionnaires d’exception ne sont pas
initialisées selon cette méthode; Ils reçoivent leur valeur à partir du code
appelant Larbi
HASSOUNI Eléments de base du langage 38
Variables « Finales »
(Final Variables )
On peut déclarer une variable de n’importe quel Scope comme étant final.
La valeur d’une variable final ne peut pas être modifié après son initialisation.
Une variable final est similaire à une constante en C, C++ et C#.
Pour déclarer une variable final, utilisez le mot clé final dans la déclaration de la
variable juste avant le type.
Exemple:
final int aFinalVariable = 0
Cette instruction déclare une variable final et l’initialise une fois pour toute.
Si on essaie de lui assigner une autre valeur dans la suite du programme, le

compilateur engendrera une erreur.
14
Variables « Finales »
(Final Variables )
Il est possible de déférer l’initialisation d’une variable locale. Il faut tout

simplement déclarer la variable comme étant final, puis l’initialiser par la suite.
Exemple:
final int aBlankFinalVariable;
……………………….
aBlankFinalVariable = 0
Une variable locale final qui a été déclarée sans être initialisée est appelé
variable « blank final ». Une fois cette variable est initialisée, toute tentative
future pour lui assigner une autre valeur engendrera une erreur lors de la
compilation.
Forcer le type en java

Opérateur Cast
Java est un langage fortement typé

Dans certains cas, il est nécessaire de forcer le programme à considérer
une expression comme étant d’un type qui n’est pas son type réel ou
déclaré
On utilise le cast : (type-forcé) expression
Exemple:
int i = 64;
char c = (char)i;
15
Cast entre type primitifs
Un cast entre types primitifs peut occasionner une perte de données
Par exemple, la conversion d'un int vers un short peut donner un

nombre complètement différent du nombre de départ
Un cast peut provoquer une simple perte de précision
Par exemple, la conversion d'un long vers un float peut faire perdre des
chiffres significatifs mais pas l'ordre de grandeur
Cast entre type primitifs

Les affectations entre types primitifs peuvent utiliser un cast implicite si
elles ne peuvent provoquer qu'une perte de précision (ou, encore mieux,
aucune perte)
int i = 130;
double x = 20 * i;
Sinon, elles doivent comporter un cast explicite
short s = 65; // cas particulier affectation int "petit"
s = 1 000 000; // provoque une erreur de compilation
Int i = 130;
byte b = (byte)(i + 2);
char c = (char)i; // caractère dont le code est 130
b = (byte)i; // b = -126 !
16
Cast entre entiers et caractères
La correspondance char → int, long s’obtient par cast implicite
Les correspondances
char → short, byte

et
long, int, short ou byte → char
nécessitent un cast explicite (les entiers sont signés et pas les char)
int i = 80;
char c = 68; // caractère dont le code est 68
c = (char)i
i = c;
short s = (short)i;
char c2 = s; // provoque une erreur

Opérateurs
Un opérateur effectue une opération (ou fonction) sur un, deux ou trois
opérandes.
Un opérateur qui requiert un seul opérande est appelé opérateur unaire.
Par exemple, ++ est un opérateur unaire qui incrémente la valeur de son
opérande de 1.
Un opérateur qui requiert deux opérandes est un opérateur binaire.

Par exemple, = est un opérateur binaire qui affecte la valeur de son opérande
qui se trouve à sa droite à son opérande suit se trouve à sa gauche.
En dernier, un opérateur qui requiert trois opérandes est appelé opérateur

ternaire. Il existe un seul opérateur ternaire qui est ?:
C’est un raccourci de l’instruction if-else.
Exemple : Max = a>b?a:b  (si (a>b) Max = a else Max=b)
17
Opérateurs
Les opérateurs unaires supportent les deux notations prefix et postfix.
La notation prefix signifie que l’opérateur apparaît avant son opérande.
Opérateur op // notation prefix (op signifie opérande).
La notation postfix signifie que l’opérateur apparaît après son opérande

Op Opérateur //notation postfix
Tous les opérateurs binaires utilisent la notation infix, qui signifie que l’opérateur
apparaît entre ses opérandes.
Op1 opérateur op2 //notation infix
L’opérateur ternaire utilise aussi la notation infix, car chaque composante de

l’opérateur apparaît entre deux opérandes.
Op1 ? Op2 : Op3 /notation infix
Opérateurs
En plus d’effectuer une opération, un opérateur retourne une valeur.
La valeur retournée et son type dépendent de l’opérateur et du type de ses

opérandes.
Par exemple, les opérateurs arithmétiques tels que les opérateurs d’addition et
de soustraction retournent comme résultat un nombre dont le type dépend de
type de leurs opérandes.
Si on additionne deux entiers , le résultat retourné est un entier,
si on additionne deux réels le résultat retourné est un réel.
18
Opérateurs
Les opérateurs se répartissent en les catégories suivantes :
Opérateurs arithmétiques
Opérateurs relationnels et logiques
Opérateurs de décalage et bit à bit
Opérateurs d’affectation
Autres opérateurs
Opérateurs arithmétiques
Le lanagage Java fournit un ensemble d’opérateurs arithmétique qui opèrent sur
des nombres entiers et en virgules flottante.
Ces opérateurs sont : + (addition), -(soustraction), *(multiplication), /(division), et
%(modulo). Ils ont la même signification qu’en C.
Le tableau suivant présente ces opérateurs:
Opérateurs arithmétiques binaires

Operateur Format Description
Ajoute op1 à op2; il est aussi utilisé également pour
+ op1 + op2
concaténer deux Strings.
- op1 - op2 Soustrait op2 de op1.
* op1 * op2 Multiplie op1 par op2.
/ op1 / op2 Divise op1 par op2.
% op1 % op2 Calcule le reste de la division de op1 par op2.
19
Types des résultats des Opérations Arithmétiques
Noter que lorsqu’un entier et un nombre en virgule flottante sont utilisés

ensemble dans une opération arithmétique, le résultat est un nombre en
virgule flottante. Le nombre entier est implicitement converti en un nombre
en virgule flottante avant que l’opération ne soit effectuée.
Le tableau suivant présente en résumé les types de données

retournés par les opérateurs arithmétiques en fonction des types des
opérandes utilisés. Les conversions nécessaires sont effectuées
implicitement avant que l’opération arithmétique ne soit effectuée.
Types des résultats des Operations Arithmétiques
Type du
Type des Opérandes
Resultat
Aucun opérande n’est de type float ou double (Arithmétique
int
entière); aucun opérande n’est de type long.
Aucun opérande n’est de type float ou double (Arithmétique
long
entière); au moins un opérande est de type long.
Au moins un opérande est de type float; aucun opérande n’est
float
de type double.
double Au moins un opérande est de type double.
20
Opérateurs Arithmétiques Unaires
En plus des formes binaire des opérateurs + et -,
chacun de ces opérateurs possède une forme unaire, comme le montre

le tableau suivant.
Operateurs Arithmétiques Unaires
Operateur Utilisation Description
Promouvoit op au type int s’il est de type byte,

+ +op
short,ou char
- -op Calcule l’opposé arithmétique de op
Opérateurs d’incrémentation (++)

Et de décrémentation (--)
Il existe deux opérateurs arithmétiques considérés comme des raccourcis.

Le premier est l’opérateur ++ qui incrémente son opérande de 1.
Le deuxième est l’opérateur -- qui décrémente son opérande de 1.
Chacun de ces deux opérateurs peut apparaître avant (prefix) ou après (postfix)
son opérande.
La version prefix , ++op/--op, fournit comme résultat la valeur de l’opérande

après l’avoir incrémenté/décrémenté.
La version postfix op++/op--, fournit comme résultat la valeur de l’opérande

avant de l’incrémenter/décrémenter.
21
Récapitulatif sur les opérateurs d’incrémentation(++)
et de décrémentation (--)

Incrémente op par 1; évalue
++ op++ l’expression en la valeur de op avant
qu’il ne soit incrémenté.
Incrémente op par 1; évalue
++ ++op l’expression en la valeur de op après
qu’il soit incrémenté.
Décrémente op par 1; évalue
-- op-- l’expression en la valeur de op avant
qu’il ne soit décrémenté.
Décrémente op par 1; évalue
-- --op l’expression en la valeur de op après
qu’il soit Décrémenté.
Operateurs Relationnels et Logiques
Un opérateur relationnel permet de comparer deux valeurs. Il retourne toujours

une valeur boolèenne.
Par exemple l’opérateur != retourne la valeur booléenne true si les deux
opérandes ne sont pas égaux.
Le tableau ci-dessous fournit les différents opérateurs relationnels.
Operateurs Relationnels

> op1 > op2 Retourne true si op1 est supérieur à op2
>= op1 >= op2 Retourne true si op1 est supérieur ou égale à op2
< op1 < op2 Retourne true si op1 est inférieur à op2
<= op1 <= op2 Retourne true si op1 est inférieur ou égale à op2
== op1 == op2 Retourne true si op1 est égale à op2
!= op1 != op2 Retourne true si op1 est différent de op2
22
Operateurs Logiques (ou conditionnels)
Les opérateurs relationnels sont souvent utilisés avec les opérateurs logiques
pour former des expressions conditionnelles plus complexes.
Le langage Java fournit six opérateurs logiques, 5 sont binaires et un est unaire
Le tableau suivant présente ces six opérateurs.
Operateurs Logiques (ou conditionnels)

Opérateur Utilisation Description
Retourne true si op1 et op2 sont tous les deux true;
&& op1 && op2
evalue op2 uniquement dans le cas ou op1 est true
Retourne true si op1 ou op2 est true; evalue op2
|| op1 || op2
uniquement dans le cas où op2 est false.
! !op Retourne true si op est false
Retourne true si op1 et op2 sont tous les deux
booléens et ont la valeur true; il evalue toujours op1 et
& op1 & op2 op2;
Si les deux opérandes sont des nombres, il effectue
l’opération AND bit à bit.
Retourne true si op1 et op2 sont tous les deux
booléens et op1 ou op2 est true; evalue toujours op1
| op1 | op2 et op2;
si les deux opérandes sont des nombres, il effectue
l’opération OR inclusif bit à bit.
Retourne true si op1 et op2 sont differents — c’est-à-
^ op1 ^ op2
dire, si un seul opérande, et non les deux est true.
23
Opérateurs de décalage et bit à bit
Un opérateur de décalage effectue une manipulation des bits en effectuant un
décalage gauche ou droite des bits de son opérande de gauche. Le tableau
Ci-dessous présente les opérateurs de décalage fourni par le langage Java.

Operateurs de décalage
Effectue un décalage gauche des bits de op1 un
<< op1 << op2 nombre de fois spécifié par l’opérande op2; remplit
avec 0 les bits de droite
Effectue un décalage droite des bits de op1 un
>> op1 >> op2 nombre de fois égal à op2. Remplit avec le bit le plus
significatif (bit de signe) les bits de gauche.
Effectue un décalage droite des bits de op1 un
>>> op1 >>> op2 nombre de fois égal à op2. Remplit avec 0 les bits
de gauche.
Operateurs Logiques
Le tableau ci-dessous présente les quatre opérateurs logiques fourni par Java pour
Effectuer des opérations bit à bit sur leurs opérandes
Operateurs Logiques
Operateur Utilisation Operation
-Opération AND bit à bit si les deux opérandes sont
des nombres;
& op1 & op2
-Opération AND logique si les deux opérandes sont
booléen
-Opération OR bit à bit si les deux opérandes sont
des nombres;
| op1 | op2
-Opération OR logiques si les deux opérandes sont
booléens
^ op1 ^ op2 Opération OR exclusif(XOR)
~ ~op Complément à un des bits de l’opérande op
24
Opérateurs d’affectation
Le langage Java utilise l’opérateur = pour affecter une valeur à une variable.
Le langage Java fournit aussi un ensemble d’opérateurs qui combine une
opération arithmétique, de décalage, ou de manipulation de bits avec
l’opération d’affectation.
Supposez que vous voulez ajouter un nombre à une variable, et puis affecter le
résultat à la variable en question, comme suit:
i = i + 2;
Vous pouvez écrire de façon plus concise cette instruction en utilisant l’opérateur
+=.
Les deux instructions i = i + 2; et i += 2; sont équivalentes
Operateurs d’affectation
Le tableau suivant présente les différents opérateurs d’affectation fournis par Java.

+= op1 += op2 Equivalent à op1 = op1 + op2
-= op1 -= op2 Equivalent à op1 = op1 - op2
*= op1 *= op2 Equivalent à op1 = op1 * op2
/= op1 /= op2 Equivalent à op1 = op1 / op2
%= op1 %= op2 Equivalent à op1 = op1 % op2
&= op1 &= op2 Equivalent à op1 = op1 & op2
|= op1 |= op2 Equivalent à op1 = op1 | op2
^= op1 ^= op2 Equivalent à op1 = op1 ^ op2
<<= op1 <<= op2 Equivalent à op1 = op1 << op2
>>= op1 >>= op2 Equivalent à op1 = op1 >> op2
>>>= op1 >>>= op2 Equivalent à op1 = op1 >>> op2
25
Autres Opérateurs
Le langage Java fourni d’autres opérateurs qui sont fournis dans le tableau ci-dessous.
si op1 est true, retourne op2; sinon, reoturne
?: op1 ? op2 : op3
op3
Voir Création et Utilisé pour déclarer un tableau, pour créer un
[] utilisation des tableau, et pour accéder aux éléments d’un
tableaux tableau.
Voir Utilisation des Utilisé pour former des noms longs (ou nom
.
Objets qualifiés)
Voir Définition des Delimite une liste de paramètres séparés par
(params)
méthodes des virgules
Convertit op vers le type spécifié; une
(type) (type) op exception est relevée si le type de op n’est pas
compatible avec type
Voir Utilisation des
Objets et Création
new Crée un nouveau objet ou tableau.
et Utilisation des
tableaux
instanceof op1 instanceof op2
HASSOUNI Larbi Eléments de base du langage
Retourne true si op1 est une instance de op2.62
Operateurs Java
Le tableau ci-dessous donne la liste complète des opérateurs du langage Java.

+ +op Promotes op to int if it's a byte, short, or char
- -op Arithmetically negates op
+ op1 + op2 Adds op1 and op2; also used to concatenate strings
- op1 - op2 Subtracts op2 from op1
* op1 * op2 Multiplies op1 by op2
/ op1 / op2 Divides op1 by op2
% op1 % op2 Computes the remainder of dividing op1 by op2
Increments op by 1; evaluates to the value of op before
++ op++
it was incremented
Increments op by 1; evaluates to the value of op after it
++ ++op
was incremented
Decrements op by 1; evaluates to the value of op before
-- op--
it was decremented
Decrements op by 1; evaluates to the value of op after it
-- HASSOUNI Larbi
--op
wasEléments de base du langage
decremented 63
26
> op1 > op2 Returns true if op1 is greater than op2
>= op1 >= op2 Returns true if op1 is greater than or equal to op2
< op1 < op2 Returns true if op1 is less than op2
<= op1 <= op2 Returns true if op1 is less than or equal to op2
== op1 == op2 Returns true if op1 and op2 are equal
!= op1 != op2 Returns true if op1 and op2 are not equal
&& op1 && op2 Returns true if op1 and op2 are both true; conditionally evaluates op2
|| op1 || op2 Returns true if either op1 or op2 is true; conditionally evaluates op2
! !op Returns true if op is false

Returns true if op1 and op2 are both boolean and both
& op1 & op2 true; always evaluates op1 and op2; if both operands are
numbers, performs bitwise AND operation
Returns true if both op1 and op2 are boolean and either
op1 or op2 is true; always evaluates op1 and op2; if both
| op1 | op2
operands are numbers, performs bitwise inclusive OR
operation
Returns true if op1 and op2 are different — that is, if one
^ op1 ^ op2
HASSOUNI Larbi or the Eléments
other ofdethe du langagebut not both, is true
operands,
base 64
Shifts bits of op1 left by distance op2; fills with 0 bits on

<< op1 << op2
the right side
Shifts bits of op1 right by distance op2; fills with highest
>> op1 >> op2
(sign) bit on the left side
Shifts bits of op1 right by distance op2; fills with 0 bits on
>>> op1 >>> op2
the left side
Bitwise AND if both operands are numbers;
& op1 & op2
conditional AND if both operands are boolean
Bitwise OR if both operands are numbers;
| op1 | op2
conditional OR if both operands are boolean
^ op1 ^ op2 Bitwise exclusive OR (XOR)
~ ~op Bitwise complement
27
= op1 = op2 Assigns the value of op2 to op1
+= op1 += op2 Equivalent to op1 = op1 + op2
-= op1 -= op2 Equivalent to op1 = op1 - op2
*= op1 *= op2 Equivalent to op1 = op1 * op2
%= op1 %= op2 Equivalent to op1 = op1 % op2
&= op1 &= op2 Equivalent to op1 = op1 & op2
|= op1 |= op2 Equivalent to op1 = op1 | op2
^= op1 ^= op2 Equivalent to op1 = op1 ^ op2
<<= op1 <<= op2 Equivalent to op1 = op1 << op2
>>= op1 >>= op2 Equivalent to op1 = op1 >> op2
>>>= op1 >>>= op2 Equivalent to op1 = op1 >>> op2
If op1 is true, returns op2; otherwise, returns

?: op1 ? op2 : op3
op3
Voir Création et
Used to declare arrays, to create arrays, and
[] utilisation des
to access array elements
tableaux
Voir utilisation des
. Used to form long names
objets
Voir Définition des Delimits a comma-separated list of
(params)
méthodes parameters
Casts (converts) op to the specified type; an
(type) (type) op exception is thrown if the type of op is
incompatible with type
Voir utilisation des
objets et création
new Creates a new object or array
et utilisation
destableaux
instanceof op1 instanceof op2 Returns true if op1 is an instance of op2

28
Expression, Instructions et Blocs
Expressions
Une expression est une combinaison de variables, d’opérateurs, et d’appels de
méthodes, qui est construite en respectant la syntaxe du langage , et dont
l’évaluation produit une seule valeur.
Les expressions sont utilisées pour calculer et affecter des valeurs aux variables.
Elles sont aussi utilisées pour aider au contrôle du déroulement de l’exécution
d’un programme
Ordre de priorité des opérateurs
Soit l’expression:
4+7*2
Quel est le résultat de son évaluation? :
11 * 2 = 22 //évaluation du + en premier
ou
4 + 14 = 18 // évaluation de * en premier
Pour éviter cette ambiguité on peut utiliser les parenthèses: Par exemple :
(4 + 7) * 2 : donnera comme résultat 22 car l’expression entre parenthèse est
évaluée en premier
En absence de parenthèses l’ordre d’évaluation est déterminé par l’ordre de

priorité des opérateurs qui est établi par le langage Java et fourni dans le
tableau suivant
29
Ordre de Priorité des opérateurs dans l’ordre décroissant
Type d’opérateurs Priorité
postfix expr++ expr--
unaire ++expr --expr +expr -expr ~ !
multiplicatif * / %
additif + -
décalage << >> >>>
relationnel < > <= >= instanceof
egalité == !=
AND bit à bit &
XOR bit à bit ^
OR bit à bit |
AND logique &&
OR logique ||
Conditionnel ?:
Affectation
HASSOUNI Larbi = +=de-=
Eléments *= du
base /= langage
%= &= ^= |= <<= >>= >>>= 70
Ordre de Priorité des opérateurs
Les opérateurs qui ont une priorité plus élevée s’évaluent avant ceux qui ont
une priorité relativement plus faible.
Donc l’expression 4 + 7 * 2 est équivalente à 4 + (7 * 2) = 18
Les opérateurs qui se trouvent sur la même ligne ont la même priorité.
Lorsqu’une expression contient des opérateurs de même priorité, les

opérateurs binaires, excepté les opérateurs d’affectation, sont évalués de la
gauche vers la droite ;
Exemple : 14 / 2 * 3 = 7 * 3 = 21
par contre les opérateurs d’affectation sont évalués de la droite vers la gauche.
Exemple: y = x = 5; est équivalente à y = (x = 5)
30
Fonctions Mathématiques
Les fonctions mathématiques classiques se trouvent dans la classe Math. Le
tableau ci-dessous fournit quelques fonctions:
Fonction Description
sqrt double sqrt(double x) : Calcule la racine carrée d’un réel positif

x
pow double pow(double x, double a): Calcule la puissance xa.
sin double sin(double x): calcule le sinus de x
cos double cos(x) : calcule le cosinus de x
exp double exp(double x): Calcule l’exponentielle de x(e x)
log double log(double x):Calcule le logarithme de x
round long double round(x) : retourne l’entier le plus proche de x
Remarque: Toutes ces méthodes sont statiques et pour les utiliser

directement sans préfix, il faut ajouter en haut de votre programme la ligne:
import static java.lang.Math.*;
Les Instructions
31
Instructions
Les instructions sont l’équivalents des phrases dans un langage naturel
Une instruction est une unité complète d’exécution.
Les expressions ci-dessous peuvent se transformer en instructions en les

terminant par un point virgule ( ;).
- Expressions d’affectation
- N’importe quelle utilisation de ++ et --
- Appels de méthodes
- Expressions de création d’objets
De telles expressions sont appelées des instruction-expressions
Exemples d’instruction-expressions.
//instruction d’affectation
uneValeur = 14.5 ;
//instruction d’incrémentation
uneValeur++ ;
//Appel d’une méthode

System.out.println(uneValeur) ;
//Création d’un objet

Integer integerObject = new Integer(4);
32
En plus des instruction-expressions, il ya deux autres types
d’instructions.
-Instruction de déclaration de variables.

Exemple :
double uneValeur = 14.5;
- Instruction de contrôle qui détermine l’ordre

d’exécution des instructions.
Les instructions if et for sont des exemples d’instructions de

contrôle.
Exemple : if (a>b) {
Max = a;
}
Bloc
Un bloc est un groupe d’instructions placées entre crochet {} et peut être
utilisé
n’importe où une instruction simple est autorisée.
Le code qui suit présente deux blocs qui contient chacun une seule
instruction
if (Character.isUpperCase(aChar)) {
System.out.println("The character " + aChar + " is uppercase.");
}
else {
System.out.println("The character " + aChar + " is lowercase.");
}
33
Instructions de contrôle d’exécution
Lorsque vous écrivez un programme, vous
écrivez une suite d’instructions que vous
stockez dans un fichier.
Sans les instructions de contrôle d’exécution,

l’intérpréteur exécutera vos instructions dans
l’ordre ou elles apparaissent dans le fichier
de gauche à droite et du haut en bas.
Les instructions de contrôle permettent de

changer l’ordre séquentiel d’exécution des
instructions du programme en permettant de:
1. Exécuter des instructions en fonction de
l’évaluation d’une condition;
2. Répéter l’exécution d’un même groupe
d’instructions.
Le nombre de répétition dépend du
résultat de l'évaluation d'une condition.
34
Par exemple, dans la partie du code ci-dessous, l’instruction if
exécute l’instruction
System.out.println uniquement dans le cas ou la valeur
retournée par Character.isUpperCase(aChar) est égale à
true.
char aChar;
...
if (Character.isUpperCase(aChar)) {
System.out.println("The character " + aChar + " is
uppercase.");

Le langage Java fournit plusieurs instructions de contrôle d’exécution.
Elles sont fournies dans le tableau ci-dessous.
Type d’instruction Mot clé
boucle while, do-while, for
sélection if-else, switch-case
Gestion des
try-catch-finally, throw
exceptions
saut break, continue, label:, return

35
Format général d’une instruction de contrôle
Le format général d’une instruction de contrôle d’exécution est :
Techniquement, les accolades — { and } — ne sont pas obligatoires si le bloc

contient une seule instruction.
Cependant, il est recommandé de toujours utiliser les accolades parce qu’elles
rendent le code plus facile à lire, et aident à éviter de faire des erreurs lorsqu’on
modifie le programme.
Instruction de sélection « if …else »
if (expressionBooléenne)
bloc-instructions ou instruction
else
bloc-instructions ou instruction
if (x % 2 == 0) {
type = 0;
x++; Un bloc serait préférable, même
} s’il n’y a qu’une seule instruction
else
type = 1;
36
Expression conditionnelle
(Opérateur ternaire)
expressionBooléenne ? expression1 : expression2
int y = (x % 2 == 0) ? x + 1 : x;
est équivalent à
Parenthèses pas
int y; indispensables
if (x % 2 == 0)
y=x+1
else
y = x;
Instruction de sélecion <switch ….case…>
switch(expression) { Attention, sans break, les

case val1: instructions; instructions du cas suivant
break; sont exécutées !
...
case valn: instructions; S’il n’y a pas de clause
break; default, rien n’est exécuté si
expression ne correspond à
default: instructions; aucun case
}
Val1, val2, …valn sont des constantes
expression est de type char, byte, short, int, String ou

de type énumération.
Attention: le type long n'est pas autorisé, seuls les
types convertibles en int sont autorisés.
37
Exemple de switch
switch (year) {
case 7: annualInterestRate = 7.25;
break;
break;
break;
default: System.out.println(
"Wrong number of years, enter 7, 15, or 30");
}
Organigramme de switch
7 default
numOfYears
15 30
annualInterestRate=7.25 annualInterestRate=8.50 annualInterestRate=9.0 System.out.println("Wrong number of " +

"years, enter 7, 15, or 30");
System.exit(0);
Next
Statement
38
Exemple de switch
char lettre;
int nbVoyelles = 0, nbA = 0,
nbT = 0, nbAutre = 0;
Lettre = 'b';
switch (lettre) {
case 'a' : nbA++;
case 'e' : // pas d’instruction !
case 'i' : nbVoyelles++;
break;
case 't' : nbT++;
break;
default : nbAutre++;
}
Répétitions « tant que »
Il existe deux formes de répétions <<tant que>>:

1- Si
expressionBooleenne
while(expressionBooléenne) est false dés le départ,
bloc-instructions ou instruction le bloc d’instruction ne
sera exécutée aucune
fois
2-
do
Le bloc
bloc-instructions ou instruction d’instructions est
while(expressionBooléenne) exécuté au moins
une fois
On répéte l’exécution de <<bloc-instructions ou instruction>>

tant que <<expressionBooléenne>> est true.
On sort de la boucle lorsque <<expressionBooléenne>> devient false
39
Organigramme de la boucle while
while (continuation-condition) {
loop-body;
}
Next statement false
Continuation
condition?
true
Statement(s)
Next
Statement
Exemple de boucle while

i = 0;
int i = 0;
while (i < 100) { (i < 100)
false
System.out.println(
"Welcome to Java!");
i++; true
} System.out.println("Welcoem to Java!");
i++;
Next
Statement
40
Exemple : diviseur d’un nombre
public class Diviseur {
public static void main(String[ ] args) {
int i = Integer.parseInt(args[0]);
int j = 2;
while (i % j != 0) {
j++;
}
System.out.println("PPD de " + i + " : " + j);
}
}
Organigramme de la boucle do-while
do { Statement(s)
<Statements>
true
} while (continue-condition); Continue
condition?
<Next Statement>;
false
Next
Statement
41
Répétition for
For (init ; test ; incrément ) {

instructions; Exemple de for
}
int somme = 0;
for (int i=0; i < 100; i++) {
est équivalent à somme += i;
}
init; System.out.println(somme);
while (test) {
instructions;
incrément;
}
Organigramme de la boucle for

for (initial-action;
loop-continuation-condition;
Initial-Action
action-after-each-iteration) {
//loop body;
}
false
Action-After- Continuation
Each-Iteration condition?
true
Statement(s)
(loop-body)
Next
Statement
42
Exemple de la boucle for
i=0
false
i++ i<100?
true
int i;
System.out.println(
for (i = 0; i<100; i++) { “Welcom to Java!”);
System.out.println(
"Welcome to Java");
Next
} Statement
<Next Statement>
Boucle « for each »
Une nouvelle syntaxe introduite par la version 5 du

JDK simplifie le parcours d’un tableau
La syntaxe est plus simple/lisible qu’une boucle for
ordinaire
Attention, on ne dispose pas de la position dans le
tableau (pas de « variable de boucle »)
On verra par la suite que cette syntaxe est encore
plus utile pour le parcours d’une « collection »
43
Parcours d’un tableau
public class ForEach{
public static void main(String[] args){
String[ ] noms = {"Larbi", "Adil", "Tarik", "Mohammed"};
// Lire « pour chaque nom dans noms »
// « : » se lit « dans »
for (String nom : noms) {
System.out.println(nom);
}
}
}
Attention!! : Cette boucle ne permet de modifier les éléments du tableau.

Au cas où vous devez modifier lés élément du tableau, il faut utiliser la
boucle for classique
Instructions liées aux boucles
break sort de la boucle et continue après la boucle

continue passe à l’itération suivante
break et continue peuvent être suivis d’un nom d’étiquette
qui désigne une boucle englobant la boucle où elles se
trouvent
(une étiquette ne peut se trouver que devant une boucle)
44
Instruction break
false
Continuation
condition?
While(Continuation-condition){
Statements true
Statement(s)
break;
Statements break
} Statement(s)
Break doit toujours se trouver Next

Statement
dans un if
Instruction continue
While(<Continuation-condition>){ false
Continue
condition?
<Statements>
continue; true
<Statements> Statement(s)
} continue
<Next statement>
Statement(s)
continue doit toujours se

trouver dans un if Next
Statement
45
Exemple de continue et break
int somme = 0; Qu’affiche ce code

avec le tableau
for (int i=0; i < tab.length; i++) {
if (tab[i] == 0) {
1
break; -2
} 5
if (tab[i] < 0){ -1
0
continue; 8
} -3
somme += tab[i]; 10
}
System.out.println(somme); Somme = ?
Étiquette de boucles
boucleWhile: L’étiquette doit se

trouver juste avant
while (pasFini) { l’instruction d’itération
...
for (int i=0; i < t.length; i++) {
...
if (t[i] < 0) {
continue boucleWhile;
}
... Branchement à l’étiquette
} boucleWhile : sortie de la
boucle for et reprise de
... nouveau de la boucle
} while
46
Java
Classes et Objets
HASSOUNI Larbi Classes et Objets 1
1
JAVA : Classes et Objets
(1ère partie)
 Classes
 Objets
 Références
 Création d’objets
● constructeur par défaut
● gestion mémoire
 Accès aux attributs d’un objet
 Envoi de messages
 this : l’objet “courant”
 Objets et encapsulation
Classe
 Une classe est constituée de descriptions de :

 données : que l’on nomme attributs.
 procédures ou fonctions : que l’on nomme méthodes
 Une classe est un modèle de définition pour des objets
 ayant même structure (même ensemble d'attributs),
 ayant même comportement (mêmes opérations, méthodes),
 ayant une sémantique commune.
 Les objets sont des représentations dynamiques (instanciation),

« vivantes » du modèle défini pour eux au travers de la classe.
 Une classe permet d’instancier (créer)plusieurs objets
 Chaque objet est instance d’une (seule) classe
1
Classe : Notation UML
Point Nom de la classe
x : double;
attributs
y : double;
translater(x : double ,y : double)

distance() : double Méthodes
...
Classe : Syntaxe java

fichier Point.java
Attention :Le nom du fichier doit être identique au nom de la classe
class Point {
double x; nom de la classe

double y;
attributs
void translater(double dx,double dy){
x += dx;
y += dy; Membres de
} la classe
double distance() { méthodes

double dist;
dist = Math.sqrt(x*x+y*y);
return dist;
}
} HASSOUNI Larbi 5
Classes et Objets
2
Classe : Syntaxe java
Visibilité des attributs
class Point {
Les attributs sont des
double x; Variables « globales »
double y; au module que
constitue la classe :
void translater(double dx, double dy) { ils sont accessibles dans
Toutes les méthodes de
x += dx; la classe soit par leur
simple nom soit en étant
y += dy; qualifiées par le mot this
}
double distance() {
double dist;
dist = Math.sqrt( x * x + y * y );
return dist;
}
Classes et Objets
} HASSOUNI Larbi 6
Syntaxe java:Visibilité des variables

 De manière générale
Variable visible à l'intérieur du bloc (ensembles des instructions entre { … }) où elle est définie
class Visibilité {
int x
void methodeA() {
float z, w; … x:int z:float w:float
z= …;
}
void methodeB(float y) {
int z; x:int y:float z:int
do { Variable peut être définie
…;float w n'importe où dans un bloc
x:int y:float z:int; w:float

z++;
}
while (z < i);
x=z+ w ; Symbole non défini
}
HASSOUNI
} Larbi Classes et Objets 7
3
Syntaxe java:Visibilité des variables
 De manière générale
Variable visible à l'intérieur du bloc (ensembles des instructions entre { … }) où elle est définie
class Visibilité {
int x
void methodeA() {
float z, w; … x:int z:float w:float
i = …;
}
void methodeB(float y) {
int z; float x x : int y: float z:int
do {
float
…;float w
x : int y:float z:int; w:float

zz++;
}
while (z < i);
x=z+ w ; Symbole non défini
}
HASSOUNI Larbi 8
} Classes et Objets
Objets
 Un objet est instance d'une (seule) classe :
 il se conforme à la description que celle-ci fournit,

 il admet une valeur (qui lui est propre) pour chaque attribut déclaré dans la
classe,
 ces valeurs caractérisent l’état de l ’objet
 il est possible de lui appliquer toute opération (méthode) définie dans la classe
 Tout objet admet une identité qui le distingue pleinement des autres objets :
il peut être nommé et être référencé par un nom
4
Objets : Notation UML
représentation
explicite de
Point
la classe Relation
d’instanciation
« instance de »
Nom de classe
Nom d’objet
point1 : Point
x = 22 Valeurs des
y = 14 attributs
Notation d'un objet point1, instance de la classe Point

Objets
 Chaque objet point instance de la classe Point possédera son propre x et
son propre y
Point
point1 : Point point2 : Point point3 : Point
x = 10 x = 20 x = 30
y = 15 y = 25 y = 35
5
Objets : Structure des classes et objets en mémoire
 objet constitué d'une partie "Statique" et d'une partie "Dynamique”
 Partie statique :
• ne varie pas d'une instance de classe à une autre
• un seul exemplaire pour l'ensemble des instances d'une classe
• constituée des méthodes de la classe
• permet d'activer l'objet
 Partie dynamique :
• varie d'une instance de classe à une autre
• varie durant la vie d'un objet
• constituée d'un exemplaire de chaque attribut de la classe.
mémoire double x , y
Partie statique
structure de la classe void translater(…)
double distance()
isa isa isa

Partie dynamique
structure des x 10 x 20 x 30
instances
HASSOUNI Larbi y 15 y et Objets
Classes 25 y 35 12
Référence
 Pour désigner des objets d'une même classe (attributs ou variables dans le
corps d ’une méthode) on utilise des variables d’un type particulier : les
références
 Une référence contient l’adresse d’un objet
 pointeur vers la structure de données correspondant aux attributs
(variables d’instance) propres à l’objet.
mémoire
référence isa Référence null
x 57
y 6
 Une référence peut posséder la valeur null

 aucun objet n’est accessible par cette référence
 Déclarer une référence ne crée pas d’objet

 une
HASSOUNI référence
Larbi n’est pas un objet,etc’est
Classes Objetsun nom pour accéder à un objet 13
6
Référence : Déclaration en java
 Déclarations de références
Identificateur de classe Identificateur
Point p1;
Point p2, p3;
 Par défaut, à la déclaration une variable membre référence vaut

null  elle ne « pointe » sur aucun objet
Point p1; Point p1 = null;
Point
mémoire p1; Point p1 = null;
Référence null
P1
Références : Différents des pointeurs du C
 Comme un pointeur une référence contient une adresse (l’adresse de

l’objet référencé)
 Mais à la différence des pointeurs les seules opérations autorisées sur

les références est
1. l’affectation d ’une référence de même type
2. La comparaison avec l'opérateur égalité (==) de deux variables
références de même type
Point p1;
…
Point p2;
p2 = p1;
if(p1==p2) ……
p1++;
…
p2 += p1 +3;
7
Création d’objets
 La création d ’un objet à partir d’une classe est appelée instanciation.

L’objet créé est une instance de la classe.
 Instanciation se décompose en trois phases :
1 : obtention de l ’espace mémoire nécessaire à la partie dynamique de

l’objet et initialisation par défaut des attributs en mémoire
2 : appel de méthodes particulières, les constructeurs, définies dans la

classe ayant pour principal objectif initialiser les attributs pour donner un
état initial à l'objet
3 : renvoi d’une référence sur l’objet maintenant créé et initialisé.Cette

référence est stockée dans une variable référence.
Création d’objets : Instanciation

 Pour créer un objet on fait appel à l'opérateur new suivi du constructeur de la
classe: new constructeur(liste des arguments)
 les constructeurs ont le même nom que la classe
 il existe un constructeur par défaut:

 sans paramètres
 n'effectue aucune initialisation. Il conserve les initialisations par défaut.
 inexistant si un autre constructeur existe
Point p1; mémoire isa

x 0
p1 = new Point(); P1 y 0
Point p2 = new Point();

isa
P2
x 0
Point p3 = p2;
P3 y 0
HASSOUNI Larbi 17
Classes et Objets
8
Création d’objets
Gestion de la mémoire
 L’instanciation provoque une allocation dynamique de la mémoire
 En Java le programmeur n’a pas à se soucier de la gestion mémoire
 Si un objet n’est plus référencé (plus accessible au travers d’une référence),
la mémoire qui lui était allouée est automatiquement “ libérée ” (le
« garbage collector » la récupérera en temps voulu).
 Attention : destruction asynchrone (car gérée par un thread)
Aucune garantie de la destruction (sauf en fin de programme! Ou "appel
explicite au garbage collector")
Point p1; mémoire isa

x 0
p1 = new Point(); P1 y 0

isa
P2
x 0
Point p3 = p2;
P3 y 0
P1HASSOUNI
= p2; Larbi Classes et Objets 18
Accès aux attributs d’un objet
pour accéder aux attributs d'un objet on utilise une notation pointée :
nomDeObjet.nomDeVariableDinstance
Point p1;
p1 = new Point();
mémoire isa
Point p2 = new Point(); x 10
P1 y
Point p3 = p2; 0
p1.x = 10; isa

P2
p2.x = 14; x 14
P3 y 24
p3.y = p1.xLarbi
HASSOUNI + p2.x; Classes et Objets 19
9
Envoi de message
 pour "demander" à un objet d'effectuer une opération (exécuter l'une de
ses méthodes) il faut lui envoyer un message
 un message est composé de trois parties
 une référence permettant de désigner l'objet à qui le message est envoyé
 le nom de la méthode à exécuter (cette méthode doit bien entendu être
définie dans la classe de l'objet)

 les éventuels paramètres de la méthode
 envoi de message similaire à un appel de fonction

 les instructions définies dans la méthode sont exécutées (elles
s’appliquent sur les attributs de l’objet récepteur du message)
 puis le contrôle est retourné au programme appelant

Envoi de message : Exemple

 syntaxe :
 nomDeObjet.nomDeMethode(<paramètres effectifs>)
class Point {
double x; mémoire isa
double y; x 10.0
void translater(double dx, double dy){ P1 y 15.0
x += dx; y += dy;
}
isa
P2
double distance() { x 20.0
return Math.sqrt(x*x+y*y);
} y 45.0
} // Point

p1.translater(10.0,15.0); Envoi d’un message à l’objet p1
p2.translater(2*p1.x,3.0 * p1.y); Envoi d’un message à l’objet p2
System.out.println("distance
HASSOUNI Larbi de p1 à origine «+etp1.distance());
Classes Objets 21
10
Envoi de message
Paramètres des méthodes
 un paramètre d’une méthode peut être :
 Une variable de type simple
 Une référence typée par n’importe quelle classe (connue dans le contexte
de compilation)
 exemple : savoir si un Point est plus proche de l’origine qu’un autre Point.
Envoi de message
Paramètres des méthodes (suite)
Ajout d’une méthode à la classe Point
/**
* Test si le Point (qui reçoit le message) est plus proche de l’origine qu’un autre Point.
* @param p le Point avec lequel le Point recevant le message doit être comparé
* @return true si le point recevant le message est plus proche de l’origine que p, false
* sinon.
*/
boolean plusProcheOrigineQue(Point p) {
if (this.distance() < p.distance())
return true;
else
return false;
}
Utilisation
P1.translater(10,15);
p2.translater(20,5);
if (p1.plusProcheORigineQue(p2))
System.out.println("p1 est plus proche de l’origine que p2");
else
System.out.println("p2 est plus proche de l’origine que p1");
11
Envoi de message
Paramètres des méthodes (suite)
 Le passage de paramètres lors de l’envoi de message est un passage par valeur.

 À l’exécution le paramètre formel défini dans la signature de la méthode
correspond à une variable locale au bloc de la méthode
 Elle est initialisée avec la valeur de l’expression définie par le paramètre effectif.
Class Point { p1 = new Point();

... p2 = new Point();
void foo(double x, Point p) p2.x = 15; p2.y = 11;
{ p1.x = 20;
p1.foo(p1.x, p2); p1.x : 20
p.translater(10,10); System.out.println(« p1.x " +p1. x); p2.x : 25
x = x + 10; System.out.println("p2.x " + p2.x); p2.y : 21
p = new Point(); System.out.println("p2.y " + p2.y);
p.translater(10,10);
x 20
} p1 y 0
}
x 25
HASSOUNI
Classes Larbi
et Objets p2 y 24
21
L’objet courant : Désigné par le mot clé this
Dans un message l'accent est mis sur l'objet (et nom pas sur l'appel de fonction)
 en JAVA (et de manière plus générale en POO) on écrit :

d1= p1.distance(); d2=p2.distance();
 l'objet qui reçoit un message est implicitement passé comme argument à la

méthode invoquée
 cet argument implicite défini par le mot clé this
 une référence particulière
 désigne l’objet courant (objet récepteur du message, auquel

s’appliquent les instructions du corps de la méthode où this est utilisé)
 peut être utilisé pour rendre explicite l'accès aux propres attributs et
méthodes définies dans la classe
12
L’objet courant
This et envoi de message
Pour invoquer, dans le code d’une classe, l’une des méthodes qu’elle définit
(récursivité possible)
class Point {
double x;
double y; • L’objet qui reçoit le message se
// constructeurs renvoie à lui-même un autre
Point(double dx, double dy){ message
...
}
// méthodes
• this n’est pas indispensable
boolean plusProcheDeOrigineQue(Point p){
return p.distance() > this.distance() ;

• l’ordre de définition des méthodes
} n’a pas d ’importance
double distance() {
}
}
L’objet courant
This et variables d’instance
Implicitement, quand class Point {

Un attribut est utilisé double x;
dans le corps d’une double y;
Méthode, il s’agit de void translater(int dx, int dy) {
l’attribut de l’objet x += dx; y += dy;
courant }
<==> this.x += dx; this.y += dy;
double distance() {
this est, quelque fois return Math.sqrt(x*x+y*y);
utilisé, essentiellement }
pour lever les ambiguités void placerAuPoint(double x, double y){
this.x = x;
this.y = y;
}
}
13
Encapsulation
 Il est possible d’accéder directement aux variables d'un objet
 L’accès direct aux variables est non recommandé car :

contraire au principe d'encapsulation
les données d'un objet doivent être privées (c'est à dire protégées)
Elles ne doivent être accessible en lecture et écriture qu’au travers
de méthodes prévues à cet effet.
 Il est possible d'agir sur la visibilité (ou accessibilité) des membres (attributs
et méthodes) d’une classe vis à vis des autres classes, lors de leur définition.
 Le niveau de visibilité d’un membre (attribut, méthode, ou constructeur) peut être

défini en précédant sa déclaration d'un modificateur (private, public, protected, -)
Encapsulation
Visibilité des membres d’une classe
public private protected Pas de
modificateur
(package)
classe Peut être utilisée Peut être
dans n’importe utilisée
quelle autre classe uniquement
N/A N/A
de n’importe quel par les classes
package de son
package
attribut Accessible Accessible Accessible dans Accessible
directement uniquement dans les classes de dans les
depuis le code de le code de la même package et classes de
n’importe quelle classe qui le dans les sous même
autre classe définit classes package
méthode Peut être invoquée à Peut être Peut être Peut être
partir du code de invoquée invoquée dans les invoquée dans
n’importe quelle uniquement dans classes de même les classes de
autre classe la classe qui la package et dans même
HASSOUNI Larbi définit
Classes et Objets les sous classes package 29
14
Encapsulation
Méthodes d’accés aux attributs privés (accesseurs : accessors)
 les attributs déclarés comme privées (private) sont totalement protégés
 ne sont plus directement accessibles depuis le code d’une autre classe
public class Point { Point p1 = new Point();

private double x;
private double y;
p1.x = 10; p1.setX(10);
public void translater(int dx, int dy) { p1.y = 10; p1.setY(10);
x += dx; y += dy; Point p2 = new Point();
} p2.x = p1.x; p2.setX(p1.getX());
public double distance() {
return Math.sqrt(x*x+y*y); p2.y = p1.x + p1.y;
} p2.setY(p1.getX()+p1.getY());
public void setX(double x){
this.x = x;
}  pour modifier un attribut privé il faut
public void setY(double y){ passer par une méthode de type
this.y = y;
} procédure (appelée accesseur ou
public double getX(){ modificateur)
return x;
}
public double getY(){
 pour accéder à la valeur d’un attribut
return y; privé il faut passer par une méthode de
}HASSOUNI Larbi Classes ettype fonction (appelé accesseur)
Objets
}
30
Encapsulation : usage des méthodes privées
Une classe peut définir des méthodes privées à usage interne
public class Point { public class X {

private double x; Point p=new Point(…);
private double y; …
// constructeurs p.distance()
public Point(double dx, double dy){ …
... }
}
// méthodes
Private double distance() {
return Math.sqrt(x*x+y*y); • une méthode privée ne peut
} plus être invoquée en dehors
public boolean plusProcheDeOrigineQue(Point p){ du code de la classe où elle
return p.distance() < this.distance(); est définie
}
...
}
• la méthode privée distance a été définie pour un usage interne à

laHASSOUNI
classe. Elle
Larbiest invoquée par d’autres méthodes
Classes et Objets de sa classe 31
15
Encapsulation : Intérêts = Robustesse du code
 L’Accès aux données ne se fait qu’au travers des méthodes définies

par le concepteur de la classe.
Un objet ne peut être utilisé que selon la manière prévue lors de la
conception de sa classe. Ce qui élimine le risque d’utilisation
incohérente : Robustesse du code
// représentation d’un point de l’écran Code utilisant la classe Pixel

public class Pixel { Pixel p1 = new Pixel();
// représentation en coordonnées cartésiennes
private int x; // 0 <= x < 1024
private int y; // 0 <= y < 780 p1.translater(100,100);
public int getX() {
return x; //le message ci-dessus modifiera les
} //coordonnées de p1: x = 100, y = 100.
public void translater(int dx,int dy) {
if ( ((x + dx) < 1024) && ((x + dx) >= 0) ) p1.translater(1000,-300);
x = x +dx;
if ( ((y + dy) < 780) && ((y + dy) >= 0) )
y = y + dy; //Le message ci-dessus ne modifiera pas
} //les coordonnées de p1, puisque x
... //deviendrait =1100>1024 et y = -200<0
} //HASSOUNI
Pixel Larbi Classes et Objets
... 32
Encapsulation : Intérêts = Evolution du code
 Masquer l’implémentation Facilite d’évolution du logiciel
y
r θ
X
// représentation d’un point du plan // représentation d’un point de l’écran

public class Point { public class Pixel {
// représentation en coordonnées cartésiennes // représentation en coordonnées polaires
private double x; private double r
private double y; private double θ;
public double distance() { public double distance() {
return Math.sqrt(x*x+y*y); return r;
} }
public void translater(double dx,double dy) { public void translater(double dr,double dθ) {
….. …………
} }
... ...
} // Point } // Point
Point p1 = new Point(); La modification de l’implémentation n’a

Code utilisant la p1.translater(x1,y1); pas d’impact sur le code utilisant la
classe Point Larbi double d = p1.distance();Classes et Objets
HASSOUNI classe si la partie publique (l’interface
33
... de la classe) demeure inchangée
16
JAVA : Classes et Objets
2ème partie
 Constructeurs
 Surcharge des méthodes
 Variables de classe
 Méthodes de classe
 Constantes
 La fonction main()
 Initialiseur statique
Initialiseur d'instance
 Finalisation
Constructeurs
 Constructeurs d’une classe :
 Un constructeur est une méthode particulière utilisée pour la création

des objets de cette classe
 Le nom d’un constructeur est identique au nom de la classe
rôle d'un constructeur
effectuer certaines initialisations nécessaires pour le nouvel objet créé
Chaque classe JAVA possède au moins un constructeur
si une classe ne définit pas explicitement de constructeur, un constructeur
par défaut sans arguments et qui n'effectue aucune initialisation particulière
est invoqué. 35
HASSOUNI Larbi Classes et Objets
17
Constructeurs : Définition explicite
private double x;
private double y;
public Point(double x, double y){

this.x = x; Déclaration explicite
this.y = y; d ’un constructeur
}
• Le constructeur par
défaut est masqué
public void translater(double dx, double dy) {
x += dx; y += dy; • nom du constructeur identique
} à celui de la classe
return Math.sqrt(x*x+y*y); • pas de type de retour ni mot
} void dans la signature
public void setX(double x){
this.x = x; • retourne implicitement une
} instance de la classe (this)
public double getX(){
return x; • pas d ’instruction return
} dans le constructeur
… idem pour y
} Création d ’objet
new Point()
new Point(15,14)
Constructeurs multiples
 Possibilité de définir plusieurs constructeurs dans une même classe
possibilité d'initialiser un objet de plusieurs manières différentes
private double x; une classe peut définir un
private double y; nombre quelconque de
constructeurs
public Point(double x, double y){
this.x = x; •chaque constructeur possède le
this.y = y; même nom (le nom de la classe)
}
• le compilateur distingue les
constructeurs en fonction :
public Point(){ -du nombre
this.x = this.y = 0; -du type
} -de la position des arguments
• on dit que les constructeurs

public Point(Point p){ peuvent être surchargés
this.x = p.x; (overloaded)
this.y = p.y;
}
HASSOUNI Larbi
Classes et Objets 37
18
Surcharge des méthodes
 La surcharge (overloading) n’est pas limitée aux constructeurs, elle est

possible pour n'importe quelle méthode
 Il est possible de définir des méthodes possédant le même nom mais dont les
paramètres diffèrent
 lorsque qu'une méthode surchargée est invoquée le compilateur sélectionne

automatiquement la méthode dont le nombre et le type des arguments
correspondent au nombre et au type des paramètres passés dans l'appel de la
méthode
 des méthodes surchargées peuvent avoir des types de retour différents

mais à condition qu'elles aient des arguments différents
Surcharge des méthodes : Exemple

// attributs
private double x;
private double y;
// constructeurs
public Point(double x, double y){ Point p1=new Point(10,10);
this.x = x; Point p2=new Point(15,14);
this.y = y
} p1.distance();
// méthodes
public double distance() { p1.distance(p2);
}
public double distance(Point p){
return Math.sqrt((x - p.x)*(x - p.x)
+ (y - p.y) * ( y - p.y));
}
...
}HASSOUNI Larbi Classes et Objets 39
19
Constructeurs
Appel d’un constructeur par un autre constructeur
 dans les classes définissant plusieurs constructeurs, un constructeur peut

invoquer un autre constructeur de cette classe en utilisant le mot this.
 l'appel this(...)
- fait référence au constructeur de la classe dont les arguments
correspondent à ceux spécifié après le mot this
- ne peut être utilisé que comme première instruction dans le corps d’un
constructeur, il ne peut pas être invoqué après d'autres instructions
- (on comprendra mieux cela lorsque l'on parlera de l'héritage

et de l'invocation automatique des constructeurs de la superclasse)
Constructeurs
Appel d’un constructeur par un autre constructeur

private double x;
private double y; Constructeur général
// constructeurs
private Point(double x, double y)
{
this.x = x; Possibilité de définir des
this.y = y; constructeurs privés
}
public Point(Point p)
{
this(p.x, p.y);
} Intérêt :
public Point() •Factorisation du code.
{ •Un constructeur général invoqué par
this(0.0, 0.0)
des constructeurs particuliers.
}
...
}
20
Variables de classe
private double x; // abscisse du point
private double y; // ordonnée du point
// Définition des fonctions abscisse() et ordonnées()

...
/* Compare 2 points cartésiens
* @return true si les points sont égaux à 1.0e-5 près
*/
public boolean egale(Point p) {
double dx= x - p.abscisse();
double dy= y - p.ordonnee(); Modifier la classe Point
if(dx<0) afin de pouvoir modifier la valeur
dx = -dx; de la constante de précision
if(dy<0
dy= - dy;
return (dx < 1.0e-5 && dy < 1.0e-5);
}
}
Variables de classe
private double x;
private double y;
// imprécision pour tests d’égalité

private double eps = 1.0e-5;
//modifie la valeur de l' imprécision 1ère solution :
public void setEps(double eps) {
Ajouter une variable (un attribut)
this.eps = eps;
} eps à la classe avec une
//restitue valeur imprécision méthode accesseur et une
public double getEps() { méthode « modificateur »
return eps;
}
……..
// Compare 2 points cartésien Quels sont les problèmes liés à
public boolean egale(Point p) { cette solution ?
double dy= y - p.ordonnee();
if(dx<0) dx = -dx;
if(dy<0) dy= - dy;
return (dx < eps && dy < eps );
}
…..
} Classes et Objets
HASSOUNI Larbi 43
21
Variables de classe
x 10 Point p1 = new Point(10,14);
Point p2 = new Point(10.001,14.001);
y 14
P1.setEps(1 E-5);
p1 eps 1.0e-5 p2.setEps(10E-2);
System.out.println(p1.egale(p2)); -=> false on utilise
la précision de p1 (=0.00001)
x 10.001
System.out.println(p2.egale(p1)); => true on utilise la
y 14.001 précision de p2(= 0.01)
p2 eps 1.0e-2
Chaque instance possède sa propre valeur de précision. egale n’est plus garantie comme étant symétrique
P1.egale(p2) ≠ p2.egale(p1)
x 10 x 10.001 x 34
y 14 y 14.001 …….. y 17
eps 1.0e-5 eps 1.0e-2 eps 1.0e-4
Variables de classe
Cette information ne concerne pas une instance particulière mais

l’ensemble du domaine des Point
x 10 x 10.001 x 34
y 14 y 14.001 …….. y 17
eps 1.0 e-5
Comment représenter cet ensemble ?
En Java, rien ne peut être défini en dehors d’un objet. pas de variables globales
45
22
Variables de classe
Cet objet est instance de la classe Class
(package java.lang)
Objet-classe pour
Class Pour chaque classe
la classe Point utilisée, il existe un
objet-classe
Chaque instance name
possède une
Objet-classe pour
référence sur l’objet eps 1.0 e-5 la classe String
représentant sa
classe
name
isa isa isa
x 10 x 10 … x 10
y 14 y 14 y 14 isa isa
Point String
Point String
API de la classe Class

public String getName()
Returns the name of the entity (class, interface, array class, primitive type, or void)
represented by this Class object, as a String.
public Class getSuperclass()

Returns the Class representing the superclass of the entity (class, interface, primitive type
or void) represented by this Class
public Object newInstance() throws InstantiationException, IllegalAccessException

Creates a new instance of the class represented by this Class object.
…
Les membres d’une classes sont eux-mêmes représentés par des objets dont
les classes sont définies dans java.lang.reflect. (Introspection des objets)
public Field getField(String name) throws NoSuchFieldException, SecurityException

Returns a Field object that reflects the specified public member field of the class or
interfacerepresented by this Class object.
public Method[] getMethods() throws SecurityException

Returns an array containing Method objects reflecting all the public member methods of
the class or interface represented by this Class object, including those declared by the class or
interface and those inherited from superclasses and superinterfaces.
HASSOUNI Larbi 47
Classes et Objets
23
Exemple de programme utilisant la class Class
Extrait du livre :
Au cœur de Java 2
Notions fondamentales
import java.util.*; De Cay S.Horstmann & Gary Cornell
import java.lang.reflect.*; (Page : 225)
public class ReflectionTest

{
{
// read class name from command line args or user input
String name;
if (args.length > 0)
name = args[0];
else
{
Scanner in = new Scanner(System.in);
System.out.println("Enter class name (e.g. java.util.Date): ");
name = in.next();
}
try
{
// print class name and superclass name (if != Object)
Class cl = Class.forName(name);
Class supercl = cl.getSuperclass();
System.out.print("class " + name);
if (supercl
HASSOUNI != null && supercl != Object.class)
Larbi 48
Classes et Objets
System.out.print(" extends " + supercl.getName());
Exemple de programme utilisant la class Class (suite 1)
System.out.print("\n{\n");
printConstructors(cl);
System.out.println();
printMethods(cl);
System.out.println();
printFields(cl);
System.out.println("}");
}
catch(ClassNotFoundException e) { e.printStackTrace(); }
System.exit(0);
}
/**
Prints all constructors of a class
@param cl a class
*/
public static void printConstructors(Class cl)
{
Constructor[] constructors = cl.getDeclaredConstructors();
for (Constructor c : constructors)

{
String name = c.getName();
System.out.print(" " + Modifier.toString(c.getModifiers()));
System.out.print(" " + name + "(");
24
// print parameter types

Class[] paramTypes = c.getParameterTypes();
for (int j = 0; j < paramTypes.length; j++)
{
if (j > 0) System.out.print(", ");
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
/**
Prints all methods of a class
@param cl a class
*/
public static void printMethods(Class cl)
{
Method[] methods = cl.getDeclaredMethods();
for (Method m : methods)

{
Class retType = m.getReturnType();
String name = m.getName();
// print modifiers, return type and method name
System.out.print(" " + Modifier.toString(m.getModifiers()));
System.out.print(" " + retType.getName() + " " + name + "(");
HASSOUNI Larbi 50
Classes et Objets
// print parameter types

Class[] paramTypes = m.getParameterTypes();
for (int j = 0; j < paramTypes.length; j++)
{
if (j > 0) System.out.print(", ");
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
/**
Prints all fields of a class
@param cl a class
*/
public static void printFields(Class cl)
{
Field[] fields = cl.getDeclaredFields();
for (Field f : fields)

{
Class type = f.getType();
String name = f.getName();
System.out.print(" " + Modifier.toString(f.getModifiers()));
System.out.println(" " + type.getName() + " " + name + ";");
}
}
}
25
Variables de classe
Cet objet est instance de la classe Class
(package java.lang)
Objet-classe pour
Class
la classe Point
name
Chaque instance Comment sont décrites les
possède une eps 1.0 e-5
référence sur l’objet caractéristiques de l’objet
représentant sa représentant la classe
classe
Point?
isa isa isa
x 10 x 15 … x 30
Dans java ceci est fait au sein du code de
y 14 y 25 y 50 la classe Point.
Dans le code de la classe Point il faut

distinguer le niveau auquel s’appliquent
les descriptions (classe ou aux instances)
Point
Les descriptions qui concernent l’objet-
classe sont précédées du mot clé static
Variables de classe : Déclaration

private double x;
private double y;
// imprécision pour tests d’égalité Variable d’instance

private static double eps = 1.0e-5;
public void setEps(double eps) {
this.eps = eps; Variable de classe
} déclaration précédée
du mot clé static
public double getEps() {
return eps;
}
……
// Compare 2 points cartésiens
public boolean equals(Point p) { Dans le corps de la classe
double dx= x - p.abscisse(); les variables de classe sont
double dy= y - p.ordonnee(); utilisées comme les autres
if(dx<0) variables… ou presque
dx = -dx;
if(dy<0
dy= - dy;
return (dx < eps && dy < eps);
}
………..
26
Accès aux Variables de classe
private double x;
private double y;
// imprécision pour tests d’égalité

private static double eps = 1.0e-5; Accéder à eps en dehors de
public void setEps(double eps) { la classe Point
this.eps = eps;
} Warning :The static field eps should il serait nécessaire de
be accessed in a static way posséder une référence sur
public double getEps() { une instance de Point pour
return eps; lui envoyer un message
} getEps ou setEps
……
// Compare 2 points cartésiens Point p = new Point (…);
public boolean equals(Point p) { …
double dx= x - p.abscisse(); p.setEps(1.e-8);
if(dx<0)
dx = -dx; eps n’est pas un attribut de
if(dy<0 l’objet Point (this) mais un
dy= - dy; attribut de l’objet représentant
return (dx < eps && dy < eps); la classe Point
}
……….. Comment faire pour désigner
}HASSOUNI Larbi Classes et Objets l’objet classe Point ? 54
Accès aux Variables de classe

private double x;
private double y; de la même manière que les
variables d'instance sont
// imprécision pour tests d’égalité accédées via les noms
private static double eps = 1.0e-5; (références) des instances de
public void setEps(double eps) { la classe, les variables de
this.eps = eps; classe sont accédées au
} travers du nom de la classe
Warning :The static field eps should
be accessed in a static way
public double getEps() {
return eps;
NomDeClasse.nomDeVariable
}
…… le nom de la classe est
// Compare 2 points cartésiens l’identificateur de la référence
public boolean equals(Point p) { créée par défaut pour désigner
double dx= x - p.abscisse(); l’objet-classe
if(dx<0)
this.x Variable d'instance
dx = -dx;
if(dy<0
dy= - dy;
return (dx < eps && dy < eps); Point.eps Variable de classe
}
………..
27
Méthodes de classe
private double x;
private double y; Les méthodes setEps et getEps
ne doivent plus être associées aux
// imprécision pour tests d’égalité instances de la classe Point mais
private static double eps = 1.0e-5; à l’objet-classe Point
Public static void setEps(double eps) {
Point.eps = eps;
} Déclaration de méthodes de
classe (méthodes statiques)
public static double getEps() {
return eps;
}
Attention : à l’intérieur du corps
……
d’une méthode statique il n’est
// Compare 2 points cartésiens
possible d’accéder qu’aux
public boolean equals(Point p) {
membres statiques de la classe
if(dx<0)
dx = -dx;
if(dy<0
dy= - dy; Appel d’une méthode de classe :
return (dx < eps && dy < eps); Envoi d’un message à l’objetcclasse
}
}HASSOUNI Larbi Classes et Objets Point.setEps(1.e-8); 56
Variables de classe : Constantes

Des constantes nommées peuvent être définies par des variables de classe
dont la valeur ne peut être modifiée
public class Pixel {
Déclarations de
public static final int MAX_X = 1024; variables de classe
public static final int MAX_Y = 768;
Le modifieur final est
// variables d'instance
utilisé pour indiquer que la
private int x;
valeur d'une variable (ici
private int y;
de classe) ne peut jamais
...
être changée
// constructeurs
// crée un Pixel de coordonnées x,y
public Pixel()
{
...
}
...
}
28
Membres statiques
 Ce sont des membres dont la déclaration est précédée du modificateur static

 variables de classe : définies et existent indépendamment des instances
 méthodes de classe : dont l’invocation peut être effectuée sans passer
par l’envoi d’un message à l’une des instances de la classe.
 accès aux membres statiques

directement par leur nom dans le code de la classe où ils sont définis,
 en les préfixant du nom de la classe en dehors du code de la classe
•NomDeLaClasse.nomDeLaVariable
• NomDeLaClasse.nomDeLaMéthode(liste de paramètres)
• n'est pas conditionné par l'existence d'instances de la classe,
Math.PI Math.cos(x) Math.toRadians(90) ...
Signification de System.out.println
System . out . println (« Bonjour");
Classe System
du package
java.lang
Variable de classe
(référence un objet de
type PrintStream)
Méthode d ’instance de
la classe PrintStream
du package java.io
HASSOUNI Larbi 59
Classes et Objets
29
 Le point d ’entrée pour l’exécution d ’une application Java est la
méthode statique main de la classe spécifiée à la machine virtuelle
 la syntaxe de cette méthode est :

 String[] args
args : tableau d’objets String (chaînes de caractères) contenant les arguments
de la ligne de commande
public class TestArgs {

System.out.println("nombre d ’arguments : " + args.length);
for (int i =0; i < args.length; i++)
System.out.println(" argument " + i + " = " + args[i]);
}
}
nombre d ’arguments : 3
Java TestArgs arg1 20 35.0 argument 0 : arg1
argument 1 : 20
argument 2 : 35.0
HASSOUNI Larbi
 Les différentes classes d’une même application peuvent éventuellement

chacune contenir leur propre méthode main.
 Au moment de l’exécution pas d’hésitation quant à la méthode main() à

exécuter
 C’est celle de la classe indiquée à la JVM
Class1.class
Java class1
Class2.class
main(…)
Class3.class main(…)
Java class3
main(…)
 possibilité de définir de manière indépendante un test unitaire

 Interêt
HASSOUNI Larbi pour chacune des classes d’un système 61
Classes et Objets
30
Initialisation des variables : à la déclaration
 les variables d'instance et de classe peuvent avoir des "initialiseurs"

associés à leur déclaration
modifieurs type nomDeVariable = expression;
private double x = 10;

private double y = x + 2;
private double z = Math.cos(Math.PI / 2);
private static int nbPoints = 0;
 variables de classe initialisées la première fois que la classe est chargée.

 variables d'instance initialisées lorsqu'un objet est créé.
 les initialisations ont lieu dans l’ordre des déclarations.
TestInit.java [4:1] illegal forward reference
public class TestInit { private double y = x + 1;
private double y = x + 1; ^
private double x = 14.0; 1 error
... Errors compiling TestInit.
} HASSOUNI Larbi Classes et Objets 62
Initialisation des variables : initialiseurs statiques
si les initialisations nécessaires pour les variables de classe ne peuvent être faites
directement avec les initialiseurs (expression) JAVA permet d'écrire une méthode
(algorithme) d'initialisation pour celles-ci : l'initialiseur statique
xs un nombre tiré au hasard entre 0 et 10
ys somme de n nombres tirés au hasard, n étant la partie entière de xs
zs somme de xs et ys
 Déclaration d’un initialiseur statique

private static double xs = 10 * Math.random();
private static double ys ;
 static { bloc de code }
private static double zs = xs + ys;
static {
 méthode
int n = (int) xs; • sans paramètres
ys = 0; • sans valeur de retour
for (int i = 0; i < n; i++) • sans nom
ys = ys + Math.random();
}
 Invocation
HASSOUNI Larbi •automatique et une seule fois lorsque la classe est chargée
Classes et Objets • dans l’ordre d’apparition dans le code de la classe 63
31
Exemple d’utilisation des blocs d’initialisation
statique et d’objets
/**@version 1.01 2004-02-19
@author Cay Horstmann
*/
import java.util.*;
public class ConstructorTest
{
{
// fill the staff array with three Employee objects
Employee[] staff = new Employee[3];
staff[0] = new Employee("Harry", 40000);
staff[1] = new Employee(60000);
staff[2] = new Employee();
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName()
+ ",id=" + e.getId()
+ ",salary=" + e.getSalary());
}
class Employee{
// three overloaded constructors
public Employee(String n, double s){
name = n;
salary = s;
System.out.println("Execution du 1er constructeur");
}
public Employee(double s) {
// calls the Employee(String, double) constructor
this("Employee #" + nextId, s);
System.out.println("Execution du 2eme constructeur");
}
// the default constructor
public Employee() {
// name initialized to ""--see below
// salary not explicitly set--initialized to 0
// id initialized in initialization block
System.out.println("Execution du constructeur par defaut");
}
public String getName() { return name; }
public double getSalary() { return salary; }
public int getId() { return id; }
32
private static int nextId;
private int id;

private String name = ""; // instance field initialization
private double salary;
// static initialization block

static
{
Random generator = new Random();
// set nextId to a random number between 0 and 9999
nextId = generator.nextInt(10000);
System.out.println("Execution du bloc static********");
}
// object initialization block

{
id = nextId;
nextId++;
System.out.println("Execution du bloc d'instance: Creation d'objet
Id:"+id);
}
}
Destruction des objets : Rappels
 La libération de la mémoire alloué aux objets est automatique

 lorsqu'un objet n'est plus référencé le "garbage
collector" récupère l'espace mémoire qui lui était réservé.
 Le "garbage collector" est un processus (thread) qui s'exécute en tâche

de fond avec une priorité faible
 s'exécute :
• lorsqu'il n'y a pas d'autre activité (attente d'une entrée clavier ou

d'un événement souris)
• lorsque l'interpréteur JAVA n'a plus de mémoire disponible

– seul moment où il s'exécute alors que d'autres activités avec
une priorité plus forte sont en cours (et ralentit donc réellement
le système)
 peut être moins efficace que la gestion explicite de la mémoire , mais

programmation
HASSOUNI Larbi beaucoup plus simple
Classes et sure.
et Objets 67
33
Destruction des objets : Finalisation
 Le "Garbage Collector" gère automatiquement les ressources mémoire utilisées

par les objets
 un objet peut parfois détenir d'autres ressources (descripteurs de fichiers,

sockets....) qu'il faut libérer lorsque l'objet est détruit.
 Il faut prévoir une méthode dite de "finalisation" à cet effet pour

 fermer les fichiers ouverts, terminer les connexions réseau..., avant la
destruction des objets
 la méthode de "finalisation" :
 est une méthode d'instance
 doit avoir la signature void finalize()
 est invoquée juste avant que le "Garbage Collector" ne récupère l'espace
mémoire associé à l'objet
 JAVA ne donne aucune garantie sur quand et dans quel ordre la récupération
de la mémoire sera effectuée,
 impossible de faire des suppositions sur l'ordre dans lequel les méthodes
de finalisation seront invoquées.
68
Destruction des objets : Finalisation exemple
class Point {
private double x;
private double y; Point p1 = new Point(14,14);
public Point(double x, double y) { Point p2 = new Point(10,10);
this.x = x; System.out.println(p1);
this.y = y; System.out.println(p2);
} p1.translater(10,10); Appel explicite
public void translater(double dx, double dy) { p1 = null; du Garbage
x += dx; System.gc(); Collector
y += dy; System.out.println(p1);
} System.out.println(p2);
public String toString() {
return "Point[x:" + x + ", y:" + y + "]";
}
public void finalize() { Point[x:14.0, y:14.0]
System.out.println("finalisation de " + this); Point[x:10.0, y:10.0]
} finalisation de Point[x:24.0, y:24.0]
} null
Point[x:10.0, y:10.0]
HASSOUNI Larbi
34
Java
Les Tableaux
Tableaux En Java 1
Généralités sur les Tableaux
 Les tableaux sont des objets en java et non seulement une suite
d'emplacements mémoire comme il est le cas en C/C++
 Ils constituent des collections ordonnées d'éléments
 Les éléments d'un tableau peuvent être :
 des variables de type primitif (int, boolean, double, char...)
 des références sur des objets ( y compris des références sur

d'autres tableaux)
HASSOUNI Larbi 2
Déclaration d’un tableau à une dimension

 Déclaration
 typeDesElements[ ] nomDuTableau;
ou bien
 typeDesElements nomDuTableau[ ];
avec
 typeDesElements un des types de base du langage JAVA
(char, int, float, double...) o
un nom de classe
 nomDuTableau l’identificateur pour désigner le tableau
Remarque : Il est recommandé d’utiliser la première forme de déclaration car permet de
déclarer plusieurs tableaux ayant le même type des éléments en une seule ligne .
Exemples
double[ ] tab1; //identique à double tab[]
Int[ ] entiersPremiers, nombresCubes; //déclare deux tableaux dont les éléments sont de type int
Etudiant[ ] classe; //déclare un tableau dont les élements sont des objets instances de la classe Etudiant
Compte[
HASSOUNI Larbi] clients; //déclare un tableau dont les élements sont des objets instances de la classe Compte
3
Tableaux En Java 1
Création d’un tableau à une dimension
 la taille d'un tableau n'est pas spécifiée à la déclaration.
 les tableaux sont des objets,
 La déclaration : typeDesElements[] nomDuTableau;
définit une référence vers un objet de type "tableau d'éléments de type

typeDesElements".
 Le nombre d'éléments du tableau sera déterminé quand l'objet tableau sera
effectivement créé en utilisant new.
 cette taille fixée à la création est fixe, elle ne pourra plus être modifiée par la
suite.
Exemple
int[] entiersPremiers; //déclaration d’une référence vers l’objet tableau
entiersPremiers = new int[50]; //Création de l’objet tableau de 50 entiers
//Déclaration et création d’un tableau de 1000 élements de type Compte

Compte[] listeDesComptes = new Compte[1000];
HASSOUNI Larbi 4
Création d’un tableau à une dimension
 La création d ’un tableau par new

 alloue la mémoire nécessaire en fonction
du type des éléments du tableau
de la taille spécifiée
 initialise le contenu du tableau

 les éléments de types numériques sont initialisés à "0"
 les éléments de type classe sont initialisé à null

(car chaque élément est une référence à un objet instance de la classe.
Et chaque élément doit être créé par new et rangé dans le tableau)
HASSOUNI Larbi 5
Tableaux En Java 2
Tableaux à une dimension
Exemples de Création
int[ ] tab1; isa

tab1 = new int[5]; tab1
int[ ] tab2 = tab1; 0 0
1 0
tab2 2 0
3 0
4 0
Etudiant[ ] classe1; isa

classe1 = new Etudiant[4]; classe1
null
Etudiant[ ] classe2 = classe1; 0
classe2 1
2
HASSOUNI Larbi 6

Accès aux éléments
 accès aux éléments d’un tableau unidimensionnel

 accès à un élément d'un tableau s'effectue à l'aide d'une expression
de la forme : nomDuTableau[expression1]
où
 expression1 s’évalue en une valeur entière dans les bornes du tableau
(>= 0 : plus petit indice et <= length-1 : plus grand indice)
on peut rencontrer une telle expression aussi bien en partie gauche
qu’en partie droite d'une affectation
 length donne la dimension (entier) du tableau

nomDuTableau.length = indice max c-a-d indice du dernier élément du
tableau +1
 Java vérifie automatiquement l'indice lors de l'accès (comparaison avec les

bornes)
Si l’indice est en dehors de l’intervalle [0, length-1] => génération de
l’exception:
HASSOUNI Larbi ArrayIndexOutOfBoundsException 7
Tableaux En Java 3
Précison sur length
 Précision sur lenght
 lenght est une constante d’instance publique
=>(non respect du principe d’encapsulation)
lenght est déclarée public final

=>(Initialisation à la création du tableau, et ne peut pas être modifiée)
nomDuTableau.length = dimension (nombre d’éléments) du tableau

nomDuTableau.length – 1 = indice max du tableau
public class TestArgs {

Ce programme
System.out.println("nombre d ’arguments : " + args.length); permet d’afficher les
arguments fournis
for (int i =0; i < args.length; i++) dans la ligne de
commande lors de
System.out.println(" argument " + i + " = " + args[i]); l’exécution du
} programme
}
HASSOUNI Larbi 8

Exemples de Création
int[ ] tab1; isa

tab1 = new int[5]; tab1
tab1[0] = 1; 0 1
for (int i=1; i<5; i++) 1 2
tab1[i] = tab1[i-1]*2; 2 4
3 8
4 16
isa
nom Moha
Public class Etudiant{
String nom, prenom; isa prenom Ali
classe1
double note;
} note 17
0 null
Public Etudiant(String n, String p,double score){
1
nom = n; prenom = p; note = score;
}} 2
3
Etudiant[ ] classe1 = new Etudiant[4];
HASSOUNI
Classe[0] LarbiEtudiant(« Moha », « Ali », 17);
= new 9
Tableaux En Java 4
Initialisation d’un tableau à une dimension
 Initialisation d’un tableau = une autre manière de créer des tableaux :
 en donnant explicitement la liste de ses éléments à la déclaration

(liste de valeurs entre accolades)
 Exemples :
int[ ] tab1 = { 1, 2 ,3, 4, 5};
Etudiant[ ] classe1 = { new Etudiant(« Moha », « Ali », 15),

new Etudiant(« Toto », «Najib », 12),
new Etudiant(« Manolo », «Brahimi », 11),
new Etudiant(« Kardi », « Rachid », 17) };
 L ’allocation mémoire (équivalent de l ’utilisation de new) est prise en

charge par le compilateur
HASSOUNI Larbi 10
Tableaux à plusieurs dimension

Déclaration
 tableau dont les éléments sont eux mêmes des tableaux
 un tableau à deux dimensions se déclarera ainsi de la manière suivante :
typeDesElements[ ][ ] nomduTableau;
Exemples
double[ ][ ] matrice;
Etudiant[ ][ ][ ] cubeEtud;
HASSOUNI Larbi 11
Tableaux En Java 5
Création
 dimensions du tableau
 ne sont pas spécifiées à la déclaration (comme pour les tableaux à une
seule dimension).
 ne sont indiquées que lors de la création
 obligatoire que pour la première dimension.
 autres dimensions peuvent n'être spécifiées que lors de la
création effective des tableaux correspondants.
Exemples :
double [ ][ ] matrice = new double[4][4]; Création d’une matrice 4x4
de réels
double [ ][ ] matrice = new double[4][ ];
for (int i=0; i < 4; i++)
matrice[i] = new double[4]; Les 3 écritures sont
équivalentes
double [ ][ ] matrice;
matrice = new double[4][ ];
for (int i=0; i < 4; i++)
matrice[i] = new double[4];
HASSOUNI Larbi 12

Création
 chaque tableau imbriqué peut avoir une taille différente.
Exemple :
isa
int [ ][ ] tabsInt; 0 0
tabsInt = new int[3][ ]; 1 0 isa
tabsInt[0] = new int[5]; 2 0
tabsInt[1] = new int[4]; 3 0 0 0
4 0 1 0
tabsInt[2] = new int[6];
2 0
3 0
tabsInt isa
isa
0
1 0 0
2 1 0
2 0
3 0
4 0
HASSOUNI Larbi 5 0 13
Tableaux En Java 6
Accès aux éléments d’un tableau à plusieurs dimensions
 accès aux éléments d’un tableau à deux dimensions
L’accès à un élément d'un tableau s'effectue à l'aide d'une expression de la forme :

nomDuTableau[expression1][expression2]
où
– expression1 s’évalue en une valeur entière entre les bornes
0 et nomDuTableau.length - 1
– expression2 délivre une valeur entière entre les bornes
0 et nomDuTableau[expression1].length - 1
char[ ][ ] tabChar = new char[3][ ];

tabChar[0] = new char[4];
tabChar[1] = new char[6];
tabChar[2] = new char[5]
tabChar[0][0] = ‘J’; tabChar[0][1] =‘A’; tabChar[0][2] = ‘V’; tabChar[0][3] =‘A’;
tabChar[1][0] = ‘B’; tabChar[1][1] =‘R’; tabChar[1][2] = ‘A’; tabChar[1][3] =‘V’; tabChar[1][4] = ‘E’;
tabChar[1][5] =‘R’;
tabChar[2][0]
HASSOUNI =Larbi
‘C’; tabChar[2][1] =‘O’; tabChar[2][2] = ‘B’; tabChar[2][3] =‘O’; tabChar[2][4] = ‘L’; 14
Initialisation d’un tableau à plusieurs dimensions
 Il est possible de créer un tableau à plusieurs dimensions en initialisant

ses éléments lors de sa déclaration (Comme pour tableaux à une dimesion)
 exemples :
int[ ][ ] t1 = { int[ ][ ] t1 = new int[2][5];
t1[0][0]=1; t1[0][1]=2; t1[0][2]=3; t1[0][3]=4; t1[0][4]=5;
{ 1, 2, 3, 4, 5},
{ 6, 7, 8, 9, 10}
≡
t1[1][0]=6; t1[1][1]=7; t1[1][2]=8; t1[1][3]=9; t1[1][4]=10;
};
Point[ ][ ] pts = {
Point[ ][ ] pts = new Point[3][2];
{ new Point(10,15),new Point(20,25)},
{ new Point(30,35), new Point(40,45)} , ≡ Pts[0][0] = new Point(10,15); Pts[0][1] = new Point(20,25);
Pts[1][0] = new Point(30,35); pts[1][1] = new Point(40,45) ;
{ new Point(50,55),new Point(60,65)} , Pts[2][0] = new Point(50,55); ,pts[2][1] = new Point(60,65) ;
};
HASSOUNI Larbi 15
Tableaux En Java 7
Classe Arrays : Tri d’un tableau
 package java.util définit une classe, Arrays, qui propose des méthodes
statiques (de classe) pour le tri et la recherche dans des tableaux.
Exemple : tri d’un tableau
// tableau de 1000 réels tirés au hasard

// dans l ’intervalle [0..100[
double[ ] tab = new double[100];
for (int i = 0; i < tab.length; i++)

tab[i] = Math.random()*100;
// tri du tableau
Arrays.sort(tab);
// affichage du tableau trié

HASSOUNI Larbi
System.out.print(tab[i] + " " ); 16
Classe Arrays : Recherche d’une donnée dans un tableau

Exemple : recherche dans un tableau
// tableau de 100 entiers tirés au hasard
// dans l ’intervalle [0..100[
int[ ] tab = new int[100];

tab[i] = (int) (Math.random()*100);
// tri du tableau
Arrays.sort(tab);
// recherche de la valeur 45
int pos = Arrays.binarySearch(tab,45);
// utilisation des résultats de la recherche

if (pos >= 0)
System.out.println("position de 45 : " + pos);
else {
System.out.println(« 45 n ’est pas dans le tableau");
System.out.println("position d ’insertion : " + (-(pos+1)));
HASSOUNI Larbi 17
}
Tableaux En Java 8
Classe Arrays : Quelques méthodes extraites
de la documenetation de l’API
static boolean deepEquals(Object[] a1, Object[] a2)

Returns true if the two specified arrays are deeply equal to one another.
static void fill(double[] a, double val)

Assigns the specified double value to each element of the specified
array of doubles.
static String toString(double[] a)

Returns a string representation of the contents of the specified array.
static void sort(double[] a)

Sorts the specified array of doubles into ascending numerical order.
static void sort(double[] a, int fromIndex, int toIndex)

Sorts the specified range of the specified array of doubles into ascending
numerical order.
HASSOUNI Larbi 18
System.arraycopy()
The subroutine, System.arraycopy(), is a static member subroutine in the

standard System class. Its declaration has the form
public static void arraycopy(Object sourceArray, int sourceStartIndex,

Object destArray, int destStartIndex, int count)
For example, to make a copy of the array, A, using this subroutine, you would say:
double B[ ] = new double[A.length];

System.arraycopy( A, 0, B, 0, A.length );
HASSOUNI Larbi 19
Tableaux En Java 9
Arrays and for-each Loops
BaseType[ ] anArray = new BaseType[N];
for ( BaseType item : anArray ) {

.
. // process the item
.
}
for ( int index = 0; index < anArray.length; index++ ) {

BaseType item;
item = anArray[index]; // Get one of the values from the array
.
. // process the item
.
}
HASSOUNI Larbi 20
It’s important to note that a for-each loop processes the values in the array, not the
elements (where an element means the actual memory location that is part of the
array).
For example, consider the following incorrect attempt to fill an array of integers
with 17’s:
int[] intList = new int[10];

for ( int item : intList ) { // INCORRECT! DOES NOT MODIFY THE ARRAY!
item = 17;
}
The assignment statement item = 17 assigns the value 17 to the loop control
variable, item.
However, this has nothing to do with the array. When the body of the loop is
executed, the value from one of the elements of the array is copied into item.
The statement item = 17 replaces that copied value but has no effect on the
array element from which it was copied; the value in the array is not
HASSOUNI Larbi
changed. 21
Tableaux En Java 10
Java
Packages
ou
NameSpaces
1
Qu’est ce qu’un package?
• Les classes Java sont regroupées en paquetages

(packages en anglais)
• Ils correspondent aux « bibliothèques » des autres
langages comme le langage C, Fortran, Ada, etc...
• Les paquetages offrent un niveau de modularité
supplémentaire pour
– réunir des classes suivant un centre d’intérêt commun
– la protection des attributs et des méthodes
• Le langage Java est fourni avec un grand nombre de
paquetages
HASSOUNI 2
Exemples de packages
java.lang : rassemble les classes de base JAVA, Object, String,
System...Ce package est importé par défaut.
java.applet : fournit les classes nécessaires pour créer et utiliser les applets.
 java.util : classes pour les collection
 java.awt (Abstract Window Toolkit) : Contient les classes pour créer les
interfaces utilisateur et pour dessiner des graphiques.
Java.io : Fournit les classes pour les entrées/sorties (flux de données,

sérialisation, fichiers).
Javax.crypto : Fournit les classes et interfaces pour les opérations de

cryptographie.
Javax.swing : Provides a set of "lightweight" (all-Java language)
components that, to the maximum degree possible, work the

same on all platforms.
HASSOUNI 3
1
Rôle d’un package
 Le regroupement des classes dans des packages permet d'organiser les
librairies de classes Java et d'éviter d'éventuels conflits de noms.
Exemple : Dans les librairies standards deux classes Date…
Mais définies dans des packages différents
nom complet de la classe

(Fully Qualified Name) :
HASSOUNI nomDupackage.nomDeLaClasse 4
Packages et Système de fichiers

Java
Java.sql Chaque classe est Java.util

stockée dans un
fichier
Chaque package
Date.class correspond à un Date.class
répertoire
Java.awt
Java.awt.DataTransfer
Chaque package peut contenir :
•Des classes Button.class
•Des interfaces
•D’autres package (sous
package) Paint Clipboard.class
HASSOUNI 5
La hiérarchie des packages correspond à une hiérarchie de répertoires
2
Packages et Système de fichiers
● A une hiérarchie de packages correspond une hiérarchie de répertoires

dont les noms coïncident avec les composantes des noms de package
Java
Java.awt src classes

Java.util
Java.awt.image
java java
Date
DataBuffer
awt sql util awt sql util
Java.sql Java.awt.event image event image event
Date
ActionListener Au niveau des Au niveau du
sources (.java) bytecode (.class
HASSOUNI 6
Ajout d’une classe à un package

Instruction package
Pour ajouter une classe à un package, il faut d’abord créer un répertoire qui
correspond au package puis utiliser l’instruction:
package nomDuPackage;
L’instruction package est optionnelle, mais lorsqu’elle existe, elle doit être la
première instruction du fichier qui contient la classe.
Si elle est absente, la classe est ajoutée au package par défaut qui correspond au
répertoire courant où est stocké le fichier de la classe.
. Répertoire courant
package mypackage;
public class UneClasse {
package mypackage.etudiants; mypackage
} public class EtudiantFB{ MaClase
package mypackage.etudiants;
} public class EtudiantFC { matieres
package mypackage.matieres; etudiants
} public class MatierePr{
package mypackage.matieres; UneClasse
} public class MatiereTh{
EtudiantFB EtudiantFC MatierePr MatiereTh
} public class MaClasse{
HASSOUNI }
7
3
Packages dans l’IDE NetBeans 5.0
src
La fenêtre Files
donne
l’organisation Myproject
physique des
fichiers de
l’application
mypackage
MaClase
matieres
etudiants
UneClasse
La fenêtre EtudiantFB EtudiantFC MatierePr

Projects donne
l’organisation
Logique des Le répertoire src est la racine des
packages de hiérarchies de packages d’un projet
l’application
Les options –classpath et –sourcepath
automatiquement placées sur ce
HASSOUNI répertoire 8
Accès aux éléments d’un Package
Pour pouvoir utiliser, dans une classe d’un package donné, une classe issue
d’un autre package il faut préciser son origine au compilateur.
Comme le montre l’exemple ci-dessous , il existe 3 façons différentes pour

préciser l’origine d’une classe :
1 En important la classe
package MyProject.mypackage.matieres;
2 En important tout le package
import java.util.*; où est définie la classe
3 En indiquant le nom complet de la

import java.sql.Connection;
classe (Fully Qualified Name : FQN).
2 public class MatierePr{
String laboratoire;
1
String preparateur; import n’insère pas du code dans le
code de la classe (comme le fait
Connection c; #include du C). Il s’agit simplement
d’une indication pour le compilateur.
Date d1; En interne seuls les FQN sont utilisés.
3 java.sql.Date d2;
…..
HASSOUNI 9
4
Accès aux éléments d’un Package
L’instruction import nomPackage.* ne concerne que les classes du package

indiqué. Elle ne s’applique pas aux classes des sous packages.
import java.awt.image.*;
Classe Star utilise les classes Color
import java.awt.*; et Graphics du package java.awt
public class Star { et la classe Raster du package
double x, java.awt.image.
double y; Import java.awt.* n’importe pas les
Color c; classes du sous package
java.awt.image
public void draw(Graphics g) {
….
Pas besoin d’import
Raster r;
pour les classes du
….
package java.lang
}
Il est importé par défaut
…..
}
HASSOUNI 10
Lever une ambiguïté

• On aura une erreur à la compilation si
– 2 paquetages ont une classe qui a le même nom
– ces 2 paquetages sont importés en entier
• Exemple (2 classes List) :
import java.awt.*;
import java.util.*;
• Pour lever l’ambiguïté, on devra donner le nom complet

de la classe. Par exemple,
java.util.List l …
HASSOUNI 11
5
Import des membres statiques d’une classe
 Jusqu'à la version 1.4 de Java, pour utiliser un membre statique d'une classe, il faut
obligatoirement préfixer ce membre par le nom de la classe qui le contient.
public class version1_4 {
System.out.println(Math.PI);
System.out.println(Math.sqrt(20));
}
}
Java 1.5 propose une solution pour réduire le code à écrire concernant les
membres statiques en proposant une nouvelle fonctionnalité concernant
l'importation de package : l'import statique (static import).
 permet d'appliquer les mêmes règles aux membres statiques qu'aux

classes et interfaces pour l'importation classique
import static java.lang.Math.*;
public class version1_5{ importation statique
public static void main(String[] args) { s'applique à tous les
System.out.println(PI); membres statiques :
System.out.println(cos(0)); constantes et méthodes
} statiques de l'élément
HASSOUNI
} importé 12
Compiler les classes d’un paquetage
javac -d répertoire-package Classe.java
• L'option « -d » permet d’indiquer le répertoire racine où

sera rangé le fichier compilé
• Si on compile avec l'option « -d » un fichier qui

comporte l'instruction « package nom1.nom2», le
fichier .class est rangé dans le répertoire
répertoire-package/nom1/nom2
Exemple: javac –d classes MaClasse.java
HASSOUNI 13
6
Compiler les classes d’un paquetage
• Si on compile sans l'option « -d », le fichier .class est

rangé dans le même répertoire que le fichier .java
(quel que soit le paquetage auquel appartient la classe)
• Quand on compile les classes d’un paquetage avec l'option -d, on doit
le plus souvent indiquer où sont les classes déjà compilées du
paquetage avec l'option -classpath :
javac -classpath répertoire-package

-d répertoire-package Classe.java
Exemple :
javac –classpath classes –d classes Maclasse.java
HASSOUNI 14
Exécuter une classe d’un paquetage
• On lance l’exécution de la méthode main() d’une classe en donnant

son nom complet (préfixé par le nom de son paquetage)
• Par exemple, si la classe C appartient au paquetage p1.p2 :
java p1.p2.C
• Le fichier C.class devra se situer dans un sous-répertoire p1/p2
d’un des répertoires du classpath (option -classpath ou variable
CLASSPATH)
• Exemples:
Java –classpath classes c

HASSOUNI 15
7
Utilisation pratique des paquetages
• Les premières tentatives de développement avec paquetages

conduisent à de grosses difficultés pratiques pour compiler les classes
• Ces difficultés peuvent être évitées:
– en respectant quelques principes simples pour le placement des

fichiers sources et classes (Voir diapositives suivantes)
– en utilisant correctement les options –classpath et -d
HASSOUNI 16
Exemples de placement des fichiers .java et .class
MyJavaProgs
src classes doc
p1
p1
Test.java
Test.class
p2
p2
C1.java
C1.class
p3 p3
C2.java C2.class
C3.java C3.class
HASSOUNI 17
8
HASSOUNI 18
import p1.*;
import p1.p2.*;
import p1.p2.p3.*;
public class Test{
System.out.println("je suis la classe Test du src" );
new C1().affiche(); new C2().affiche(); new C3().affiche(); }}
HASSOUNI 19
9
package p1;
public class C1{
public void affiche(){
System.out.println("je suis la classe C1 du package p1");}}
HASSOUNI 20
package p1.p2;
public class C2{
System.out.println("je suis la classe C2 du package p1.p2");}}
HASSOUNI 21
10
package p1.p2.p3;
public class C3{
System.out.println("je suis la classe C3 du package p1.p2.p3"); }}
HASSOUNI 22
Compilation et exécution des classes du

package p1, p1.p2 et p1.p2.p3
• Si on se place dans le répertoire racine,
- pour compiler :
javac –d classes –classpath classes src/p1/p2/p3/C3.java
javac –d classes –classpath classes src/p1/p2/C2.java
javac –d classes –classpath classes src/p1/C1.java
javac –d classes –classpath classes src/Test.java
-pour exécuter :
java –classpath classes Test
-pour générer la documentation :

javadoc –d doc –sourcepath src
–subpackages p1 p1.p2 p1.p2.p3
• On peut ajouter
HASSOUNI d’autres répertoires ou fichiers .jar dans le classpath 23
11
Classes inter-dépendantes
• Si 2 classes sont inter-dépendantes, il faut les indiquer

toutes les deux dans la ligne de commande java de
compilation :
javac ... A.java B.java
ou
javac ... *.java
HASSOUNI 24
Option -sourcepath
• javac peut ne pas savoir où sont les fichiers source de

certaines classes dont il a besoin (en particulier si on
compile plusieurs paquetages en même temps)
• L’option –sourcepath indique des emplacements pour

des fichiers sources
• Comme avec classpath, cette option peut être suivie de

fichiers jar, zip ou des répertoires racines pour les fichiers
source (l’endroit exact où se trouvent les fichier .java
doit refléter le nom du paquetage)
HASSOUNI 25
12
Utilisation des fichiers source
• javac recherche les classes dont il a besoin dans le

classpath
• S’il ne trouve pas le fichier .class, mais s’il trouve le

fichier .java correspondant, il le compilera pour obtenir le
.class cherché
• S’il trouve les 2 (.class et .java), il recompilera la

classe si le .java est plus récent que le .class
HASSOUNI 26
Exemple avec sourcepath

• Situation : compiler une classe C, et toutes les classes dont cette
classe dépend (certaines dans des paquetages pas encore compilés)
• « javac C.java » ne retrouvera pas les fichiers class des

paquetages qui ne sont pas déjà compilés
• On doit indiquer où se trouvent les fichiers source de ces classes par

l’option –sourcepath ; par exemple, pour compiler Test.java
C1.java, C2.java et C3.java de notre exemple
javac –d classes –classpath classes

–sourcepath src src/Test.java
HASSOUNI 27
13
Problème avec sourcepath
• Si C.java a besoin d’un paquetage pas encore compilé
et dont les sources sont indiquées par l’option
sourcepath
• Si ce paquetage comporte une erreur qui empêche sa

compilation
• Alors javac envoie un message d’erreur indiquant que le

paquetage n’existe pas, sans afficher de message
d’erreur de compilation pour le paquetage
• L’utilisateur peut alors penser à tort que l’option

sourcepath ne marche pas
HASSOUNI 28
Recherche des classes

par la JVM
HASSOUNI 29
14
Chemin de recherche des classes
• Les outils java et javac recherchent toujours d’abord dans les

fichiers système qui sont placés dans le répertoire dit <java-
home>, le répertoire dont le nom commence par jre
• Ces fichiers système sont les suivants :

– fichiers rt.jar dans le répertoire jre/lib où java a été
installé,
– fichiers .jar ou .zip dans le sous-répertoire jre/lib/ext
• Ils regardent ensuite dans le classpath
HASSOUNI 30
Classpath
• Le classpath contient par défaut le seul répertoire courant (il est égal
à « . »)
• Si on donne une valeur au classpath, on doit indiquer le répertoire

courant si on veut qu’il y soit
• Dans le classpath on indique des endroits où trouver les classes et

interfaces :
– des répertoires (les classes sont recherchées sous ces
répertoires selon les noms des paquetages)
– des fichiers .jar ou .zip
HASSOUNI 31
15
Exemples de Classpath
• Sous Windows, le séparateur est « ; » :

.;c:\java\mespackages;c:\mesutil\cl.jar
• Sous Unix, le séparateur est « : »
HASSOUNI 32
16
Java
Réutilisation des classes:
• Délégation
• Héritage
Délégation et Héritage 1
Classes : Rappels
 Une classe représente une « famille » d’objets ayant en commun un
ensemble de propriétés et comportements.
 Une classe sert à définir les propriétés et comportements des objets d’un type donné.
 Elle décrit l ’ensemble des données (attributs,ou variables) et des
opérations sur données (méthodes)
 Elle Sert de « modèle » pour la création d’objets (instances de la classe)
int x; // abscisse du point
int y; // ordonnée du point
Variables
d’instance
public void translate(int dx, int dy){
x = x + dx;
y = y + dy;
}
Méthodes
// calcule la distance du point à l'origine
return Math.sqrt(x * x + y * y);
}
} 2
Réutilisation du code : Introduction
Comment utiliser une classe comme brique de base pour concevoir d’autres
classes ?
 Dans une conception objet on définit des « associations (relations) entre » pour
exprimer la réutilisation entre classe.
 UML (Unified Modelling Language) définit 5 types des associations

possibles entre classes.
Relation de classe moins forte Relation de classe plus forte
Dépendance Association Agrégation Composition Héritage
Dépendance : Un objet d'une classe travaille brièvement avec des objets

d'une autre classe
Association : Un objet d'une classe travaille avec des objets d'une autre
classe pendant une durée prolongée
Agrégation : Une classe détient et partage une référence à des objets

d'une autre classe
Composition : Une classe contient des objets d'une autre classe
Héritage : Une classe est un type d'une autre classe
Délégation
Mise en œuvre
Exemple : la classe Cercle
Agrégation / Composition
Délégation : Définition
L'association, l'agrégation, et la composition sont des fois appelées Délégation
 Un objet o1 instance de la classe C1 utilise les services d’un objet o2 instance

de la classe C2 (o1 délègue une partie de son activité à o2)
 La classe C1 utilise les services de la classe C2

 C1 est la classe cliente
 C2 est la classe serveuse
C1 C2
La classe cliente (C1) possède une référence de type de la classe serveuse(C2)
public class C1 { public class C2 {
private C2 champ; ...

... } 6
}
Délégation : Exemple
rayon
Exemple la classe Cercle
.centre  rayon : double
 centre : deux doubles (x et y) ou bien Point
public class Cercle {

Cercle Point
// centre du cercle
private Point centre;
L’association entre les // rayon du cercle

classes Cercle et private double r;
Point exprime le fait …
qu’un cercle possède public void translation(double dx, double dy) {
(a un) centre centre.translate(dx,dy);
}
…
}
7
public class Cercle { Point p1 = new Point(10,10);
//centre du cercle Cercle c1 = new Cercle(p1,10)
private Point centre; Cercle c2 = new Cercle(p1,20);
//rayon du cercle  Le point représentant le centre a une
private double r; existence autonome (cycles de vie
indépendants)
public Cercle( Point centre, double r) {  il peut être partagé (à un même moment
this.centre = centre; il peut être liée à plusieurs instances
this.r = r; d'autres classes) .
}
… p1 isa
} x 10
c1 y 10
Le point P1 peut être utilisé en c2
dehors du cercle dont il est le centre isa
(Attention aux effets de bord) isa
Centre
Centre
p1.rotation(90); r 10
c2.translater(10,10); r 20
Affecte le cercle c1 8
Après ces opérations le centre de c1 et c2 devient (0,20)
public class Cercle { Le Point représentant le centre n’est pas partagé
(à un même moment, une instance de Point ne
//centre du cercle
peut être liée qu'à un seul Cercle)
private Point centre;
Point p1 = new Point(10,10);
//rayon du cercle Cercle c1 = new Cercle(p1,10)
Cercle c2 = new Cercle(p1,20);
private double r;
p1
public Cercle(Point p, double r) { isa
this.centre = new Point(p); x 10
this.r = r; y 10
} isa isa
… x 10 x 10
} y 10 y 10
c2
 Les cycles de vies du Point et du c1
isa
Cercle sont liés : si le cercle est isa
détruit (ou copié), le centre l’est Centre
Centre
aussi. 20
10 r 9
r
Agrégation / Composition
 Les deux exemples précédents traduisent deux nuances (sémantiques) de

l’association a-un entre la classe Cercle et la classe Point
 UML distingue ces deux sémantiques en définissant deux type de relations :
Agrégation Composition
Voiture Cercle
Roue Point
Agrégation forte
L’élément agrégé (Roue) a une
existence autonome en dehors A un même moment, une instance de
de l’agrégat (Voiture) composant (Point) ne peut être liée qu'à un
seul agrégat (Cercle), et le composant a un
10
cycle de vie dépendant de l’agrégat.
Héritage
 Extension d’une classe
 Terminologie
 Généralisation/spécialisation
 Héritage en Java
 Redéfinition des méthodes
 Réutilisation
 Chaînage des constructeurs
 Visibilité des variables et des méthodes
 Classes et méthodes finales

11
Réutilisation du code avec modification
• Soit une classe A dont on a le code compilé
• Une classe C veut réutiliser la classe A
• Elle peut créer des instances de A et leur demander des services
• On dit que la classe C est une classe cliente de la classe A :

Ceci s’appelle la délégation comme on l’a vu
précédemment
• Souvent, cependant, on souhaite modifier en partie le

comportement de A avant de le réutiliser
• Le comportement de A convient, sauf pour des détails qu’on

aimerait changer
• Ou alors, on aimerait ajouter une nouvelle fonctionnalité à A 12
Réutilisation avec modifications du code source
• On peut copier, puis modifier le code source de A dans des classes A1,
A2,...
• Problèmes :
– on n'a pas toujours le code source de A
– les améliorations futures du code de A ne seront pas dans les classes

A1, A2,…
La solution en POO est l’HERITAGE

définir une nouvelle classe à partir de la classe déjà existante
13
Réutilisation par l'héritage
• L’héritage existe dans tous les langages objet à classes
• L’héritage permet d’écrire une classe B

– qui se comporte dans les grandes lignes comme la classe A
– mais avec quelques différences
sans toucher au code source de A
• On a seulement besoin du code compilé de A
• Le code source de B ne comporte que ce qui a changé par rapport au code de

A
• On peut par exemple
– ajouter de nouvelles méthodes
– modifier certaines méthodes
14
Héritage : classe mère

Exemple 1
import java.awt.Graphics;
import java.awt.Color;
public class Rectangle {
private int x, y; // point en haut à gauche
private int largeur, hauteur;
public int getX(){
return x;
}
public void setX(int x){
this.x = x;
}
// Idem pour getHauteur(), setHauteur(int),
// getLargeur(), setLargeur(int),
...
public void dessineToi(Graphics g) {
g.drawRect(x, y, largeur, hauteur);
}
} 15
Héritage : classe fille
Exemple 1
public class RectangleColore extends Rectangle { RectangleColore
private Color couleur; // nouvelle variable hérite de (étend)
// Constructeurs Rectangle. Elle
. . . possède les variables
et méthodes définies
// Nouvelles Méthodes
dans la classe
public getCouleur() { Rectangle
return this.couleur;
} Définition d’un nouvel
public setCouleur(Color c) { attribut
this.couleur = c;
} RectangleColore définit
2 nouvelles méthodes
// Méthodes modifiées
public void dessineToi(Graphics g) {
g.setColor(couleur);
RectangleColore
g.fillRect(getX(), getY(), redéfinit une méthode
getLargeur(), getHauteur()); de la classe mère.
}
} 16
Héritage : Exemple 2
Point.java : Classe mère PointGraphique.java : Classe fille

public class Point { import java.awt.Graphics;
protected int x; // abscisse du point import java.awt.Color;
protected int y; // ordonnée du point public class PointGraphique extends Point {
Color coul;
public void translate(int dx, int dy){
x = x + dx; // affiche le point matérialisé par
y = y + dy; // un rectangle de 3 pixels de coté
} public void dessine(Graphics g) {
g.setColor(coul);
// calcule la distance du point à l'origine g.fillRect(x - 1,y - 1,3,3);
public double distance() { }
return Math.sqrt(x * x + y * y); }
}
}
17
Héritage : Exemple 3
// ! c06:Detergent.java public class Detergent extends Cleanser {
// Syntaxe d'héritage & propriétés. // Change une méthode:
public void scrub() {
class Cleanser {
append(" Detergent.scrub()");
private String s = new String("Cleanser");
public void append(String a) { s += a; } super.scrub(); // Appel de la version de
public void dilute() { append(" dilute()"); } la classe de base
public void apply() { append(" apply()"); } }
public void scrub() { append(" scrub()"); } // Ajoute une méthode à l'interface:
public void print() { System.out.println(s); } public void foam() { append(" foam()"); }
public static void main(String[] args) { // Test de la nouvelle classe:
Cleanser x = new Cleanser(); public static void main(String[] args) {
x.dilute(); x.apply(); x.scrub();
Detergent x = new Detergent();
x.print();
} x.dilute();
} x.apply();
x.scrub();
x.foam();
x.print();
Exécution: System.out.println("Testing base
class:");
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class: Cleanser.main(args);
Cleanser dilute() apply() scrub() }
18
}
Terminologie
 La classe héritée A s'appelle une classe mère, classe parente, classe de

base ou super-classe
 La classe B qui hérite de la classe A s'appelle une classe fille ou sous-classe
 Point est la classe mère et PointGraphique la classe fille.
 la classe PointGraphique hérite de la classe Point
 la classe PointGraphique est une sous-classe de la classe Point
 la classe Point est la super-classe de la classe PointGraphique
19
Héritages : Autres exemples
• La classe mère Vehicule peut avoir les classes filles Velo, Voiture et Camion
• La classe Avion peut avoir les classes mères ObjetVolant et ObjetMotorise
• La classe Polygone peut hériter de la classe FigureGeometrique
• La classe Image peut avoir comme classe fille ImageGIF et ImageJpeg
• La classe Animal peut avoir comme classe fille Singe et Cheval.
20
Utilistaions des instances d’une classe héritée
Un objet instance de PointGraphique possède les attributs définis dans PointGraphique
ainsi que les attributs définis dans Point (un PointGraphique est aussi un Point )
Un objet instance de PointGraphique répond aux messages définis par les méthodes
décrites dans la classe PointGraphique et aussi à ceux définis par les méthodes de la
classe Point
PointGraphique p = new PointGraphique(); isa

p
// utilisation des variables d’instance héritées x 20
p.x = 20; y 10
p.y = 10;
// utilisation d’une variable d’instance spécifique coul
p.coul = new Color(200,200,0);
// utilisation d’une méthode héritée
double dist = p.distance(); isa
// utilisation d’une méthode spécifique r 200
p.dessine(graphicContext);
v 200
b 0
21
Héritage : Généralisation / Spécialisation
 la relation d'héritage peut être vue comme une relation de

“généralisation/spécialisation” entre une classe (la super-classe) et
plusieurs classes plus spécialisées (ses sous-classes).
 Particularisation ou Spécialisation:
– un rectangle coloré est un rectangle mais un rectangle particulier
– Un PointGraphique est un point mais un point particulier
 Généralisation:
– la notion de figure géométrique est une généralisation de la notion de
polygone
– Un animal est une généralisation du cheval et du singe
 Une classe fille offre de nouveaux services ou enrichit les services rendus
par une classe : la classe RectangleColore permet de dessiner avec des
couleurs et pas seulement en « noir et blanc »
22
La spécialisation exprime une relation “est-un” entre une classe et sa superclasse
(chaque instance de la classe est aussi décrite de façon plus générale
par la super-classe).
super-classe Animal
Singe est une
spécialisation d’Animal.
Spécialisation
Généralisation
Un singe est un cas

particulier d’animal
Singe sous-classe
La spécialisation exprime une relation de “particularisation” entre une classe

et sa sous-classe (chaque instance de la sous-classe est décrite de manière
plus spécifique) 23
Utilisation de l’héritage :
 dans le sens “spécialisation” pour réutiliser par modification
incrémentielle les descriptions existantes.
 dans le sens “généralisation” pour abstraire en factorisant les propriétés

communes aux sous-classes,
Animal Rectangle Point
Homme Singe Poisson Rectangle colore Point Graphique
24
Héritage : Différences entre les langages
• Chaque langage objet a ses particularités :
• Par exemple, C++ permet l’héritage multiple ; par contre Java et C# ne le

permettent pas
• Dans la suite du cours nous nous intéresserons à l’héritage dans le langage

Java
25
Héritage à plusieurs niveaux
 Il n’y a pas de limitation dans le nombre de niveaux dans la hiérarchie d'héritage
 Les méthodes et variables sont héritées au travers de tous les niveaux
Equipement
caractéristiques nom caractéristiques
communes à tous fabricant supplémentaires
les équipements poids pour les citernes
cout
Echangeur Citerne
Pompe
superficie volume
pression
diametre pression
debit
longueur
Piston …. PompeCentrifuge …. Citerne sphérique

nbrePales diamètre
taille
axe
26
Héritage à plusieurs niveaux : Exemple
public class A {
public void hello() {
System.out.println(«Vous etes en classe A »); Pour résoudre un
} message, la hiérarchie
} des classes est
parcourue de manière
ascendante jusqu’à
public class B extends A {
trouver la méthode
public void bye() {
correspondante.
System.out.println(«Vous etes en classe B»);
}
} C unC = new C();
unC.hello();
unC.bye();
public class C extends B { unC.bof();
public void bof() {
System.out.println(«Vous etes en classe C»);
}
}
27
Que peut on mettre dans une classe fille?
• Dans la classe qui hérite, on peut

– ajouter des variables, des méthodes et des constructeurs
– redéfinir (override) des méthodes, et fournir ainsi des implémentations
spécialisées pour celles-ci.
(Lorsqu’on redéfinit une méthode dans une classe fille, on doit donner le
même nom, , même type de retour, et mêmes types des paramètres).
– surcharger des méthodes (même nom mais pas même signature)
(la surcharge est aussi possible à l’intérieur d’une classe)
• Mais
– elle ne peut retirer aucune variable ou méthode
Lorsqu’une méthode redéfinie par une classe est invoquée pour un objet de
cette classe, c’est la nouvelle définition et non pas celle de la super-classe
qui est invoquée.
28
Héritage : redéfinition des méthodes
public class A {
public void hello() {
System.out.println(«Hello»);
}
public void affiche() { A unA = new A();
System.out.println(«vous etes en A»); B unB1 = new B();
}
} unA.hello();  Hello
unA.affiche(); vous etes en A
unB1.hello();  Hello
unB1.affiche(); vous etes en B
public void affiche() {
System.out.println («vous etes en B»);
A unB2 = new B(); ?
}
unB2.hello();  Hello ?
}
unB2.affiche();  vous etes en B ?
Voir polymorphisme 29
Surcharge ou redéfinition de méthodes
 Attention de confondre redéfinition (overriding) avec surcharge (overloading)
public class A {
public void methodX(int i) {
...
}
}
Surcharge Redéfinition
public class B extends A { public class C extends A {

public void methodX(Color i) { public void methodX(int i) {
... ...
} }
} }
B possède deux C possède une seule

méthodes methodX méthode methodX
(methodX(int) et methodX(Color)) (methodX(int)) 30
Redéfinition avec réutilisation : mot super

Redéfinition des méthodes (method overriding) :
 Il est possible de réutiliser le code de la méthode héritée ( en utilisant le
mot super)
public class Etudiant {
String nom;
String prénom;
int age;
...
System.out.println("Nom : " + nom + " Prénom : " + prénom);
System.out.println(" Age : " + age);
...
} public class EtudiantSportif extends Etudiant {
... String sportPratiqué;
} ...
super.affiche();
System.out.println("Sport pratiqué : "+sportPratiqué);
...
}
} 31
Limite pour désigner
une méthode redéfinie
• On ne peut remonter plus haut que la classe mère pour récupérer une méthode
redéfinie :
– pas de cast « (ClasseAncetre)affiche() »
– pas de « super.super.affiche() »
Remarque : Depuis le JDK 5 on peut accoler une annotation à une méthode qui
redéfinit une méthode d’une classe ancêtre : @Override
C’est très utile pour repérer des fautes de frappe dans le nom de la méthode :
le compilateur envoie un message d’erreur si la méthode ne redéfinit aucune
méthode d’une classe ancêtre. Il est donc fortement conseillé de le faire
32
Racine de la hiérarchie d’héritage : Classe Object
La hiérarchie d’héritage est un arbre dont la racine est la classe Object
(package java.lang)
 toute classe autre que Object possède une super-classe
 toute classe hérite directement ou indirectement de la classe Object
 par défaut une classe qui ne définit pas de clause extends hérite de la
classe Object
public class Point { public class Point extends Object {

int x; // abscisse du point int x; // abscisse du point
int y; // ordonnée du point
≡ int y; // ordonnée du point
... ...
} }
33
Classe Object
La classe Object n’a pas de variables d’instance ni de variables de classe.
• La classe Object fournit plusieurs méthodes qui sont héritées par toutes les
classes sans exception
• Les plus couramment utilisées sont les méthodes toString() et equals().
• public String toString()
Renvoie une chaîne représentant la valeur de l’objet
return getClass().getName() + "@" + Integer.toHexString(hashCode());
• public boolean equals(Object obj)

Teste l’égalité de l’objet avec l’objet passé en paramètre. (voir
polymorphisme)
return (this == obj);
Autres méthodes:
• public int hashCode()
Renvoie une clé de hashcode pour adressage dispersé (Voir collections)
• protected Object clone()
Crée un copie de l’objet
• public final Class getClass()
Renvoie la référence de l’objet Java représentant la classe de l’objet 34
Classe Object : méthode toString

<Expression de type String> + <reference>
≡ Opérateur de
<Expression de type String> + <reference>.toString() concaténation
du fait que la méthode toString est définie dans la classe Object , on est sûr que
quel que soit le type (la classe) de l’objet il saura répondre au message toString()
public class Object {
...
public String toString(){
}
…
}
private double x;
private double y;
}
35
méthode toString :Utilisation
...
public String toString(){
}
…
}

private double x,
public class Point { private double y;
private double x; public String toString(){
private double y; return ("Point:[" + x + "," + y + "]");
} }
}
Cette classe Point ne
redéfinit pas toString Cette classe Point redéfinit toString
Point@2b580c Point p = new Point(20,30);

Point:[20,30] 36
System.out.println(p);
Exemple de toString, equals et hashCode

public class Fraction {
private int num, den;
...
@Override
public String toString() {
return num + "/" + den;
}
@Override a/b = c/d
public boolean equals(Object o) {
if (! (o instanceof Fraction))
si et seulement si
return false; a.d = b.c
return num * ((Fraction)o).den
== den * ((Fraction)o).num;
}
private static int pgcd(int i1, int i2) {
if(i2 == 0) return i1;
else return pgcd(i2, i1 % i2);
37
}
Exemple de toString, equals et hashCode
public Fraction reduire() {

int d = pgcd(num, den);
return new Fraction(num/d, den/d);
}
// Calcul du hashcode : Réduit la fraction, puis calcule un int

public int hashCode() {
Fraction f = reduire();
return (17 + f.num * 37) * 37 + f.den;
}
}
38
classe Class
• Class est une classe particulière (voir cours sur la reflection)
• Les instances de la classe java.lang.Class représentent les classes

utilisées par Java (et aussi les types primitifs)
• public Class getClass()
renvoie la classe de l’objet
• La méthode getName() de la classe Class renvoie le nom complet de la
classe (avec le nom du paquetage)
• Instanceof
 Si x est une instance d'une sous-classe B de A,
« x instanceof A » renvoie true
 Pour tester si un objet o est de la même classe que l'objet courant, il ne faut
donc pas utiliser instanceof mais le code suivant :
if (o != null && o.getClass() == this.getClass())
39
Constructeurs
Réutilisation des constructeurs
 Nous avons vu que lors de la redéfinition d’une méthode, il est possible de

réutiliser le code de la méthode héritée à l’aide du mot super.
 De la même manière il est important de pouvoir réutiliser le code des

constructeurs de la classe mère dans la définition des constructeurs d'une classe
fille.
 L’invocation d'un constructeur de la super classe se fait par l’instruction :

super(paramètres du constructeur)
 Attention: cette instruction doit être la première dans le constructeur d’une

classe fille.
 L’utilisation de super(…) est analogue à celle de this.
40

Exemple 1

private double x,y; Appel du constructeur de la super-classe.
public Point(double x, double y){ Si cet appel est présent, il doit toujours
this.x = x; this.y = y; être la première instruction du corps du
} constructeur.
...
}
public class PointCouleur extends Point {
Color c;
public PointCouleur(double x, double y, Color c){
super(x,y);
this.c = c;
}
...
}
41
Exemple 2
public class Rectangle { public class RectangleColore extends
private int x, y, largeur, hauteur; Rectangle {
private Color couleur;
public Rectangle(int x, int y, public RectangleColore(int x, int y,
int largeur, int hauteur) { int largeur, int hauteur
this.x = x; Color couleur) {
this.y = y; super(x, y, largeur, hauteur);
this.largeur = largeur; this.couleur = couleur;
this.longueur = longueur; }
} public RectangleColore(int x, int y,
... int largeur, int hauteur) {
} this(x, y, largeur, hauteur, Color.black);
}
Appel du constructeur de la super ...
classe : doit être la 1ere instruction }
Appel d’un autre constructeur de la même classe : doit être la 1ere instruction
42
Appel implicite du constructeur

de la classe mère
 L’appel à un constructeur de la super classe doit toujours être la première

instruction dans le corps du constructeur
 Si la première instruction d'un constructeur n'est pas un appel explicite à l’un des
constructeur de la super classe, alors JAVA insère implicitement l'appel super()
 Chaque fois qu'un objet est créé les constructeurs sont invoqués en remontant en
séquence de classe en classe dans la hiérarchie jusqu'à la classe Object
 C’est le corps du constructeur de la classe Object qui est toujours exécuté en

premier, suivi du corps des constructeurs des différentes classes en redescendant
dans la hiérarchie.
43
Appel implicite du constructeur
de la classe mère
Il est garanti qu'un constructeur d'une classe est toujours appelé lorsqu'une
instance de l'une de ses sous classes est créée.
un objet c instance d’une classe C sous classe de B elle même sous classe de
A est un objet de classe C mais est aussi un objet de classe B et de classe A.
Lorsqu’il est créé c doit l’être avec les caractéristiques d ’un objet de A, de B et
de C.
Remarque : C’est le constructeur de la classe Object

qui crée l’objet en mémoire
(il est le seul à savoir le faire).
44
Chaînage des constructeurs

public Object(){ 3
Ordre
appels
...
}
...
}

d’ e x é c u t i o n
des
double x,y;
public Point(double x, double y){ 2
// Appel implicite du super()
this.x = x; this.y = y;
}
Ordre
...
}
public class PointCouleur extends Point {

Color c; 1
public PointCouleur(double x, double y, Color c) {
super(x,y);
this.c = c; PointCouleur unPC =
}
... new PointCouleur(…..)
}
45
Constructeur par défaut
 Lorsqu'une classe ne définit pas explicitement de constructeur, elle possède un
constructeur par défaut. Ce constructeur a les caractéristiques suivantes:
 Il n’a pas de paramètres
 Son corps est vide, il contient par défaut l’appel au constructeur super();
 Il est masqué dans le cas où un autre constructeur est défini.
public Object() {
...
}
...
} Constructeur par
défaut implicite
public class A {
// attributs
String nom;
public A() {
super();
// méthodes }
String getNom() {
return nom; Il garantit chaînage
} des constructeurs
...
46
}
Constructeur par défaut
public class ClasseA {

double x;
// constructeur Constructeur explicite
public ClasseA(double x){ masque constructeur par défaut
this.x = x;
} Pas de constructeur
} sans paramètres
public class ClasseB extends ClasseA {

double y = 0; public ClasseB(){
super();
// pas de constructeur }
}
Constructeur
par défaut implicite
javac ClasseB.java
ClasseB.java:3: No constructor matching ClasseA() found in class ClasseA.
public ClasseB() {
^
1 error 47
Redéfinition des attributs
 Lorsqu'une sous classe définit une variable d'instance dont le nom est
identique à l'une des variables dont elle hérite, la nouvelle définition
masque la définition héritée
 l'accès à la variable héritée se fait en utilisant super. Mais il n’est pas
recommandé de masquer les variables.
public class A {
Dans le code de la classe C:
int x;
}
((A)this).x
double x; super.super.x
}
super.x
public class C extends B {
char x;
x ou this.x
}
48
Redéfinition des attributs: Exemple

class A{ public class C extends B{
protected int x =5; char x = 'c';
public void affiche(){ public void affiche(){
System.out.println("x de A = " +x); //((A)this).affiche(); Attention ne marche pas
} super.affiche();
} System.out.println("x de C = " +x);
}
class B extends A{ public void affiche2(){
protected double x = 5.5; System.out.println("x de A " + ((A)this).x);
public void affiche(){ System.out.println("x de B " + super.x);
super.affiche(); System.out.println("x de C " + x);
System.out.println("x de B = " +x); }
} C unC = new C();
} unC.affiche();
x de A = 5 System.out.println("======================");
x de B = 5.5 unC.affiche2();
x de C = c }
=============== }
x de A = 5
x de B = 5.5
49
x de C = c
Visibilité des variables et méthodes
principe d'encapsulation : les données propres à un objet ne sont
accessibles qu'au travers des méthodes de cet objet
sécurité des données : elles ne sont accessibles qu'au travers de

méthodes en lesquelles on peut avoir confiance
masquer l'implémentation : l'implémentation d'une classe peut être

modifiée sans remettre en cause le code utilisant celle-ci
en JAVA possibilité de contrôler l'accessibilité (visibilité) des membres

(variables et méthodes) d'une classe
public : accessible à toute autre classe

private : n'est accessible qu'à l'intérieur de la classe où il est défini
protected: est accessible dans la classe où il est défini, dans toutes ses
sous-classes et dans toutes les classes du même package
package : (visibilité par défaut) n'est accessible que dans les classes du
même package que celui de la classe où il est défini
50
private -(package) protected public
La classe elle même Oui Oui Oui Oui
Classes du même
Non Oui Oui Oui
package
Sous-classes d'un
Non Non Oui Oui
autre package
Classes (non sous-classes)

Non Non Non Oui
d'un autre package
51
Package monPackage Définit le package auquel Package tonPackage
appartient la classe.
package monPAckage; Si pas d’instruction package
public class Classe2 { package par défaut : package tonPackage;
{ classes définies dans public class Classe4 {
le même répertoire }
Classe1 o1; Classe1 o1;
o1.c package monPackage;

public class Classe1 { o1.d
o1.b o1.d private int a;
int b;
protected int c
public int d; package tonPackage;
package monPackage; public class Classe5
public class Classe3 a c extends Classe1 {
extends Classe1 {
b d c
c
d
b d
52
Les mêmes règles de visibilité s’appliquent aux méthodes
Visibilité des classes

Deux niveaux de visibilité pour les classes :
public : la classe peut être utilisée par n’importe quelle autre classe
- (package) : la classe ne peut être utilisée que par les classes appartenant au
même package
Package A Package B
package A;
public class ClasseA {
ClasseB b; package B;
public class ClasseC {
ClasseC c;
ClasseA a;
}
package A; ClasseB b;
class ClasseB
extends ClasseA { }
53
Méthodes finales
●Méthodes finales
♦ public final void méthodeX(….) {
…. }
♦ «verrouiller » la méthode pour interdire toute éventuelle redéfinition
dans les sous-classes
♦ efficacité
quand le compilateur rencontre un appel à une méthode finale il peut
remplacer l’appel habituel de méthode (empiler les arguments sur la
pile, saut vers le code de la méthode, retour au code appelant,
dépilement des arguments, récupération de la valeur de retour) par
une copie du code du corps de la méthode (inline call).
♦si le corps de la méthode est trop gros, le compilateur est censé ne pas
faire cette optimisation qui serait contrebalancée par l ’augmentation
importante de la taille du code.
♦Mieux vaut ne pas trop se reposer sur le compilateur :
– utiliser final que lorsque le code n ’est pas trop gros ou lorsque l ’on
veut explicitement éviter toute redéfinition
♦méthodes private sont implicitement final (elles ne peuvent être

redéfinies)
54
Classes finales
● Une classe peut être définie comme finale

public final class UneClasse {
…
}
♦ Interdit tout héritage pour cette classe qui ne pourra être sous-classée
♦ toutes les méthodes à l’intérieur de la classe seront implicitiment finales
(elles ne peuvent être redéfinies)
♦ exemple : la classe String est finale
● Attention à l’usage de final, prendre garde de ne pas privilégier une

supposée efficacité au détriment des éventuelles possibilités de réutiliser la
classe par héritage.
55
Exercice : Implémenter le diagramme des classes ci-dessous:
56
Java
Héritage
Et
Polymorphisme
Héritage et Polymorphisme 1
Upcasting ou Surclassement
♦ La réutilisation du code est un aspect important de l'héritage, mais ce n'est peut être
pas le plus important
♦ Le deuxième point fondamental est la relation qui relie une classe à sa superclasse:
Une classe B qui hérite de la classe A peut être vue comme un

sous-type (sous ensemble) du type défini par la classe A.
Etudiant Un EtudiantSportif est un Etudiant
Un etudiant peut être un étudiant

sportif
L’ensemble des étudiants sportifs est

inclus dans l’ensemble des étudiants
EtudiantSportif
HASSOUNI Larbi 2
♦ tout objet instance de la sous-classe B peut être aussi vu comme une instance de
sa super-classe A.
♦ Cette relation est directement supportée par le langage JAVA :
● à une référence déclarée de type A il est possible d'affecter une valeur qui
est une référence vers un objet de type B (upcasting)
Etudiant
Etudiant e;
e = new EtudiantSportif(...);
EtudiantSportif
plus généralement à une référence d'un type donné, il est

possible d'affecter une valeur qui correspond à une référence vers
un objet dont le type effectif est n'importe quelle sous-classe
directe ou indirecte du type de la référence
HASSOUNI Larbi 3
♦ Lorsqu'un objet est "sur-classé" il est vu comme un objet du type de la
référence utilisée pour le désigner :
● Ses fonctionnalités sont alors restreintes à celles proposées par la
classe du type de la référence
Etudiant
EtudiantSportif es; String nom;
es = new EtudiantSportif(« Toto", »Ali",25,..,« Foot",..); String prénom;
int age;
Etudiant e; es …
e = es; // upcasting public Etudiant(String n, String p,int a ...)
● isa public void affiche()
● public int nbInscriptions()
...
e.affiche(); e Toto
es.affiche();
●
Ali EtudiantSportif
e.nbInscriptions(); String sportPratiqué;
es.nbInscriptions(); 25 …
…… public EtudiantSportif (String n, String p,

es.bonusSportif(); int a, …, String s, ...)
Foot public void affiche()
e.bonusSportif(); public double bonusSportif()
...
HASSOUNI Larbi …… 4
Lien dynamique
Résolution des messages
● Que va donner e.affiche() ? Etudiant
Etudiant e = new EtudiantSportif( System.out.println(
"Toto", "Ali",25,.., "Foot",..); "Nom : "+nom+"\n"
"Prénom : "+prénom+"\n"
"Age : "+age+ ...);
}
?
e e.affiche(); EtudiantSportif
isa ●
●
? public void affiche(){
Toto
super.affiche();
Ali System.out.println(
"Sport" : "+sport+"\n"
25 + ...);
…… }
Foot
……
HASSOUNI Larbi 5
Lien dynamique : Résolution des messages
Lorsqu'une méthode d'un objet est accédée
au travers d'une référence "surclassée",
c'est la méthode telle qu'elle est définie
au niveau de la classe effective de Etudiant
l'objet qui est invoquée et exécutée public void affiche(){
System.out.println(
"Nom : "+nom+"\n"
Etudiant e = new EtudiantSportif( "Prénom : "+prénom+"\n"
"Toto", "Ali",25,.., "Age : "+age+ ...);
"Foot",..); }
e e.affiche();
isa ● EtudiantSportif
●
Toto Nom : Toto public void affiche(){
Ali Prénom : Ali super.affiche();
System.out.println(
25 Age : 25
"Sport" : "+sport+"\n"
… + ...);
……
Sport : Foot }
Foot
……
HASSOUNI Larbi 6
Lien dynamique
Mécanisme de résolution des messages
● Les messages sont résolus à l’exécution
♦ la méthode exécutée est déterminée à l'exécution (run-time) et non pas à la
compilation
♦ à cet instant le type exact de l'objet qui reçoit le message est connu
▲ la méthode définie pour le type réel de l’objet recevant le message est
appelée (et non pas celle définie pour son type déclaré).
public class A {
public void m() { A obj = new C();
System.out.println("m de A"); obj obj.m();
}}
●
m de B
public void m() {
System.out.println("m de B");
ce mécanisme est
}} isa ● désigné sous le terme de
lien-dynamique
(dynamic binding,
public class C extends B { latebinding
} ou run-time binding)
HASSOUNI Larbi 7
Lien dynamique
Vérification statique
● A la compilation :seules des vérifications statiques qui se basent sur le type
déclaré de l’objet (de la référence) sont effectuées
♦ la classe déclarée de l’objet recevant le message doit posséder une

méthode dont la signature correspond à la méthode appelée.
public class A {
public void m1() {
A obj = new B();
System.out.println("m1 de A"); obj.m1();
} obj obj.m2(); //N’est pas définie
} //dans A
●
public class B extends A { Test.java:21: cannot resolve symbol

public void m1() { symbol : method m2 ()
System.out.println("m1 de B");
}
location: class A
public void m2() { obj.m2();
System.out.println("m2 de B"); ^
}} 1 error
HASSOUNI Larbi 8
Lien dynamique
Vérifications statiques
● A la compilation il n’est pas possible de déterminer le type exact de l'objet récepteur
d'un message
public class A {
public void m1() { A obj;
System.out.println("m1 de A"); for (int i = 0; i < 10; i++){
} obj
hasard = Math.random()
}
● if ( hasard < 0.5)
obj = new A();
public class B extends A { else
public void m1() {
System.out.println("m1 de B"); obj = new B();
} obj.m1();
public void m2() { }
System.out.println("m2 de B");
}}
● vérification statique : garantit dès la compilation que les messages pourront être
HASSOUNI Larbi résolus au moment de l’exécution 9
Lien dynamique
Choix des méthodes, sélection du code
● La signature de la méthode à exécuter est
effectué statiquement à la compilation en
fonction du type des paramètres
public class A {
public void m1() {
System.out.println("m1 de A");} A refA = new A();
public void m1(int x) { invokevirtual … <Method m1()> refaA.m1();
System.out.println("m1(x) de A");} refA.m1(10);
}
invokevirtual … <Method m1(int)>
invokevirtual … <Method m1()> refA = new B();
refA.m1();
public class B extends A { Byte-code refA.m1(10);
public void m1() { compilation refA.m2();
System.out.println("m1 de B");}
public void m2() { La sélection du code de la méthode à exécuter est
System.out.println("m2 de B");}
} effectué dynamiquement à l’exécution en fonction
du type effectif de l'objet récepteur du message
HASSOUNI Larbi 10
Polymorphisme
A quoi servent l’upcasting et le lien dynamique ?
A la mise en oeuvre du polymorphisme
● Le terme polymorphisme décrit la caractéristique d'un élément qui peut prendre
plusieurs formes, comme l'eau qui se trouve à l'état solide, liquide ou gazeux.
● En programmation Objet, on appelle polymorphisme

♦ le fait qu’un objet d’une classe puisse être manipulé comme s’il
appartenait à une autre classe.
♦ le fait que la même opération puisse se comporter différemment sur
différentes classes de la hiérarchie.
● "Le polymorphisme constitue la troisième caractéristique

essentielle d'un langage orienté objet après l'abstraction des
données (encapsulation) et l'héritage"
Bruce Eckel "Thinking in JAVA"
HASSOUNI Larbi 11
Polymorphisme
ClasseA
méthodeX()
ClasseB ClasseC
méthodeX()
ClasseD ClasseE ClasseF

méthodeX()
Surclassement
la référence peut désigner des un cas particulier
ClasseA objA; objets de classe différente d'utilsation de
objA = ... (n’importe quelle sous Polymorphisme
objA.methodeX(); classe de ClasseA) est
+ manipulation uniforme des
Lien dynamique objets de plusieurs classes
Le comportement est différent par l'intermédiaire d'une
selon la classe effective de classe de base commune
l’objet
HASSOUNI Larbi 12
Polymorphisme
Etudiant EtudiantSportif
super.affiche();
public void affiche(){ System.out.println("Sport" : "+sport+"\n"
System.out.println("Nom : "+nom+"\n" + ...);
"Prénom : "+prénom+"\n" }
"Age : "+age+ ...);
}
Si un nouveau type d’étudiant est défini,
le code de GroupeTD reste inchangé EtudiantEtranger
public class GroupeTD{ super.affiche();
Etudiant[] liste = new Etudiant[30]; System.out.println("Nationalité" : "+pays+"\n"
+ ...);
int nbEtudiants = 0; }
...
public void ajouter(Etudiant e){
if (nbEtudiants < liste.lenght) GroupeTD td1 = new GroupeTD();
liste[nbEtudiants++] = e; td1.ajouter(new Etudiant(« MOHA", …));
} td1.ajouter(new EtudiantSportif(« TOTO",
public void afficherListe(){
« ALI", … , « FOOT");
for (int i=0;i<nbEtudiants; i++)
liste[i].affiche(); Td1.ajouter(new EtudiantEtranger("FOFO",
} "NAJIB", …, "Algérie")
} td1.afficherListe();
HASSOUNI Larbi 13
Polymorphisme
● En utilisant le polymorphisme en association à la liaison dynamique

♦ plus besoin de distinguer différents cas en fonction de la classe des objets
♦ possible de définir de nouvelles fonctionnalités en définissant de nouveaux types
de données à partir d'une classe de base commune sans avoir besoin de
modifier le code qui manipule l'interface de la classe de base
● Développement plus rapide

● Plus grande simplicité et meilleure organisation du code
● Programmes plus facilement extensibles
● Maintenance du code plus aisée
HASSOUNI Larbi 14
Surcharge et Polymorphisme
public class ClasseC {
public static void methodeX(ClasseA a){
Surcharge
ClasseA
System.out.println("param typeA");
}
ClasseB public static void methodeX(ClasseB b){
System.out.println("param typeB");
}
ClasseA refA = new ClasseA(); }
ClasseC.methodeX(refA); param TypeA
ClasseB refB = new ClasseB();
ClasseC.methodeX(refB); param TypeB
refA = refB; // upCasting
ClasseC.methodX(refA); param TypeA
invokestatic … <Method void methodX(ClasseA )>

Le choix de la méthode à exécuter est
effectué à la compilation en fonction des Byte-code
types déclarés : Sélection statique
HASSOUNI Larbi 15
Redéfinition de equals
● Tester l’égalité de deux objets de la même classe
De manière générale, il vaut mieux
...
éviter de surcharger des méthodes
public boolean equals(Object o)
en spécialisant les arguments
return this == o
}
... public boolean equals(Point pt) {
} return this.x == pt.x && this.y == pt.y;
}
private double x;
private double y; surcharge (overloads) la méthode
... equals(Object o) héritée de Object
}
Point p1 = new Point(15,11);
invokevirtual … <Method equals(Object)> Point p2 = new Point(15,11);
p1.equals(p2); true
Le choix de la méthode à exécuter est effectué Object o = p2;
statiquement à la compilation p1.equals(o); false
en fonction du type déclaré de l’objet récepteur
o.equals(p1); false
du message et du type déclaré du (des)
HASSOUNI Larbi paramètre(s) 16
Redéfinition de equals
● Tester l’égalité de deux objets de la même classe
...
public boolean equals(Object o) public boolean equals(Object o) {
if (! (O instanceof Point))
return this == o
return false;
} Point pt = (Point) o; // Downcasting
... return (thix.x == pt.x && this.y == pt.y)
}
public class Point { redéfinit (overrides) la méthode

private double x; equals(Object o) héritée de Object
private double y;
... Point p1 = new Point(15,11);
} Point p2 = new Point(15,11);
p1.equals(p2); true
Object o = p2;
p1.equals(o); true
o.equals(p1); true
HASSOUNI Larbi 17
Downcasting
ClasseX obj = …
ClasseA a = (ClasseA) obj;
● Le downcasting (ou transtypage) permet de « forcer un type » à la compilation

● C’est une « promesse » que l’on fait au moment de la compilation.
● Pour que le transtypage soit valide, il faut qu’à l’exécution le type effectif de obj
soit « compatible » avec le type ClasseA
● Compatible : la même classe ou n’importe quelle sous classe de ClasseA

(obj instanceof ClasseA)
● Si la promesse n’est pas tenue une erreur d’exécution se produit.

● ClassCastException est levée et arrêt de l’exécution
java.lang.ClassCastException: ClasseX
at Test.main(Test.java:52)
HASSOUNI Larbi 18
HERITAGE ET ABSTRACTION
Classes abstraites
HASSOUNI Larbi 19
Classes abstraites : Exemple introductif
● Formes géométriques
▲ on veut définir une application permettant de manipuler des formes
géométriques (triangles, rectangles, cercles…).
▲ chaque forme est définie par sa position dans le plan
▲ chaque forme peut être déplacée (modification de sa position), peut
calculer son périmètre, sa surface
largeur v2
hauteur
●
x,y v1
x,y ●
x,y ●
Attributs : Attributs :
Attributs : double x,y; //1 des sommets
double x,y; //centre du cercle double x,y; //coin inférieur gauche
double r; // rayon double x1,y1; // v1
double largeur, hauteur; double x2,y2; // v2
Méthodes : Méthodes :
deplacer(double dx, double dy) Méthodes :
deplacer(double dx, double dy) deplacer(double dx, double dy)
double surface() double surface()
double périmètre() double surface()
double périmètre(); double périmètre();
HASSOUNI Larbi Comment factoriser le code ? 20

v2
largeur
hauteur
●
x,y
x,y ● v1
x,y ●
class Forme {
protected double x,y; Forme
public void deplacer(double dx, double dy) {
x += dx; y += dy;}}
double x,y;
deplacer(double dx, double dy)
class Cercle extends Forme {

protected double r;
public double surface(){
return Math.PI * r * r;} Cercle Rectangle Triangle
protected double périmetre(){ double r; //rayon double largeur, hauteur double x1,y1; // v1
return 2 * Math.PI * r;} double surface(); double surface(); double x2,y2; // v2
} double perimetre(); double perimetre(); double surface();
double perimetre();
HASSOUNI Larbi 21
public class ListeDeFormes { On veut pouvoir
public static final int NB_MAX = 30; gérer des listes
private Forme[] tabForme = new Forme[NB_MAX]; de formes
private int nbFormes = 0;
public void ajouter(Forme f){ On exploite le polymorphisme
if (nbFormes < NB_MAX) la prise en compte de nouveaux
tabForme[nbFormes++] =f; types de forme ne modifie pas le
} code
public void toutDeplacer(double dx,double dy){
for (int i=0; i < NbFormes; i++) Appel non valide car la méthode
tabFrome[i].deplace(dx,dy); périmètre n ’est pas implémentée
} au niveau de la classe Forme
public double périmetreTotal(){ Définir une méthode périmètre
double pt = 0.0; dans Forme ? Comment?
for (int i=0; i < NbFormes++; i++)
pt += tabForme[i].périmetre(); public double périmetre(){
return pt; return 0.0; // ou -1. ??
} }
}
HASSOUNI Larbi Une solution propre et élégante : les classes abstraites 22
Classes abstraites
● Utilité :
♦ définir des concepts incomplets qui devront être implémentés dans les sous classes
♦ factoriser le code
public abstract class Forme{

protected double x,y;
Classe abstraite public void deplacer(double dx, double dy) {
x += dx; y += dy;
}
public abstract double périmètre() ;

méthodes abstraites
public abstract double surface();
}
HASSOUNI Larbi 23
Classes abstraites
● classe abstraite : classe non instanciable,

c'est à dire qu'elle n'admet pas d'instances directes.
♦ Impossible de faire new ClasseAbstraite(…);
● méthode abstraite : méthode n'admettant pas d'implémentation

♦ au niveau de la classe dans laquelle elle est déclarée, on ne peut pas dire
comment la réaliser.
● Une classe pour laquelle au moins une méthode abstraite est déclarée est une classe
abstraite (l'inverse n'est pas vrai).
● Les méthodes abstraites sont particulièrement utiles pour mettre en oeuvre le

polymorphisme.
♦ l'utilisation du nom d'une classe abstraite comme type pour une (des)
référence(s) est toujours possible (et souvent souhaitable !!!)
HASSOUNI Larbi 24
Classes abstraites
● Une classe abstraite est une description d'objets destinée à être héritée par des
classes plus spécialisées.
● Pour être utile, une classe abstraite doit admettre des classes descendantes concrètes.
● Toute classe concrète; sous-classe d'une classe abstraite doit “concrétiser” toutes les
opérations abstraites de cette dernière.
● Une classe abstraite permet de regrouper certaines caractéristiques communes à ses

sous-classes et définit un comportement minimal commun.
● La factorisation optimale des propriétés communes à plusieurs classes par

généralisation nécessite le plus souvent l'utilisation de classes abstraites.
HASSOUNI Larbi 25
Classes abstraites
public abstract class Magnitude {
public abstract boolean egalA(Magnitude m) ;

public abstract boolean inferieurA(Magnitude m) ;
public boolean superieurA(Magnitude m) {

return !egalA(m) && !inferieurA(m);
}
...
} Magnitude
égalA(obj : Magnitude) : boolean Méthodes
inférieurA(obj : Magnitude) : boolean abstraites
méthodes concrètes supérieurA(obj : Magnitude) : boolean
(basées sur les 2 ...
opérations abstraites)
chaque sous-classe Date Caractère … Nombre

concrète admet une
implémentation différente
pour égalA() et Entier … Réel
inférieurA()
HASSOUNI Larbi 26
HERITAGE ET ABSTRACTION
Interfaces
HASSOUNI Larbi 27
Interfaces : Exemple introductif
abstract class Animal { Bill Venners Designing with Interfaces
... One Programmer's Struggle to Understand
the Interfaces
abstract void talk(); http://www.atrima.com/designtechniques
} /index.html
class Dog extends Animal { class Bird extends Animal { class Cat extends Animal {
... ... ...
void talk() { void talk() { void talk() {
System.out.println("Woof!"); System.out.println("Tweet"); System.out.println("Meow");
} } }
} } }
Polymorphisme signifie qu’une référence d’un En JAVA le polymorphisme est rendu possible
type (classe) donné peut désigner un objet de par la liaison dynamique (dynamic binding)
n’importe quelle sous classe et selon la nature de
class Interrogator {
cet objet produire un comportement différent static void makeItTalk(Animal subject) {
Animal animal1 = new Dog(); subject.talk();
... }
Animal animal2 = new Cat(); }
animal peut être un Chien, un Chat ou JVM décide à l’exécution (runtime) quelle méthode
n’importe quelle sous classe d ’Animal invoquer en se basant sur la classe de l’objet
HASSOUNI Larbi 28

Comment utiliser Interrogator pour faire parler aussi un CuckooClock ?
abstract class Animal {

... Faire rentrer CuckooClock
abstract void talk(); dans la hiérarchie Animal ?
}
class Clock {
... Pas d’héritage
class Dog extends Animal { } multiple
... class Bird extends Animal {
void talk() { ...
System.out.println("Woof!"); class Cat extends Animal {
void talk() { class CuckooClock {
} ...
System.out.println("Tweet"); public void talk() {
} void talk() {
} System.out.println("Cuckoo,cuckoo!");
System.out.println("Meow");
} }
}
}
}
class Interrogator { class CuckooClockInterrogator {

static void makeItTalk(Animal subject) { static void makeItTalk(Cuckooclock subject) {
subject.talk(); subject.talk();
} }
} }
HASSOUNI Larbi Se passer du polymorphisme ? 29
abstract class Animal {

... Faire rentrer CuckooClock
abstract void talk(); dans la hiérarchie Animal ?
}
class Clock {
... Pas d’héritage
class Dog extends Animal { } multiple
... class Bird extends Animal {
void talk() { ...
void talk() { class CuckooClock {
} ...
} void talk() {
} }
}
}
}
class Interrogator { class CuckooClockInterrogator {

static void makeItTalk(Animal subject) { static void makeItTalk(Cuckooclock subject) {
subject.talk(); subject.talk();
} }
} }
HASSOUNI Larbi Se passer du polymorphisme ? 30

abstract class Animal implements Talkative {

...
abstract void talk();
} Association
de ce type à class Clock {
différentes ...
classes de la
class Dog extends Animal { hiérarchie
}
... class Bird extends Animal { d’héritage
void talk() { ...
void talk() { class CuckooClock implements Talkative {
} ...
} void talk() {
} }
}
}
}
class Interrogator {
static void makeItTalk(Talkative subject) { interface Talkative {
subject.talk(); public void talk(); Définition d’un type
} } abstrait (interface)
}
Utilisation de ce type abstrait
Les interfaces permettent plus de polymorphisme car avec les interfaces il n’est pas
HASSOUNI Larbi 31
nécessaire de tout faire rentrer dans une seule famille (hiérarchie) de classes
Interfaces
● Java's interface gives you more polymorphism than you

can get with singly inherited families of classes, without
the "burden" of multiple inheritance implementation.
Bill Venners Designing with Interfaces - One Programmer's Struggle to

Understand the Interface
http://www.atrima.com/designtechniques/index.html
HASSOUNI Larbi 32
Interfaces : Déclaration d’une interface

● Une interface est une collection de méthodes utilisée pour spécifier un service offert par
une classe.
● Une interface peut être vue comme une classe abstraite sans attributs et dont toutes les
méthodes sont abstraites.
import java.awt.*; •Toutes les méthodes sont abstraites

public interface Dessinable { •Elles sont implicitement publiques
public void dessiner(Graphics g);
void effacer(Graphics g); • Possibilité de définir des attributs à
} condition qu’il s’agisse d ’attributs de
type primitif
• Ces attributs sont implicitement
Dessinable.java déclarés comme static final
<<interface>> interface
Dessinable
méthodes abstraites
dessiner(g : Graphics)
effacer(g: Graphics)
HASSOUNI Larbi 33
Interfaces : Implémentation d’une interface
● Une interface est destinée à être “réalisée” (implémentée) par d’autres classes (celles-ci
en héritent toutes les descriptions et concrétisent les opérations abstraites).
● Les classes réalisantes s'engagent à fournir le service spécifié par l'interface

Forme
● L’implémentation d’une interface est libre double x,y;
<<interface>> deplacer(double dx, double dy)
Dessinable
Clock dessiner(Graphics g)
………. effacer(Graphics g)
Rectangle
double largeur, hauteur
double surface();
implémentation double perimetre();
CuckooClockDessinable TexteDessinable
…….. String txt;
dessiner(Graphics g) int x,y; RectangleDessinable
effacer(Graphics g) Font f; ... Color c
…….. dessiner(Graphics g); dessiner(Graphics g);
effacer(Graphics g); effacer(Graphics g);
HASSOUNI Larbi Méthodes concrétisées 34

● De la même manière qu'une classe étend sa super-classe elle peut de manière
optionnelle implémenter une ou plusieurs interfaces
● dans la définition de la classe, après la clause extends nomSuperClasse, faire apparaître
explicitement le mot clé implements suivi du nom de l'interface implémentée
class RectangleDessinable extends Rectangle implements Dessinable {
public void dessiner(Graphics g){

g.drawRect((int) x, (int) y, (int) largeur, (int) hauteur);
}
public void effacer(Graphics g){

g.clearRect((int) x, (int) y, (int)largeur, (int) hauteur);
}
}
si la classe est une classe concrète elle doit fournir une implémentation (un corps) à
chacune des méthodes abstraites définies dans l'interface (qui doivent être déclarées
publiques)
HASSOUNI Larbi 35
● Une classe JAVA peut implémenter simultanément plusieurs interfaces
● Pour cela la liste des noms des interfaces à implémenter séparés par des virgules
doit suivre le mot clé implements
class RectangleDessinable extends Rectangle implements Dessinable,Comparable {
public void dessiner(Graphics g){

g.drawRect((int) x, (int) y, (int) largeur, (int) hauteur);
}
public void effacer(Graphics g){
g.clearRect((int) x, (int) y, (int)largeur, (int) hauteur);
}
public int compareTo(Object o) {

if (o instanceof Rectangle)
...
}
}
Méthodes de l’interface Comparable Méthodes de l’interface Dessinable

HASSOUNI Larbi 36
Interfaces et polymorphisme
● Une interface peut être utilisée comme un type
♦ A des variables (références) dont le type est une interface il est possible d'affecter
des instances de toute classe implémentant l'interface, ou toute sous-classe d'une
telle classe.
Dessinable d;
public class Fenetre { ..
private nbFigures; d = new RectangleDessinable(…);
private Dessinable[] figures; ...
... d.dessiner(g);
public void ajouter(Dessinable d){ d.surface();
...
}
public void supprimer(Dessinable o){
... permet de s’intéresser uniquement à
} certaines caractéristiques d’un objet
public void dessiner() {
for (int i = 0; i < nbFigures; i++) règles du polymorphisme s’appliquent de
figures[i].dessiner(g); la même manière que pour les classes :
}
• vérification statique du code
}
• liaison dynamique
HASSOUNI Larbi 37
Heritage d’interfaces
● De la même manière qu'une classe peut avoir des sous-classes, une interface peut
avoir des "sous-interfaces"
● Une sous interface
♦ hérite de toutes les méthodes abstraites et des constantes de sa "superinterface"
♦ peut définir de nouvelles constantes et méthodes abstraites
<< interface >>
Collection
interface Set extends Collection{
...
<< interface >> << interface >> }
List Set
<< interface >>

SortedSet
● Une classe qui implémente une interface doit implémenter toutes les méthodes
abstraites définies dans l'interface et dans les interfaces dont elle hérite.
HASSOUNI Larbi 38
Heritage d’interfaces
● A la différence des classes une interface peut étendre plus d'une interface à la fois
<< interface >>
Chanel
boolean isOpen()
représente une connexion ouverte void close()
vers une entité telle qu’un dipositif
hardware, un fichier, une “socket”
réseau, ou tout composant logiciel
capable de réaliser une ou plusieurs
opérations d’entrée/sortie. << interface >> << interface >>
ReadableByteChanel WritableByteChanel
int read(ByteBuffer dst) int write(ByteBuffer src)
<< interface >>

ByteChanel
package java.nio;
interface ByteChannel extends ReadableByteChanel, WriteableByteChanel {
}
HASSOUNI Larbi 39
Interfaces : Intérêts
● Les interfaces permettent de s ’affranchir d ’éventuelles contraintes d’héritage.
♦ Lorsqu’on examine une classe implémentant une ou plusieurs interfaces, on est sûr que
le code d’implémentation est dans le corps de la classe. Excellente localisation du code
(défaut de l’héritage multiple, sauf si on hérite de classes purement abstraites).
● Permet une grande évolutivité du modèle objet
HASSOUNI Larbi 40
LES CLASSES ENVELOPPES

(WRAPPERS)
HASSOUNI Larbi 41
LES CLASSES ENVELOPPES (WRAPPERS)
Les variables instances d’une classe (objets) et les variables de types primitifs
ne se comportent pas de la même manière:
•L’affectation porte sur l’adresse d’un objet, sur la valeur d’une variable de
type primitif
•Les règles de compatibilité de l’affectation se fondent sur une hiérarchie

d’héritage pour les objets, sur une hiérarchie de type pour les variables.
•Le polymorphisme ne s’applique qu’aux objets
•Les collections ne sont définies que pour des éléments qui sont des
objets.(collections = LinkedList, ArrayList, HashSet, TreeSet, …etc)
Les classes enveloppes permettent de manipuler les types primitifs comme

des objets.
HASSOUNI Larbi 42
Les classes WRAPPERS sont :
Boolean : encapsule le type primitif boolean

Character : encapsule le type char
Byte : encapsule byte
Short : encapsule short
Integer : encapsule int
Long : encapsule long
Float : encapsule float
Double : encapsule double
HASSOUNI Larbi 43
Construction et accès aux valeurs
Toutes les classes enveloppes disposent d’un constructeur qui reçoit un argument d’un
type primitif:
Character charObj = new Character(‘c’);

Integer intObj = new Integer(12) ;
Double doubleObj = new Double(12.5);
Elles disposent toutes d’une méthode de la forme <typeprimitif>Value qui permet de

retrouver la valeur du type primitif correspondant:
char a = charObj.charValue();
int n = intObj.intValue();
double x = doubleObj.doubleValue();
Ces instructions sont simplifiées dans le JDK5.0 à l’aide du principe « boxing/unboxing ».
Ces classes WRAPPERS sont finales (ne peuvent pas être dérivées), et inaltérables (Les
valeurs qu’elles encapsulent ne sont pas modifiables
HASSOUNI Larbi 44

Comparaison avec la méthode equals
L’opérateur = = appliqué à des objets, comparent leur référence.
Exemple : Integer intObj1 = new Integer(10);

Integer intObj2 = new Integer(10);
L’expression intObj1 == intObj2 retourne la valeur false (à moins que le compilateur ne

crée qu’un seul objet de type Integer contenant la valeur 10, et référencé par les deux
objets intObj1 et intObj2).
En revanche, la méthode equals a bien été redéfinie dans les classes WRAPPERS, de
manière à comparer effectivement les valeurs correspondantes.
intObj1.equals(intObj2) retournera à la valeur true.
HASSOUNI Larbi 45
Boxing / Unboxing dans JDK5.0
Le JDK 5.0 a introduit les techniques de boxing (emballage) et d’unboxing (déballage) qui
effectuent des conversions, et mises en place automatiquement par le compilateur, entre
les classes WRAPPERS et les types primitifs.
Exemple:
Integer intObj = 10 // 10 est converti en new Integer(10);
Double doubleObj = 10.5 //10.5 est converti en new Double(10.5);
int n = intObj //intObj est converti en intObj.intValue();

double x = doubleObj //doubleObj est converti en doubleObj.doubleValue();
Ces convertions sont effectués également lors des opérations arithmétiques:
intObj2 = intObj1 + 5 //intObj2 = new Integer(intObj1.intValue() + 5);
intObj1++ // intobj = new Integer(intObj1.intValue() + 1);
Attention : Ces conversions ne sont possibles qu’entre un type enveloppe et son type
primitif correspondant. Les instructions suivantes sont incorrects:
Double doubleObj = 10; // 10, de type int, ne peut pas etre converti en Double.
Integer intObj; Double doubleObj = intObj //erreur de compilation
HASSOUNI Larbi 46
CLASSES ANONYMES
JAVA permet de définir ponctuellement une classe, sans lui donner de nom. Cette
technique est très utilisée pour la gestion des événements dans les interfaces graphiques.
Une classe anonyme est soit une classe qui dérive d’une autre classe, soit elle
implémente une interface.
Format d’une classe anonyme qui dérive d’une autre classe:

Class A{ // définition des champs et méthodes de A }
A a = new A(){
// Définition des champs et méthodes de la classe anonyme dérivant de A
};
Format d’une classe anonyme qui implémente une interface:

Interface I{ // définition des constantes et déclaration des méthodes de I }
I a = new I(){
// Définition des méthodes de la classe anonyme implémentant
l’interface I
};
HASSOUNI Larbi 47
CLASSE ANONYME
Dérivée d’une autre classe
Exemple :
Class A{
System.out.println(« Je suis un objet de la classe A »);
}
}
Public class Anonyme1{
A a1 = new A();
A a2 = new A(){
System.out.println(« Je suis un objet de la classe anonyme dérivée de
A »);
};
a1.affiche();
a2.affiche();
}
HASSOUNI Larbi 48
CLASSE ANONYME
Implémentant une interface
Exemple :
Interface I{
public void affiche();
}
Public class Anonyme2{
I a = new I(){
System.out.println(« Je suis un objet de la classe anonyme qui implémente
l’interface I »);
};
a.affiche();
}
HASSOUNI Larbi 49
Les chaînes de caractères
Classe String
Les chaînes des caractères sont des séquences de caractères.

Elles sont largement utilisées dans les programmation en Java.
En Java une chaîne de caractère est un objet.
Java fournit la classe String pour créer et manipuler les chaînes de
caractères
Création des chaînes de caractères
La façon la plus directe de créer une chaîne est d’écrire : String s =

“Bonjour”.
“Bonjour ” est une constante chaîne de caractère (litteral string).
Chaque fois que le compilateur rencontre une litteral string, il crée un objet
instance de la classe String dont la valeur est la constante en question
(“Bonjour ” dans ce cas).
HASSOUNI Larbi 50
La classe String possède 11 constructeurs qui vous

permettent de construire des objets String avec une valeur
initiale provenant de plusieurs sources.
Ainsi, il est possible de créer un objet String à partir d’un

tableau de caractères.
Exemple:
char[] bonjourTab = { ‘b', ‘o', ‘n', ‘j', 'o', ‘u’, ‘r’, '.'};
String bonjourString = new String(bonjourTab);
System.out.println(bonjourString); //affichera : bonjour
HASSOUNI Larbi 51
Note:
La classe String est immuable, par conséquent,
une fois un objet String est créé, il ne peut pas être
modifié. La classe String possède un ensemble de
méthodes qui opèrent sur les objets comme s’ils les
modifiaient, mais en réalité, puisque la classe String
est immuable, ces méthodes créent et retournent de
nouveaux objets qui contiennent les résultat de
l’opération.
HASSOUNI Larbi 52
Longueur d’une chaîne
La classe String fournit une méthode d’instance length() qui
permet d’obtenir la longueur d’une chaîne (Attention, ne pas
confondre avec le champ public length d’un tableau).
Exemple: String palindrome = "Dot saw I was Tod";
int len = palindrome.length(); // fournit 17
HASSOUNI Larbi 53
Concatenation des chaînes
La classe String inclut une méthode d’instance qui permet de
concaténer deux chaînes: ch1.concat(ch2); retourne un
nouveau objet String formé par les carctères de ch1 ausquels
on a ajouté à la fin les caractères de ch2.
Attention, ch1 n’est pas modifié.
Il est aussi possible d’utiliser concat avec des constantes
chaines comme
“Bonjour ".concat(“tout le monde");
HASSOUNI Larbi 54
Les chaines sont souvent concaténées en utilisant l’opérateur

+, qui est souvent utilisé dans les instructions print.
Exemple : « bonjour » + « tout le monde »; produit l’objet
chaine « bonjour tout le monde ».
Il est possible de concaténer n’importe quel objet à une
chaine. Lorsque l’objet n’est pas une chaine, sa méthode
toString() est appelé pour le convertir en une chaine.
Note:
Java n’autorise pas de diviser une constante string en
plusieurs lignes dans un programme source. Par
conséquent, il faut avoir recours à l’opérateur + à la fin de
chaque ligne dans le cas d’une constante chaîne multilignes.
Exemple :
String quote = "Now is the time for all good " +
"men to come to the aid of their country.";
HASSOUNI Larbi 55
Création d’une chaine de format
La classe String possède une méthode statique format() qui permet de créer une
chaine de format qui peut être réutilisée.
Par exemple, au lieu de :
System.out.printf(" La valeur de la variable float est %f, losque celle de la " + "
variable entier est %d, et celle de type string est %s", floatVar, intVar, stringVar);
Vous pouvez écrire:
String fs;
fs = System.out.printf(" La valeur de la variable float est %f, celle de la " + "

variable entier est %d, et celle de la variable string est %s", floatVar, intVar,
stringVar);
System.out.println(fs);
HASSOUNI Larbi 56
Conversions entre nombre et chaines de caractères

Conversion des chaines en nombres
Chaque classe WRAPPER ( Byte, Integer, Double, Float, Long, et Short) fournit
une méthode nommée valueOf qui convertit une chaîne en un objet instance de la
dite classe.
public class ValueOfDemo {
if (args.length == 2) {
float a = (Float.valueOf(args[0]) ).floatValue();
float b = (Float.valueOf(args[1]) ).floatValue();
System.out.println("a + b = " + (a + b) );
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a * b) );
System.out.println("a / b = " + (a / b) );
System.out.println("a % b = " + (a % b) ); }
else {
System.out.println("This program requires two command-line arguments."); } }
}
HASSOUNI Larbi 57
Note:
Chaque classe WRAPPER fournit également une méthode statique dont le nom
est parseXXXX() (parseInt, parseFloat, …etc) qui convertit une chaîne en un
nombre de type primitif.
Puisque cette méthode retourne un type primitif, elle est plus directe que la
méthode. Ainsi dans le programme précédent, au lieu d’écrire :
float a = (Float.valueOf(args[0]) ).floatValue();

float b = (Float.valueOf(args[1]) ).floatValue();
Nous pouvons écrire directement
float a = Float.parseFloat(args[0]);
float b = Float.parseFloat(args[1]);
HASSOUNI Larbi 58
Conversion des nombres en chaine de caractères
Java fournit plusieurs méthodes pour convertir un nombre en une chaine de

caractères.
Méthode 1: utiliser l’opérateur + pour concatener un nombre à une chaine vide
int i;
String s1 = "" + i; //la conversion est faite automatiquement.
Méthode 2 : Utiliser la méthode statique valueOf de la classe String.
String s2 = String.valueOf(i);
Méthode 3 : Utiliser la méthode toString() de la classe WRAPPER correspondante.
Par example:
int i;
double d;
String s3 = Integer.toString(i);
String s4 = Double.toString(d);
HASSOUNI Larbi 59
Manipulation des caractères dans une chaîne
La classe String fournit un ensemble de méthodes pour examiner le contenu des

chaines de caractères, comme rechercher un caractère, ou une sous-chaine,
changer la casse des lettres, …etc.
Obtention d’un caractère à partir d’une chaine
La méthode charAt() permet d’obtenir un caractère situé à un indice donné à

l’intérieur d’une chaine. L’indice du 1 er caractère de la chaine est 0, et celui du
dernier est length()-1.
Par exemple le code suivant :
String anotherPalindrome = "Niagara. O roar again!";

char aChar = anotherPalindrome.charAt(9);
Retourne le caractère 'O', qui se trouve à l’indice 9 (position 10) comme le montre
la figure ci-dessous.
HASSOUNI Larbi 60
Obtention d’une sous-chaine à partir d’une chaine

La méthode substring permet d’extraire une sous chaine à partir d’une chaine de
caractères. Cette méthode a deux versions:
String substring(int debut, int fin) : retourne la sous chaine située entre l’indice debut et
l’indice fin-1.
String substring(int debut) : retourne la sous chaine située entre l’indice debut et la fin
de la chaine.
String ch = "Niagara. O roar again!";

String sousch1 = ch.substring(11, 15); //Extrait la sous chaine “roar”
String sousch2 = ch.substring(16); //Extrait la sous chaine “again!”
HASSOUNI Larbi 61
Les
Exceptions
Préparé par : Larbi Hassouni
Exceptions 1
Introduction aux exceptions
• Toutes les applications peuvent rencontrer des
erreurs lorsqu'elles s'exécutent. Par exemple:
– Un utilisateur peut fournir une donné
inappropriée (Une chaine au lieu d'un nombre);
– Un fichier dont a besoin l'application peut être
déplacé ou supprimé.
HASSOUNI Larbi 2
• Ce type d'erreurs peut causer à une

application "pauvrement" codée de se planter
et de perdre les données de l'utilisateur
• En revanche, lorsqu'une erreur survient dans
une application bien codée, l'application
avertit l'utilisateur et essaie de se récupérer
après l'erreur.
– Si elle ne peut pas se récupérer, elle sauvegarde le
plus possible de données, nettoie les ressources,
et arrête son exécution le plus proprement
possible.
HASSOUNI Larbi 3
Exceptions 1
• Les anciens langages n'offraient pas de
moyens pour contrôler les erreurs.
• Pire encore, ils ne permettaient pas de
communiquer ces erreurs aux autres parties
de l'application qui peuvent avoir besoin
d'avoir des informations dessus.
• Pour résoudre ce problème, la plupart des
langages modernes, y compris java,
fournissent un mécanisme de gestion des
erreurs, connu sous le nom d'exceptions.
HASSOUNI Larbi 4
• Les exceptions vous permette d'écrire du code

robuste capable de gérer les erreurs de
manière facile et fiable.
• Avant de présenter comment gérer les
erreurs, nous allons présenter :
– La hiérarchie des exceptions
– Le mécanisme de gestion des exceptions
HASSOUNI Larbi 5
Exceptions 2
Hiérarchie des exceptions
• En Java, une exception est un objet instance
de la classe Exception ou de l'une de ses sous-
classes.
• Une exception représente une erreur qui s'est
produit lors de l'exécution d'une application,
et contient des informations sur cette erreur.
• Comme le montre la figure de la diapositive
suivante. Toutes les exceptions dérivent de la
classe Throwable.
HASSOUNI Larbi 6
Arbre d’héritage des exceptions

Object
Throwable
Error Exception
RunTimeException
Unchecked Errors
Unchecked Exceptions Checked Exceptions
Exceptions 3
• Comme le montre le schéma, deux classes héritent
directement de la classe Throwable:
– Error
– Exception
• Les classes qui héritent de la classe Error représentent
des erreurs internes contre lesquelles, vous ne pouvez
rien faire, comme les erreurs de l'environnement
d'exécution (JVM).
• Par conséquent, vous pouvez ignorer ce type d'erreurs
dans la plupart du temps.
• En revanche, vous avez besoin de gérer les exceptions
qui héritent de la classe Exception.
HASSOUNI Larbi 8
• Les classes qui dérivent de la classe Exception se

divisent en deux catégorie:
– Les exceptions qui dérivent de la classe
RunTimeException
– Les autres sous classes qui ne dérivent pas de
RunTimeException.
• Les exceptions qui dérivent de RunTimeException
sont appelées des exceptions non contrôlées
puisque le compilateur ne vous forcent pas de les
gérer
• Par contre, le compilateur exige qu'on gère de
façons explicites les exceptions qui ne dérivent
pas de RunTimeException. Elles sont alors
appelées Exceptions contrôlées.
HASSOUNI Larbi 9
Exceptions 4
• Les exceptions non contrôlées survient
souvent à cause d'une erreur de codage.
• Par exemple, si une application essaie
d'accéder à un tableau avec un indice
incorrect (par exemple, supérieur à la
longueur du tableau) Java lance un objet
exception instance de
ArrayIndexOutOfBoundsException qui est sous
classe de IndexOutOfBoundsException.
• Si vous êtes attentif lorsque vous écrivez votre
code, vous pouvez généralement éviter ce
type d'exception d'être lancé.
HASSOUNI Larbi 10
• Les exceptions contrôlées, surviennent dans

des circonstances qui sont en dehors du
contrôle du programmeur.
– Comme par exemple un fichier manquant, ou une
mauvaise connexion réseau.
• Bien que vous ne pouvez pas éviter ces
exceptions, vous pouvez écrire le code qui les
traite lorsqu'ils se produisent.
HASSOUNI Larbi 11
Exceptions 5
Sous classes de la classe RunTimeException
Dans le package java.lang
Exception
RunTimeException
ArithmeticException ArrayStoreException IllegalArgumentException
NegativeArraySizeException
ClassCastException
NullPointerException
NumberFormatException
IndexOutOfBoundsException
IllegalThreadStateException
12
Nom de la classe Condition de lancement de

l’exception
ArithmeticException Opération arithmétique invalide
telle que la division d’un entier
par zéro.
IndexOutOfBoundsException Utilisation d’un indice qui est en

dehors des bornes autorisés .
L’indice peut être d’un tableau,
d’une String ou d’un objet Vector.
Cette classe possède deux sous
classes :
ArrayIndexOutOfBoundsException
, et StringOutOfBoundsException.
13
Exceptions 6
l’exception
Essai de créer un tableau avec

NegativeArraySizeException
une dimension négative
Essai d’utilisation d’un objet

dont la valeur est null, pour
NullPointerException
accéder à un attribut ou
appeler une méthode
Essai de stocker un objet dans

ArrayStoreException un tableau dont le type des
éléments ne l’autorise pas
14

l’exception
ClassCastException Essai d’effectuer un cast d’un objet
vers un type invalide. L’objet n’est
pas du type de la classe, d’une sous
classe, ou de la superclasse de la
classe vers laquelle on veut effectuer
le cast.
IllegalArgumentException Essai de passer un argument à une
méthode qui n’est pas du type du
paramètre correspondant.
C’est une classe de base des sous
classes IllegalThreadStateException,
et NumberFormatException.
15
Exceptions 7
l’exception
llegalThreadStateException est lancée lors d’une opération qui est
illégale dans l’état actuel du thread.
NumberFormatException est lancée avec les méthodes
valueOf(), et decode() qui se trouvent
dans les classes qui représentent les
entiers (Byte, Short, Integer, et Long).
Les méthodes parseXXX() présentes
dans ces classes peuvent égament
lancer NumberFormatException.
L’exception est lancée si l’objet String
passé en argument contient un
caractère invalide qui empêche la
conversion vers un entier.
16
Quelques exceptions du JDK,

contrôlées par le compilateur
Exception
ClassNotFoundException InterruptedException
SQLException IOException
EOFException FileNotFoundException
17
Exceptions 8
Exceptions : Exemple 1
class ExempleSansExcep1{
int n ;
if(args.length > 0){
n = Integer.parseInt(args[0]);
System.out.println("C'est trés bien vous avez fourni un entier : " +n);
}
}
}
java ExempleSansExcep1 5
C'est tres bien vous avez fourni un entier : 5
java ExempleSansExcep1 a
Exception in thread "main" java.lang.NumberFormatException: For input string: "a"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at ExempleSansExcep1.main(ExempleSansExcep1.java:5)
18
public class Div {
public static int divint (int x, int y) {

return (x/y);
}
static void main (String [] args) {
int c=0,a=1,b=0;
c= divint(a,b);
System.out.println("res: " + c);
System.exit(0);
}
}
Le système affiche l'erreur suivante:
Exception in thread "main" java.lang.ArithmeticException: / by zero

at Div.divint(Div.java:3)
at Div.main(Div.java:7)
Une erreur s'est produite à la ligne 3 de la méthode divint appelée par la

méthode main à la ligne 7.
19
Exceptions 9
class Point{
private int x, y;
public int getX(){ return x; }
public void setX(int x){ this.x = x; }
}
public class ExempleExcep2{
Point p1 = null;
p1.setX(5);
System.out.println("l'abscisse du point est : " + p1.getX());
}
}
java ExempleSansExcep2
Exception in thread "main" java.lang.NullPointerException

at ExempleSansExcep2.main(ExempleSansExcep2.java:9)
20
class ExempleExcep1{
int n = -1;
try{
if(args.length > 0){
System.out.println("C'est trés bien vous avez fourni un entier : " +n);
}
}
catch (NumberFormatException e){
System.out.println("Vous n'avez pas fourni un entier :");
System.out.println(e.getMessage());
}
finally{
System.out.println("Je suis toujours exécutée!!!");
}
}
}
21
Exceptions 10
class Point{
private int x, y;
public void setX(int x){ this.x = x; }
}
Point p1 = null;
try{
p1.setX(5);
}
catch (NullPointerException e){
System.out.println("Vous avez oublie de creer l'objet p1");
}
finally{
System.out.println("Je suis toujours exécutée!!!");
}
}}
22
class Point{
private int x, y;
public void setX(int x){ this.x = x; }}

Point p1 = null; int n;
try{
System.out.println("Vous avez bien saisi un entier : " + n);
p1.setX(5);
}
catch (NumberFormatException e){
System.out.println("Vous n'avez pas fourni un entier :");
}
catch (NullPointerException e){
System.out.println("Vous avez oublie de creer l'objet p1");
23
} }}
Exceptions 11
class EntNat{
class ErrConst extends Exception{ private int n;
} public EntNat (int n) throws ErrConst {
if (n<0) throw new ErrConst();
java TestEntNat1 this.n = n;
n1 = 20 }
**Erreur construction entier naturel** public int getN(){ return n; }
}
public class TestEntNat{
try{
EntNat n1 = new EntNat(20);
System.out.println("n1 = " + n1.getN());
EntNat n2 = new EntNat(-20);
}
catch(ErrConst e){
System.out.println("**Erreur construction entier naturel);
System.exit(-1);
}
}} 24
class EntNat{
class ErrConst extends Exception{ private int n;
private int valeur; public EntNat (int n) throws ErrConst {
public ErrConst(int valeur){ if (n<0) throw new ErrConst(n);
this.valeur = valeur;} this.n = n;
public int getValeur(){ return valeur; } }
} public int getN(){ return n; }
}
public class TestEntNat{
try{
EntNat n1 = new EntNat(20);
EntNat n2 = new EntNat(-20);
}
catch(ErrConst e){
System.out.println("**Err: construction entier naturel avec:"+e.getValeur());
System.exit(-1);
}
}} 25
Exceptions 12
Exceptions contrôlées
Pour toutes les autres classes (différentes de RunTimeException) qui dérivent de la
classe Exception, le compilateur vérifie que l’exception est soit traitée par la méthode
où elle a été lancée, soit que vous avez indiqué que cette méthode peut lancer une
telle exception. Si vous ne faites ni l’une ni l ’autre, votre code ne se compilera pas.
Gestion des exceptions

Si votre code peut lancer une exception qui n’est pas de type Error, ou de type
RunTimeException ( ou une sous classe de Error ou RunTimeException) vous devez
vous en occuper en suivant l’une des deux méthodes suivantes:
1. Spécifier que votre méthode peut lancer l’exception pour qu’elle soit traitée par la
méthode appelante
2. Ecrire le code dans la méthode où est lancée l’exception pour la traiter.
26
Spécification des exceptions

qu’une méthode peut lancer
Pour déclarer qu’une méthode peut lancer des exceptions, il suffit de mettre, juste
après la liste de ses paramètres, le mot clé throws suivi de la liste des classes
exceptions séparées par des virgules.
Exemple:
double myMethode() throws EOFException, FileNotFoundException{
//corps de la méthode
}
Attention:
La méthode qui appelle une méthode qui lance des exceptions doit à son tour les
lancer ou contenir du code qui les traite. Dans le cas contraire, le compilateur
génère une erreur, et le code n’est pas compilé.
27
Exceptions 13
Traitement des exceptions
Pour traiter une exception, il existe trois types de blocs de code que vous pouvez inclure dans la méthode qui va se
charger du traitement:
• try
• catch
• finally
Le bloc try délimite le code qui est sensé lancer une ou plusieurs exceptions.
Le bloc catch délimite le code qui est destiné à traiter les exceptions d’un type particulier qui pourraient être lancée par le
code du bloc try.
Le bloc finally délimite un code qui sera toujours exécuté qu’il y ait ou non lancement d’exceptions par le code du bloc try,
et traitement ou non d’une éventuelle exception par un bloc catch.
28
Bloc try
Lorsque vous voulez attraper une exception, vous devez placer le code
susceptible de lancer une telle exception dans un bloc try.
Un bloc try consiste simplement en le mot clé try suivi de deux accolades qui
englobent le code susceptible de lancer l’exception.
try {
// code qui peut lancer une ou plusieurs exceptions
}
Il n’est pas obligatoire de mettre un code qui peut causer des exceptions dans
un bloc try. Seulement, la méthode qui contient un tel code ne peut pas
attraper ces exceptions si elles sont lancées, et il faut alors que la méthode
déclare avec throws qu’elle peut lancer les types d’exceptions qui ne peuvent
pas être attrapées.
Même si on est en train de discuter des exceptions que nous devons traiter, un
bloc try est aussi nécessaire si vous voulez attraper des exceptions de type
Error ou RunTimeException.
29
Exceptions 14
Bloc catch
Un bloc catch englobe le code qui traite un type donné d’exception.
Le bloc catch doit suivre immédiatement le bloc try qui contient le code qui peut
avoir causé ce type d’exception.
Un bloc catch consiste en le mot clé catch, suivi d’un paramètre entre parenthèses
qui identifie le type d’exception que le bloc doit traiter, suivi du code, qui traite
l’exception, placé entre des accolades.
Catch (ClasseException e){

// Code qui traite l’exception de type ClasseException
}
En général le paramètre du bloc catch doit être de type throwable ou d’une des
sous classes de throwable.
Le bloc catch traitera les exceptions de type de la classe du paramètre, et de toutes
les sous classes de cette classe.
Par exemple, si vous spécifiez un paramètre de type RunTimeException, le code
du bloc catch sera invoqué pour traiter les exceptions de type RunTimeException,
et celles de ses sous classes.
30
Exemple :
Try {
// Code qui peut lancer une ou plusieurs exceptions
}
Catch (ArithmeticException e) {
// Code qui traite l’exception de type ArithmeticException et pas les autres
}
Ce bloc catch traite uniquement les exceptions de type ArithmeticException. Ceci

implique que ce sont les seuls exceptions qui peuvent être lancés dans le bloc try.
Si d’autres exceptions peuvent être lancés, le code ne s'exécutera pas.
Nous verrons ultérieurement comment traiter plusieurs exceptions qui sont lancées
par un même bloc try.
31
Exceptions 15
public class TestTryCatch {
int i = 1;
int j = 0;
try {
System.out.println("Try block entered " + "i = "+ i + " j = "+j);
System.out.println(i/j); // Divide by 0 - exception thrown
System.out.println("Ending try block");
} catch(ArithmeticException e) { // Catch the exception

System.out.println("Arithmetic exception caught");
}
System.out.println("After try block");

return;
}
}
Exécution Try block entered i = 1 j = 0

Arithmetic exception caught
After try block 32
L’exécution montre que le bloc try n'a pas été entièrement exécuté, puisque
l'instruction println(i/j) lance une exception, le bloc try s'arrête et l'exécution
continue au bloc catch associé.
Remarque:
En ce qui concerne le scope des variables, les blocs try et catch ont le même
comportement qu’un bloc standard.
Par conséquent, une variable déclarée dans un bloc try ou catch n’est visible que
dans ce bloc, elle n’est pas visible à l’extérieur.
Liaison des blocs try/catch

Les blocs try et catch vont ensemble. Vous ne devez pas les séparer par des
instructions ou par quoi que ce soit. Si vous avez une boucle qui est aussi un
bloc try, le bloc catch qui suit doit être aussi une partie de la boucle.
33
Exceptions 16
Que fait ce programme ?
public class TestLoopTryCatch {
int i = 12;
for(int j=3 ;j>=-1 ; j--) {

try {
System.out.println("Try block entered " + "i = "+ i + " j = "+j);

}
}
System.out.println("After try block");
return;
}
}
34
Exécution :
Try block entered i = 12 j = 3

4
Ending try block
6
Ending try block
12
Ending try block
Arithmetic exception caught
Try block entered i = 12 j = -1
-12
Ending try block
After try block
35
Exceptions 17
public class TestLoopTryCatch2 {
int i = 12;
try {
System.out.println("Try block entered.");
for(int j=3 ;j>=-1 ; j--) {
System.out.println("Loop entered " + "i = "+ i + " j = "+j);
}

}
}
} 36
Bloc try avec de multiple blocs catch

Si un bloc try peut lancer plusieurs types différents d’exception,
vous pouvez placer plusieurs blocs catch pour les traiter.
try {
// Code qui peut lancer plusieurs types d’exceptions
}
catch (ArithmeticException e){

// Code qui traite les exceptions de type ArithmeticException
}
catch (IndexoutOfBoundsException e){

// Code qui traite les exceptions de type IndexoutOfBoundsException
}
// L’exécution continue ici ….
37
Exceptions 18
Les exceptions de type ArithmeticException seront
attrapées par le premier catch, et celles de type
IndexoutOfBoundsException seront attrapées par le
deuxième catch.
Si une exception de type ArithmeticException est

lancée, seul le code du bloc catch correspondant est
exécuté. L’exécution se poursuit ensuite à l’instruction
qui suit le dernier bloc catch.
38
Lorsque vous voulez attraper des exceptions de

plusieurs types différents qui peuvent être lancé par un
même bloc try, l’ordre des blocs catch est important.
Lorsqu’une exception est lancée, elle sera attrapée par

le premier bloc catch dont le type du paramètre est le
même que celui de l’exception, ou de type d’une
superclasse de la classe type de l’exception.
39
Exceptions 19
Le cas extrême serait si vous spécifiez un bloc catch avec un paramètre de type
Exception, ce bloc attrapera n’importe quelle exception de type Exception ou de
type d’une sous classe de la classe Exception.
Les blocs catch doivent être placés avec le bloc dont le paramètre est de type le
plus dérivé en premier, et le bloc catch dont le paramètre est de type de la
classe de base en dernier. Dans le cas contraire, le code ne sera pas compilé.
La raison de cela est que si un bloc catch qui attrape une exception d’un type
donné précède le bloc catch qui attrape une exception d’un type qui dérive de
type précédent, le second bloc catch ne sera jamais exécuté.
40
// Sequence invalide de blocs catch
Try {
// Code qui peut lancer des exceptions de type
// ArithmeticException et d’autres exception de type sous classes
// de Exception
}
Catch (Exception e) {
// Code qui attrapera toute exception de type Exception
// ou de toute classe dérivé de la classe Exception
}
Catch (ArithmeticException e) {
// Code qui attrape uniquement les exceptions de type
// ArithmeticException et de ses sous classes
}
Ce code ne compilera pas parce que le deuxième catch ne s’exécutera jamais,

puisque le premier catch attrapera toutes les exceptions qui dérivent de la
classe Exception y compris ArithmeticException.
41
Exceptions 20
Le bloc finally
Lorsqu’une exception est lancée dans un bloc try, l’exécution du bloc est arrétée
à l’instruction qui cause l’exception, quel que soit l’importance du code qui vient
après.
Ceci peut avoir comme effet de laisser les choses dans un état non satisfaisant,
car il est possible d’avoir ouvert un fichier où établir une connexion réseau, et le
lancement d’une exception ne laissera pas les instructions destinées à fermer
les fihiers et les connexions s’exécuter.
Le bloc finally fournit le moyen de faire le nettoyage après l’exécution d’un bloc
try.
Vous utilisez un bloc finally lorsque vous voulez être sûr qu’un code sera
exécuté avant de quitter la méthode qu’il y ait ou non lancement d’exceptions
dans le bloc try.
Un bloc finally est toujours exécuté quel que soit ce qui arrive dans une
méthode.
42
Le bloc finally a une structure simple:
Finally {
// code de nettoyage toujours exécuté et en dernier
}
Comme un bloc catch, un bloc finally doit toujours être associé à un bloc try, et
doit être placé après le dernier catch associé au même try.
S’il n’ya aucun catch associé à un bloc try, le bloc finally doît être placé
immédiatement après le bloc try.
Il est bien sûr possible d’avoir un bloc try avec uniquement des blocs catch sans
qu’il n’y ait de bloc finally.
43
Exceptions 21
Structure d’une méthode
Double doSomething(int aParam)
throws exceptionType1, ExceptionType2 try {
{ // Code qui peut lancer des exceptions
//Code qui ne lance pas d’exception }
//ensemble de blocs try/catch/finally catch (MyException1 e) {
// Code qui traite MyException1
//Code qui ne lance pas d’exception
}
//ensemble de blocs try/catch/finally
catch (MyException2 e){
//Code qui ne lance pas d’exception // Code qui traite MyException2
}
//ensemble de blocs try/catch/finally
//Code qui ne lance pas d’exception finally{
// Code à exécuter toujours
//…. }
44
Exécution normale d’une méthode

(aucun lancement d’exception)
L’exécution
commence au try {
début de try // Code qui peut lancer des exceptions
}
catch (MyException1 e) {
Après une sortie // Code qui traite MyException1
normale du bloc try, }
le bloc finally est
exécuté, avant toute catch (MyException2 e){
instruction return // Code qui traite MyException2
dans le bloc try }
finally {
Si aucune instruction }
return ne se trouve ni
dans try, ni dans finally,
l’exécution continue à
l’instruction qui suit
finally.
45
Exceptions 22
Exécution lorsqu'une exception est lancée et attrapée
L’exécution
commence au try {
début de try
// Code qui peut lancer des exceptions
}
L’exécution s’arrête au point où s’est
produite l’exception. L’exécution catch (MyException1 e) {
continue au bloc catch qui
correspond à l’exception
}
catch (MyException2 e){
Après l’exécution du bloc catch, }
le contrôle passe au bloc finally
finally {
Si aucune instruction }
return ne se trouve ni
dans catch, ni dans
finally, l’exécution
continue à l’instruction
qui suit finally.
46
Exécution lorsqu’une exception est lancée mais pas attrapée.

Propagation d'une exception
int method1(…){
try{
methode2(…)
Int methode2(…){
}
Propagation d'exception2 non attrapée methode3( …)
}
Exception2 attrapée
catch (Exception1 e){

//Code pour traiter l’exception
non attrapée
d'exception2
Propagation
catch (Exception2 e){

//Code pour traiter l’exception
}
finally { Int methode3(…){
// code toujours exécutée //lancecement de l'exception2
} }
}
Une exception lancée mais non attrapée se propage d'un niveau à l'autre jusqu'à
ce qu'elle soit attrapée ou jusqu'au niveau le plus élevé. Si elle n'est pas traitée
dans ce dernier niveau, l'exécution du programme est interrompue 47
Exceptions 23
public class TryBlockTest {
int[] x = {10, 5, 0}; // Array of three integers
// This block only throws an exception if method divide() does

try {
System.out.println("First try block in main() entered");
System.out.println("result = " + divide(x,0)); // No error
x[1] = 0; // Will cause a divide by zero
System.out.println("result = " + divide(x,0)); // Arithmetic error
x[1] = 1; // Reset to prevent divide by zero
System.out.println("result = " + divide(x,1)); // Index error
} catch(ArithmeticException e) {
System.out.println("Arithmetic exception caught in main()");
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Index-out-of-bounds exception caught in main()");
}
System.out.println("Outside try block in main()");
}
48
// Divide method
public static int divide(int[] array, int index) {
try {
System.out.println("\nFirst try block in divide() entered");
array[index + 2] = array[index]/array[index + 1];
System.out.println("Code at end of first try block in divide()");
return array[index + 2];
} catch(ArithmeticException e) {
System.out.println("Arithmetic exception caught in divide()");
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Index-out-of-bounds exception caught in divide()");
} finally {
System.out.println("finally block in divide()");
}
System.out.println("Executing code after try block in divide()");
return array[index + 2];
}
}
49
Exceptions 24
Blocs try emboités
try{
try{
//premier bloc try interne
}
catch(Exception1 e){ Le bloc catch externe
//…… peut attraper n'importe
} quelle exception lancée
//bloc try externe mais non attrapée à
try{
//second bloc try interne
l'intérieur du bloc try , y
} compris dans les blocs
catch(Exception1 e){ try internes
//……..
}
}
Catch (Exception2 e){
bloc catch du bloc try externe
}
HASSOUNI Larbi 50
Relance d'une exception

try{
//code qui lance une ArithmeticException
}
catch(ArithmeticException e){
traitement de l'exception
//lancement de l'exception vers le programme appelant
throw e;
}
Une exception qui a été lancée et traitée dans une méthode appelée peut être
relancée vers le programme appelant en vue de terminer son traitement et en
tenir compte dans la suite des opérations du programme.
HASSOUNI Larbi 51
Exceptions 25
Objets Exception
L'objet Exception qui est passé comme
argument au block catch peut fournir des
informations importantes sur la nature du
problème qui a causé l'exception.
La classe de base des exceptions est la classe
Throwable, par conséquent chaque objet
Exception hérite ses membres
HASSOUNI Larbi 52
Classe Throwable
La classe Throwable contient deux constructeurs public:
• Le constructeur par défaut
• un constructeur qui accepte un argument de type String.
Cet argument est utilisé pour fournir une description de
la nature du problème qui a causé l'exception.
Un objet Throwable contient deux entités d'information:

• Un message, qui est initialisé par le constructeur
• Un enregistrement de la pile d'exécution au moment où
l'objet Exception est créé, autrement dit au moment où
l'exception est lancée.
HASSOUNI Larbi 53
Exceptions 26
La pile d'exécution garde la trace de toutes les
méthodes qui sont en cours d'exécution à un
moment donné. Elle fournit le moyen qui
permet de retourner au programme appelant
après exécution d'une instruction return de la
méthode appelée.
HASSOUNI Larbi 54
L'enregistrement de la pile d'exécution stocké dans l'objet

Exception consiste en le numéro de la ligne du code source où
l'exception s'est produite, suivie par une trace des appels de
méthodes qui précèdent le point où l'exception est arrivée.
Cette trace des appels de méthodes contient le FQN de

chaque méthode appelée, plus le numéro de la ligne du code
source où l'appel de méthode a eu lieu.
Ces appels sont en séquence, avec l'appel de méthode le plus
récent en premier. Cela aide à comprendre comment on est
arrivé au point qui cause l'exception
HASSOUNI Larbi 55
Exceptions 27
La classe Throwable contient les méthodes public ci-
dessous pour permettre l'accès au message et à
l'enregistrement de la pile d'exécution:
Méthode Description
Retourne le message qui décrit
l'exception.
getMessage() Il est généralement formé par le
FQN de la classe exception, et une
brève description de l'exception
Affiche à l'écran le message et
printStackTrace() l'enregistrement de la pile
d'exécution
HASSOUNI Larbi 56
Méthode Description
printTraceStack Identique à printStackTrace, sauf qu'elle
(PrintStream s) écrit dans un fichier.
Modifie le numéro de la ligne où s'est
produite l'exception par celui où cette
méthode est appelée.
L'intérêt principal de cette méthode est
lorsqu'on veut relancer une exception, et
fillInStackTrace() enregistrer le numéro de la ligne où la
relance a été effectuée.
e.fillInStackTrace(); //enregistrer la ligne de
relance
throw e; //relancer l'exception.
HASSOUNI Larbi 57
Exceptions 28
Pourquoi des exceptions
non contrôlées ?
• Les exceptions non contrôlées peuvent
survenir dans toute portion de code (par
exemple NullPointerException ou
IllegalArgumentException)
• Si ces exceptions étaient contrôlées, toutes les
méthodes auraient une clause throws ou le
code serait rempli de bloc try-catch
58
Définir ses propres exceptions

Il ya deux raisons principales pour définir ses
propres exceptions:
Vous voulez ajouter des informations lorsqu'une
exception standard se produit. Vous pouvez
faire cela en lançant un objet de votre propre
classe exception
Vous avez une condition d'erreur dans le
programme qui garantit la distinction d'une
classe d'exception spéciale.
HASSOUNI Larbi 59
Exceptions 29
Définition d'une classe Exception
une classe exception doit toujours avoir Throwable comme
superclasse, sinon vous ne définissez pas une exception.
Même si vous pouvez dériver votre classe exception de
n'importe quelle classe d'exception standard, la meilleure
politique est de la dériver à partir de la classe Exception.
Cela permet au compilateur de garder trace de l'endroit où
l'exception s'est produite, puis de contrôler si l'exception est
attrapée (caught) ou lancée (thrown) dans la méthode.
Si vous utilisez RunTimeException comme superclasse, le
compilateur supprimera le contrôle de l'existence des blocs
catch pour votre exception.
HASSOUNI Larbi 60
Exemple de définition d'une classe exception

Public class MyException extends Exception{
//Constructeurs
public MyException(){} //Constructeur par défaut
public MyException(String s){
super(s); //appel du constructeur de la superclasse
}
}
Par convention, votre classe exception doit inclure un constructeur par défaut ,
et un constructeur qui accepte un argument de type String.
Le message stocké dans la superclasse Exception sera automatiquement
initialisé par le nom de votre classe quelque soit le constructeur utilisé pour
créer l'objet exception.
Si vous utilisez le deuxième constructeur, l'argument String est ajouté au nom
de la classe.
HASSOUNI Larbi 61
Exceptions 30
Il est bien sûr possible de définir d'autres
constructeurs.
Il est également possible d'ajouter à votre classe
des variables membres d'instances pour
stocker davantage d'information sur les causes
de l'exception, et des méthodes qui vont
permettre d'accéder à ces informations dans
un bloc catch.
Votre classe héritera bien sûr des méthode de la
classe Throwable citées précédemment.
HASSOUNI Larbi 62
Lancement de votre propre exception

Pour lancer votre propre exception, vous utiliserez le mot clé
throw suivi par un objet instance de votre classe exception:
MyException e = new MyException()
throw e;
ou tout simplement:
throw new MyException();
Cette instruction mettra immédiatement fin à l'exécution de la
méthode qui la contient à moins qu'elle ne se trouve dans un
bloc try ou catch qui est associé à un bloc finally, lequel est
d'abord exécuté avant que la méthode ne se termine.
L'exception est lancée au programme appelant au point où la
méthode est appelée.
Si vous voulez ajouter un message spécifique, vous pouvez bien
sûr utiliser le 2ème constructeur.
HASSOUNI Larbi 63
Exceptions 31
Exemples de traitements
dans un bloc catch
• Fixer le problème et réessayer le traitement
qui a provoqué le passage au bloc catch
• Faire un traitement alternatif
• Retourner (return) une valeur particulière
• Sortir de l’application avec System.exit()
• Faire un traitement partiel du problème et
relancer (throw) la même exception (ou une
autre exception)
64
Souplesse dans le traitement

des exceptions
• La méthode dans laquelle l’erreur a eu lieu peut
– traiter l’anomalie
• pour reprendre ensuite le déroulement normal du
programme,
• ou pour faire un traitement spécial, différent du
traitement normal
– ne rien faire, et laisser remonter l’exception
– faire un traitement partiel de l’anomalie, et laisser les
méthodes appelantes terminer le traitement
65
Exceptions 32
Pourquoi laisser remonter
une exception ?
• Plus une méthode est éloignée de la
méthode main dans la pile d’exécution,
moins elle a une vision globale de
l’application
• Une méthode peut donc laisser remonter
une exception si elle ne sait pas comment la
traiter, en espérant qu’une méthode
appelante en saura assez pour la traiter
66
Cas des exceptions non traitées

• Si une exception remonte jusqu’à la méthode
main() sans être traitée par cette méthode,
– l’exécution du programme est stoppée
– le message associé à l’exception est
affiché, avec une description de la pile des
méthodes traversées par l’exception
• A noter : en fait, seul le thread qui a généré
l’exception non traitée meurt ; les autres
threads continuent leur exécution
67
Exceptions 33

Java Notions Fondamentales Open Classroom

Transféré par

Droits d'auteur :

Formats disponibles

Java Notions Fondamentales Open Classroom

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Java Notions Fondamentales Open Classroom

Transféré par

Droits d'auteur :

Formats disponibles

Univerité hassan ii

HASSOUNI Larbi Présentation de Java

HASSOUNI Larbi Présentation de Java 2

• La technologie Java est développée par SUN Microsystems™

• La technologie Java est utilisée dans de nombreux domaines

HASSOUNI Larbi Présentation de Java

public static void main(String[ ] args) { La description

Compilation : javac HelloWorld.java Exécution : java HelloWorld.

♠ Un code source ne peut pas être exécuté directement par

♠ Il faut traduire ce code source dans un langage que

♠ Un compilateur est un programme qui effectue cette

HASSOUNI Larbi Présentation de Java

Compilation en Java → bytecode

♠ En Java, le code source n’est pas traduit directement

♠ Il est d’abord traduit dans un langage appelé «bytecode»,

♠ Ce langage (bytecode) est indépendant de l’ordinateur qui

HASSOUNI Larbi Présentation de Java

Programme écrit en Java Programme source

Programme en bytecode, Bytecode

Compilation avec javac

crée un fichier « HelloWorld.class » qui contient le

On peut désigner le fichier à compiler par un chemin

HASSOUNI Larbi Présentation de Java

public class Test { 01100001

HASSOUNI Larbi Présentation de Java

Le bytecode doit être exécuté par une JVM

Cette JVM n'existe pas ; elle est simulée par un programme

– lit les instructions (en bytecode) du programme .class,

– les traduit dans le langage natif du processeur de

– lance leur exécution

HASSOUNI Larbi Présentation de Java

♠Sun fournit le programme java qui simule une JVM

♠ HelloWorld.class doit être dans le répertoire courant ou

HASSOUNI Larbi Présentation de Java

♠ Les systèmes qui veulent pouvoir exécuter un

♠ A l'heure actuelle, tous les systèmes ont une JVM

♠ Il existe aussi depuis peu quelques JVM « en dur »,

HASSOUNI Larbi Présentation de Java

JVM sous Unix, JVM sous Linux,

JVM sous Windows, JVM sous MacOS,

Avantages de la JVM pour Internet

♠ Grâce à sa portabilité, le bytecode d'une classe peut

♠ La JVM fait de nombreuses vérifications sur le bytecode

♠ La JVM apporte donc

HASSOUNI Larbi Présentation de Java

♠ Les vérifications effectuées sur le bytecode et l'étape

♠ Mais les techniques « Just In Time (JIT) » ou « Hotspot »

HASSOUNI Larbi Présentation de Java

Java et les autres langages

♠ Java est devenu en quelques années un des langages de

♠ Pour les applications qui nécessitent une très grande

HASSOUNI Larbi Présentation de Java

♠ Java, c’est en fait

– le langage Java : http://java.sun.com/docs/books/jls/

– une JVM : http://java.sun.com/docs/books/vmspec/

– les API : Ensemble de classes prédéfinies et réparties

♠ Java n’est pas normalisé ; son évolution est gérée par le

HASSOUNI Larbi Présentation de Java

API (Application Programming Interface) :

♠ Java SE : Java Standard Edition ; JDK = J2SE