Cours-Programmation Orienté Objet Java

Licence 2- Réseau Télécom
ESGIC
Mr. Sany
2020-2021
1
2
Origines
Fin des années 50
Début des
début des années Années 70
Années 50 Années
60 …
80
Langages Bas niveau Langage de plus Langages de

Langage
Ex: langage binaire, haut niveau programmation
orientées Objet
langage assembleur Ex: Fortran, structurée Ex: Java, C++
Cobol Ex: Pascal, C
3
Le langage Java
 Créé en 1995 par Sun Microsystems
 Sa syntaxe est proche du langage C
 Il est fourni avec le JDK (Java Developpment Kit)
– Outils de développement
– Ensemble de paquetages très riches et très variés
 Multi-tâches (threads)
 Portable grâce à l’exécution par une machine virtuelle
4
Caractéristiques
Orienté Portable
Objet
Simple Interprété
JAVA
Fortement Multitâches
typé
Gère la Économe
mémoire
Sûr
5
Environnement de programmation
1. Compilation:
-La compilation d’un programme Java ne traduit
pas directement le code source en fichier exécutable.
-Elle traduit d’abord le code source en un code
intermédiaire appelé «bytecode».
-Le bytecode sera ensuite exécuté par une machine
virtuelle (JVM ; Java Virtual Machine).
=>Ceci permet de rendre le code indépendant de la
machine qui va exécuter le programme.
 Sun fournit le compilateur javac avec le JDK.
6
Environnement de programmation
1. 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 machine relatif à la machine
sur laquelle il sera exécuté.
– Lance leur exécution
 Pour exécuter, Sun fournit le programme java qui

simule une JVM.
7
8
Mon premier programme en java
public class Bonjour

{
public static void main(String args[])
{
System.out.println(" Bonjour" );
}
}
9
10
Java: Syntaxe
Convention de codage
 Un nom de classe ou interface doit commencer par une
majuscule.
 Ex: class Point
 Un nom d’attribut doit commencer par une minuscule.

 Ex: loopCounter
 Une constante s’écrit en majuscules.

 Ex: PI
 JAVA est sensible à la casse.
Ne pas utilisé les noms réservés comme noms de variables ou
noms de classes.
11
Mots réservés
12
Java: Syntaxe
Les commentaires
 Sur plusieurs lignes
 Sur une seule ligne
 Commentaire Javadoc
Java: Syntaxe
Déclaration des variables
int i = 0;
Type
Nom de la variable
La déclaration et l’initialisation d’une variable peut se faire en une seule ligne.
Ex: int i = 0;
La déclaration et l’initialisation d’une variable peut se faire sur plusieurs lignes.
Ex: String chaine;

chaine = "bonjour";
La déclaration de plusieurs variables en même temps.
Ex: int i = 0, j = 3;
Java: Syntaxe
Les types des variables
Les types numériques entiers
byte short int long

Taille (en bits) 8 16 32 64
Intervalle de -128 … 127 -32768 … 32767 -231 … 231-1 -263 … 263-1
valeurs
Les types numériques flottants
float double
Taille (en bits) 32 64
Exemple 4.2f 4.2
Java: Syntaxe
Le type booléen
true
 peut prendre deux valeurs Ex: boolean trouve = true;
false
Le type caractère
 Permet de gérer les caractères. Ex: char unChar = ‘A’;

 Un caractère est placé entre simples quottes.
Java: Syntaxe
Le type chaîne de caractères
 Comme son nom l’indique, ce type permet de gérer les chaînes de caractères.
 Il s’agit d’une classe donc elle intègre des méthodes permettant d’opérer sur la chaîne.
 Une chaîne est placée entre doubles quottes.
Ex: String chaine = " Bonjour ";

Java: Syntaxe
Les opérateurs
D’affectation
Opérateur Exemple Résultat
= i = 90 i = 90
+= i += 20 i = 110
-= i -= 10 i = 100
*= i *= 2.5 i = 250
/= i /= 10 i = 25
%= i %= 10 i=5
^= i ^= 2 i = 25
Java: Syntaxe
Les opérateurs
De comparaison
Opérateur Signification Opérateur Signification

x>y Strictement supérieur x&y ET binaire
x<y Strictement inférieur x^y OU exclusif
x >= y Supérieur ou égal binaire
x <= y Inférieur ou égal x|y OU binaire
x == y Egalité x && y ET logique
x != y Différent x || y OU logique
x?y: z Opérateur
conditionnel
Java: Syntaxe
 Les opérateurs
De transtypage ou de cast
implicites  pas de perte d’information

Exemple : int vers float
int n;
float f;
n=3;
f=n; // 3 est converti en 3.0
20
Java: Syntaxe
 Les opérateurs
De transtypage ou de cast
explicites  passage d’un type donné vers un autre

moins précis
Exemple:
double rslt;
int x = 3, y = 2;
rslt = 1.5 + x / y;  rslt = 2.5 division entière
rslt = 1.5 + (double) x / (double) y;  rslt = 3.0 division réelle
21
Java: Syntaxe
Les structures de contrôle
Les boucles
while (boolean) do
{ {
… …
// bloc d’instructions // bloc d’instructions
… …
} } while (boolean)
Java: Syntaxe
Les boucles
for (initialisation; condition; modification)

{
…
// bloc d’instructions
…
} Exemple:
 for (i = 0; i < 10; i++) {…}
 for (int j = 10; j > 0; j - -) {…}
 for ( ; ; ) {…}
Java: Syntaxe
Les branchements conditionnels
switch (variable)
{
if (boolean) { case argument:
… …;
} else if (boolean) { break;
…
} else { case argument:
… …;
} break;
default: …;
}
Exemple de Switch
25
Exemple if
int month = 8;
if (month == 1)
{ System.out.println("January"); }
else if (month == 2)
{ System.out.println("February");
}
... //jusqu’a la fin
26
27
Nom de la
classe
Déclaration de classe
public class Personne {
private String nom;
Modificateur private String prenom;
private int age;
… // autres attributs
Déclaration des
attributs public Personne () {
nom = " ";
prenom = " ";
age = 0;
Définition des }
méthodes public String getNom(){
return this.nom;
}
… // autres méthodes
}
28
Modificateurs de classe
Modificateur Signification
Public La classe est accessible partout.
Private La classe n’est accessible que du fichier où elle a été définie.
Abstract La classe contient des méthodes abstraites. Elle ne peut pas

être instanciée.
Final La classe ne peut pas être redéfinie.
29
Exemple de classe public void setNom(String n){
nom = n;
public class Personne { }
private String nom; public String getPrenom(){
private String prenom; return this.prenom;
private int age; }
public void setPrenom(String p){
public Personne () { prenom = p;
nom = " ";
}
prenom = " ";
age = 0;
public int getAge (){
} return this.age;
public String getNom(){ }
public void setAge(int a){
return this.nom;
age = a;
}
}
30
Exemple de classe
public Static void main(String[] args){

Personne a = new Personne();
a.setNom (« Alaoui" );
a.setPrenom (" Aymen ");
a.setAge(25);
System.out.println(" Le nom est " + a.getNom()+ " , le prénom
est " + a.getPrenom() + " et l’âge est " + a.getAge() + " ans. ");
}
}
Le nom est Alaoui, le prénom est Aymen et l’âge est 25 ans.
31
Classe Personne

private String nom ;
private byte departement ;
}
//Définition des champs de la classe Personne
//private précise que les champs nom et département ne
sont accessibles qu’à l’intérieur de la classe Personne.
//département de résidence qui est un entier compris
entre 1 et 95
32
Classe Personne
Définition des constructeurs de la classe Personne
public Personne (String nomp) {
nom = nomp.toUpperCase() ;
departement = 0 ;
}
//Définition d'un constructeur qui construit un objet de
type Personne dont le nom est une chaîne de
caractères en majuscules et dont le département est
inconnu.
33
Classe Personne
Définition des méthodes de la classe Personne
public void setDepartement (int dept) {
departement = (byte) dept; }
public void affiche () {
System.out.println("Je m'appelle " + nom) ;
if (departement!=0)
System.out.println("J’habite dans le " + departement) ;}
}
//Le mot clé public précise que les méthodes sont
accessibles partout où la classe Personne est accessible.
34
Accès aux membres d’une classe
 On appelle membres d'une classe les champs et les
méthodes de la classe.
 Accès public : Les membres d’une classe C, définies avec

le modificateur public, sont accessibles partout où la
classe C est accessible.
 Accès private :Les membres d’une classe C, définies

avec le modificateur private, ne sont accessibles que
dans la classe C.
35
Les méthodes d’une classe
typologie des méthodes
 On distingue trois types de méthodes dans une classe :
 les constructeurs qui permettent d'initialiser les

champs d'un objet.
 les méthodes d'accès qui fournissent des informations

relatives à l'état d'un objet, c'est à dire aux valeurs de
certains de ses champs (généralement privés), sans les
modifier ;
Exemple:
public String getNom()
{ return nom ; }
36
typologie des méthodes
 les méthodes d'altération qui modifient l'état d'un

objet, donc les valeurs de certains de ses champs.
Exemple
public void setDepartement (int dept)
{ departement = (byte) dept; }
37
Règles d’écriture des méthodes
 Une méthode est formé d'un bloc qui constitue son
corps précédé d'un en-tête comme suit :
modificateur_d'accès type_de_retour nom_méthode

(Type1 argument1, Type2 argument2, …)
Exemple:
public void setDepartement (int dept)
{ departement = (byte) dept; }
38
Surdefinition des méthodes
 Plusieurs méthodes peuvent porter le même nom si
leur signature diffère, c'est à dire si le nombre et/ou le
type de leurs arguments diffèrent. Le compilateur
détermine alors la méthode à exécuter en fonction de
sa signature.
39
Surdefinition des méthodes - Exemple
class Point { public class Surcharge {
private int x,y; public static void main(String arg[]) {
public void initialise (int abs, int ord) Point a=new Point();
{ a.initialise(1,2);
x=abs; y=ord;
} a.deplace(1,3);
pubic void deplace (int dx, int dy)
{ a.deplace(2);
x+=dx; y+=dy;
} short p=3;
pubic void deplace (int dx) a.deplace(p);
{
x+=dx; byte b=2;
} a.deplace(b); //???
pubic void deplace (short dy) }
{ }
y+=dy;
}}
40
Variables et valeurs
 Il existe deux types de variables en Java :
 les variables de type primitif (chapitre précédent)

Exemple: int n ;
 les variables de type classe.

Exemple : Personne p1 ;
41
 L’emplacement mémoire d’une variable de type

primitif contient la valeur associée à la variable.
Exemple:
int n; n ?
n=10; n 10
42
 L’emplacement mémoire d’une variable de type classe

contient une référence à l’objet associé à la variable.
Exemple:
Personne p = new Personne(" Aymen");
p Aymen nom
0 departement
43
Variables et affectations
 Une affectation entre deux variables de type primitif
porte sur leur valeur.
Exemple:
int x=10, y=20 ;
x = y ; //x et y valent 20
y+=5 ; //les valeurs de x et de y sont distinctes : x
vaut 20 et y vaut 25
44
 Une affectation entre deux variables de type classe
porte sur les références et non sur les objets eux
mêmes.
Exemple:
Personne p1, p2 ;
p1 = new Personne("Aymen") ;
p2 = new Personne("Sarah") ;
p1 Aymen
0
p2 Sarah
0
45
p1=p2;
p1 Aymen
0
p2 Sarah
0
//Les variables p1 et p2 désignent le même objet.
46
Création et initialisation d’un objet
 Soit une classe C. Pour créer un objet de type C, il faut :
 déclarer une variable de type C qui réserve un

emplacement mémoire pour une référence à l’objet de
type C
 appeler l’opérateur unaire new qui permet d’allouer un

emplacement mémoire pour l’objet de type C et fournit
sa référence en résultat.
47
Exemple:
//déclaration d’une variable de type Personne
Personne p1 ; p1 ?
//création d’un objet de type Personne référencé par p1

p1 = new Personne("Sarah") ;
p1 Sarah
0
 On notera que les champs d'un objet peuvent être soit de

type primitif, soit de type classe.
48
Initialisation par défaut des champs d’un
objet
 Les champs d'un objet sont toujours initialisés par
défaut. Dès qu'un objet est créé, et avant l'appel du
constructeur, ses champs sont initialisés à une valeur par
défaut dite "nulle« ainsi définie :
Type du champ Valeur par défault
boolean false
char caractère de code nul
entier (byte, short, int, long) 0

flottant (float, double) 0
objet null
49
Initialisation explicite des champs d’un
objet
 Les champs d'un objet peuvent être initialisés lors de
leur déclaration.
Exemple
class A {
private int n = 10 ;
private int p ;
}
// En règle générale, il est préférable d’effectuer les

initialisations explicites dans le constructeur
50
Initialisation explicite des champs d’un
objet
 Les champs d'un objet peuvent être initialisés lors de
leur déclaration.
Exemple
class A {
private int n = 10 ;
private int p ;
}
// En règle générale, il est préférable d’effectuer les

initialisations explicites dans le constructeur
51
Initialisation par un constructeur
 Un constructeur d’une classe C est une méthode
particulière, sans valeurs de retour, portant le même nom
que la classe. Il permet d'automatiser le mécanisme
d'initialisation d'un objet de type C.
Exemple
private String nom ;
private byte departement ;
public Personne (String nomp) {
nom = nomp.toUpperCase() ;
departement = 0 ; } }
Personne p1 = new Personne("Sarah") ;
//Création d’un objet de type Personne référencé par p1.

//Le constructeur de la classe Personne initialise les champs nom et
departement de l’objet p1 ave respectivement les valeurs Sarah et 0.
52
Remarque
 Une classe peut avoir plusieurs constructeurs ou aucun.
 Java fournit un constructeur par défaut.
 Le constructeur par défaut est sans arguments et initialise

chaque champ de l’objet construit avec la valeur par défaut
nulle de son type.
 Dès qu’une classe possède au moins un constructeur, le

constructeur par défaut n’est plus disponible, sauf si la
classe contient explicitement un constructeur sans
arguments.
53
Remarque
 Exemple
//Si dans la classe Personne, on définit le constructeur :
public Personne () {
nom = null ; departement = 0 ; }
//On pourra écrire :

Personne p2 = new Personne() ;
54
Encapsulation
 Une classe permet d’envelopper les objets : Un objet
est vu par le reste du programme comme une entité
opaque.
 Encapsulation est l'enveloppement des attributs et

méthodes à l'intérieur des classes (+) le contrôle
d'accès aux membre de l’objet.
 Le contrôle d'accès aux membres de l’objet : Les

membres publiques sont vus de l'extérieur mais les
membres privés sont cachés.
55
Encapsulation
 Accessibles pour l’extérieur par des méthodes

particulières (sélecteurs)
 Plusieurs niveaux de visibilité peuvent être définis en

précédant, la déclaration d’un attribut, d’une méthode
ou d’un constructeur, par un modificateur : private,
public ou protected.
56
Encapsulation : Spécificateurs d’accès
 L'encapsulation permet de définir 3 niveaux de
visibilité des éléments de la classe:
 public: accès depuis l’extérieur (par une classe

quelconque)
 private : accès depuis l’intérieur (accès par une méthode
de la classe elle-même).
 protected: se comporte comme private avec moins de
restriction. Une classe dérivée à un accès aux membres
protected mais pas aux membres private.
57
Encapsulation : Spécificateurs d’accès
 Accès par défaut: lorsqu’aucun de ces spécificateurs

n’est mentionné. Encapsulation "usuelle": les
attributs sont privés, et les méthodes sont
publiques.
58
Exemple 1: modification depuis l’extérieur d’un
champs private
class ClasseTest {
public int x;
private int y;
public void initialise (int i, int j){
x=i;
y=j; // accès à l’attribut private y depuis l’intérieur
}
}
public class TestA{
public static void main (String args[]) {
ClasseTest objA=new ClasseTest();
objA.initialise(1,3); // x vaut 1 et y vaut 3
objA.x=2; // x vaut maintenant 2. On peut accéder à x car il est public
objA.y=3; // ne se compile pas car accès à un attribut privé: y attribut private
}
}
59
Exemple 2: affichage depuis l’extérieur d’un
champs private.
class ClasseTest {
public int x;
private int y;
public void initialise (int i, int j){
x=i;
y=j; // accès à l’attribut private y depuis l’intérieure
}
}
public class TestA{
ClasseTest objA=new ClasseTest();
objA.initialise(1,3); // x vaut 1 et y vaut 3
System.out.println(" x= "+objA.x); // affiche x = 1. x public, on peut y accéder
System.out.println(" y= "+objA.y);
// ne se compile pas car : accès à y qui est un attribut y privé
}
} 60
Résumer :Encapsulation
Public Private
Classe La classe peut être

utilisée dans n’importe
quelle classe
Attribut L’attribut accessible Attribut accessible
directement depuis le uniquement dans le code
code de n’importe quelle de la classe qui le définit
classe
Méthode Méthode pouvant être Méthode utilisable
invoqué depuis le code de uniquement dans le code
n’importe quelle classe de la classe qui la définit
61
Voir TD1
62
Corrigé TD – Exercice1
=>Pour afficher la valeur de l’attribut nom (champs

private), on définie :
Un accesseur (méthode getNom) qui est une
méthode permettant de lire, depuis l’extérieur, le
contenu d'une donnée membre protégée.
63
class Etudiant public class TestEtudiant
{ {
private String nom, prenom; public static void main(String[] args)
Public void initialise(String n, String p) {
{ Etudiant e= new Etudian();
nom=n;
Prenom=p; e.initialise("Mohammed","Ali");
}
public String getNom (){ System.out.println("Nom =
return nom; "+e.getNom());
}
public String getPrenom (){ System.out.println("Prenom =
return prenom; "+e.getPrenom());
} }
} }
64
=>Pour modifier la valeur de l’attribut nom (champs

private), on défine :
Un modificateur (mutateur) (méthode setNom)
qui est une méthode permettant de modifier le contenu
d'une donnée membre protégée.
65
class Etudiant public class TestEtudiant
{ {
private int cne; public static void main(String[] args)
{
public void setCne (int cne)
{ Etudiant e= new Etudiant();
this.cne=cne;
} e.setCne(23);
} }
}
66
Autoréférence: emploi de this
 Utilisé dans un constructeur, le mot clé this désigne
l’objet qui est construit.
Exemple:
public Personne (String nom, int dept) {
this.nom = nom.toUpperCase() ;
//this.nom désigne le champ nom de l'objet de type
Personne qui est construit. Le mot clé this permet de
distinguer le champ de l’objet de l'argument du
constructeur.
setDepartement(dept) ; }
67
 Utilisé dans une méthode autre qu'un constructeur, le
mot clé this désigne l’objet qui a appelé la méthode.
Exemple:
public Personne copie () {
Personne x = new Personne(this.nom,this.departement);
return x ; }
=> Voir td1 exercice3
68
 Au sein d'un constructeur, il est possible d'en appeler
un autre de la même classe (et portant alors sur l'objet
courant).
 Pour cela, on fait appel au mot clé this qu'on utilise

cette fois comme un nom de méthode.
 L'appel this(…) doit alors être la première instruction

du constructeur.
=> Voit tp2 exercice3
69
Exemple
 Dans la classe Personne, on peut définir les deux
constructeurs suivants :
public Personne (String nom, int dept) {

this.nom = nom.toUpperCase() ;
setDepartement(dept) ; }
public Personne (String nom) {
this(nom, 0); }
70
Champ de classe
 Un champ qui n'existe qu'en un seul exemplaire pour

tous les objets d'une même classe est appelé un champ
de classe.
 Un champ de classe est défini avec le modificateur
static.
71
Exemple
Classe A{
static int n;
float y;
}
A a1= new A();
A a2= new A();
a1.n a2.n
a1.y a2.y
Obj a1 Obj a2
// les notation a1.n et a2.n designe le meme champ.Il est possible et
préferable de le nonné A.n
72
Méthodes de classe
 Une méthode de classe représente un comportement
associé à la classe elle-même et peut être appelée
indépendamment de tout objet de la classe.
 La déclaration d’une méthode de classe se fait à l’aide

du mot clé static.
 L’appelle d’une telle méthode ne nécessite que le nom

de la classe correspondante.
 Une méthode de classe ne pourra pas accéder à des

champs usuels (champs non statiques).
73
Méthodes de classe - Exemple
class A{
privat static int n; // Champ de classe
privat float x; // Champ usuel
public static void f() // Methode de classe

{
// ici on peut pas accéder au champ x,
//on peut accéder au champ statique n
}
}
A a =new A();
A.f(); // Appel de la méthode de classe f de la classe A
a.f(); // reste autorisé, mais déconseillé
N.B :La méthode main est une Méthode de classe
74
Classe utilitaire
 Une classe est dite utilitaire si elle ne contient que des
méthodes statiques.
 Exemple:
Math.random();
Math.sqrt(35);
75
Les paquetages
 Le paquetage est un regroupement logique d'un
ensemble de classes sous un identificateur commun.
 Le paquetage est proche de la notion de bibliothèque

que l'on rencontre dans d'autres langages.
 L’attribution d’une classe à un paquetage se fait au

niveau du fichier source:
package nom_paquetage
76
Les paquetages
 En absence d’instruction package dans un fichier
source, le compilateur considère que les classe
appartiennent au paquetage par défaut.
 Pour utiliser une classe appartenant à un paquetage

ont écrit:
import nom_paquetage.*;
77
Les paquetages
Exemple de paquetage:
java.util -> Classes utilitaire :Math ,Date, Scanner,..

java.aw t -> Classes pour concevoir des interfaces graphiques
java.io -> Classes d’entrées / sorties
java.sql -> Classes communiquant avec des BD
78
79
Les tableaux
 Un tableau est une collection indexée d’éléments dont

le nombre est fixé à la création. Le premier élément
d’un tableau correspond à l’indice 0.
 Un tableau est un objet qui peut être référencé par une

variable.
80
Déclaration d’un tableau
 La déclaration d’une référence à un tableau précise
simplement le type des éléments du tableau. Elle peut
prendre les deux formes suivantes :
type nom_tableau []; OU type [] nom_tableau;
 Les éléments d’un tableau peuvent être d’un type

primitif ou d’un type classe.
81
Déclaration d’un tableau-Exemple
 int t1[],n ; // t1 est une référence à un tableaux
d’entiers et n est un entier.
 float [] t2, t3; // t2 et t3 sont des références à des

tableaux de réels.
 Personne t4[],p1; // t4 est une référence à un tableau

d’objets de type Personne et p1 est une référence à un objet
de type Personne.
=>N.B: Une déclaration de tableau ne doit pas précisé de

dimension. Cette instruction sera rejetée à la compilation
: int t[5] ;
82
Création et initiation d’un tableau
 Un tableau a une taille invariable qui est définie à la
création du tableau.
 Pour créer un tableau, on peut : appeler l’opérateur

new qui permet d’allouer un emplacement mémoire
pour le tableau.
83
Exemple:
int t[] = new int[5];
//t est une référence à un tableaux de 5 entiers Cette
instruction alloue l’emplacement mémoire nécessaire
à un tableau de 5 éléments de type int et en place la
référence dans t. Les 5 éléments sont initialisés à une
valeur par défaut "nulle" (0 pour le type int).
t 0
0
0
0
0
84
 Pour utiliser un initialisateur au moment de la
déclaration du tableau.
Exemple:
int t[]={4,5,9,2}
//t est une référence à un tableaux de 4 entiers de valeurs
respectives 4, 5, 9 et 2. Cette instruction est
équivalente aux instructions suivantes :
int t[] = new int[5];
t[0]= 4; t[1]=5; t[2]=9; t[3]=2;
85
 Remarque : La taille peut être une variable.
int n=Clavier.lireInt( ); // saisir au clavier l’entier n.
int tab[ ]=new int [n];
 Le champ length permet de connaître le nombre

d’éléments d’un tableau de référence donnée.
Exemple
int t[] = new int[5] ;
System.out.println("La taille de t est : " + t.length) ;
// la taille de t est 5
86
Affectation des tableaux
 Java permet de manipuler globalement les tableaux par
affectation de leurs références.
 l’affectation ne modifie que la référence. Elle permet le
changement de références.
Soient tab1 et tab2 deux tableaux
tab1=tab2;
=> La référence contenue dans tab2 est affectée à tab1.
Maintenant tab1 et tab2 désignent le même objet
tableau qui était initialement référencé par tab2.
87
Copie de tableau
 Méthode « manuelle » : création d'un nouveau tableau puis
copie élément par élément.
 Copie par appel de : System.arraycopy() :
System.arraycopy(src, srcPos, dest, destPos, nb);
 src : tableau source
 srcPos : indice de src du 1er élément copié
 dest : tableau destination
 destPos : indice de dst où sera copié le 1er élément
 nb : nombre d'éléments copiés
 Copie nb éléments du tableau src (source) à partir de

l’indice srcPos et les affecte dans le tableau dest
(destination) à partir de l’indice destPos.
88
Copie de tableau- Exemple
import java.lang.*;
System.arraycopy(tab1, 6, tab2, 2, 50);
 copie de 50 éléments de tab1 à partir de l’indice 6 et les

affecte dans tab2 à partir de l’indice 2
89
Copie de tableau
 Allocation et copie par appel de : Arrays.copyOf()
 Exemple:
Soit tab un tableau d’entier déjà crée et initialisé.
Création et initialisation du tableau t2 à partir du
tableau tab
import java.util.Arrays;
int[] t2= Arrays.copyOf(tab, 10);
// 1. crée le tableau t2
// 2. affecte au tableau t2 les 10 premiers éléments du
tableau tab.
90
Copie de tableau
 Allocation et copie par appel de :Arrays.copyOfRange()
 Exemple:
Soit tab un tableau d’entier déjà crée et initialisé.
Création et initialisation du tableau t3 à partir du
tableau tab.
import java.util.Arrays;
int[] t3= Arrays.copyOfRange(tab, debut, fin);
// 1. crée le tableau t3
// 2. affecte à t3 les éléments de tab situés entre
// les indices debut et (fin-1) :
91
Comparer deux tableaux
 Soit on compare un à un les éléments des deux tableaux.
 On peut aussi utiliser la méthode equals() de la classe
Arrays
import java.util. Arrays;
int[] tab1,tab2;
tab1=new int[10];
tab2=new int[10];
// initialisation de tab1 et tab2
boolean b=Arrays.equals(tab1,tab2);
if (b) {
…….}
else { ………..}
92
Tableaux à plusieurs dimension
 Java permet de créer des tableaux de tableaux, c’est à
dire des tableaux dont les éléments sont eux-mêmes
des tableaux.
 Création et initialisation :
int t [] [] ;
int [] t [] ;
int [] [] t ;
t = { new int[n], new int[p] };

t[][]= { {1,2,3},{6,7} }
93
Tableaux à plusieurs dimension-Exemple
int t1 [] [] ;
t1 = { new int[3], new int[2] };
//t1 est un tableau à deux éléments dont le premier
élément est un tableau de 3 entiers et le deuxième
élément un tableau de 2 entiers.
94
Matrice
int t3 [] [] = new int[4] [3] ;
//t3 est une matrice composée de 4 lignes et 3 colonnes
95
TD2
96
97
L’exemple du cours
 Un employé est une personne qui travaille dans une

société.
 La classe Employe hérite de la classe Personne.
98
class Personne { public Personne (String lenom, int dept) {

private String nom ; setNom(lenom) ;
private byte departement ; if(dept != 0) setDepartement(dept) ; }
public void setNom (String nom) { public Personne () { // constructeur par

this.nom = nom.toUpperCase() ; } défaut
nom = null ; departement = 0 ; }
public void setDepartement (int
departement) { public void affiche () {
this.departement = (byte) departement; } if (nom != null)
System.out.println("Je m'appelle " + nom);
if (departement != 0)
System.out.println("J’habite dans le " +
departement) ; }
}
99
class Employe extends Personne { public class Test {
public static void main(String args[]) {
/*Le mot clé extends indique au
compilateur que la classe Employe e = new Employe("SocieteX") ;
Employe est une classe dérivée de la /*l’objet e de type Employe a accès aux
classe Personne.*/ membres publics de la classe Personne
*/
Private String societe ;
e.setNom(" Alaoui");
public void setSociete (String societe) { e.setDepartement(75) ;
this.societe = societe.toUpperCase() ; } e.affiche() ;
public Employe (String entreprise) { /*affiche : Je m’appelle Alaoui

setSociete(entreprise) ; } J’habite dans le 75 */
} }
}
100
Définition
 L’héritage permet de définir une nouvelle classe, dite
classe dérivée, à partir d’une classe existante, dite
classe de base.
 Cette nouvelle classe ; classe dérivée ;hérite des
fonctionnalités de la classe de base (champs et
méthodes) .
 qu’elle pourra modifier ou compléter à volonté, sans
remettre en cause la classe de base.
101
Définition
Classe de base A
Héritage
Classe dérivée B
 A la définition d’une classe dérivée, on utilise le mot

clé extends pour désigner sa classe de base :
class B extends A {…}
102
Définition
 Une classe dérivée ne peut hériter que d’une seule
classe de base. On parle d’héritage simple.
 D’une même classe peuvent être dérivées plusieurs
classes différentes.
 Les notions de classe de base et de classe dérivée sont
relatives puisqu’une classe dérivée peut, à son tour,
servir de classe de base pour une autre classe.
 La hiérarchie de classe est une arborescence de racine
unique.
103
Définition
Objet
A B
C D E F G
 La classe Object est la super-classe de toutes les classes

Java.
 On dit que D est une classe descendante de Object et
inversement que Object est une classe ascendante de
D.
104
Accès d’une classe dérivée aux membres de sa
classe de base
 Accès public & privé :
 Les membres publics d’une classe de base restent des
membres publics pour la classe dérivée.
Exemple : Nous avons vu dans l'exemple du cour

que l’objet e de type Employe a accès aux membres
publics de la classe Personne.
105
classe de base
 Accès public & privé:
 Un objet d’une classe dérivée accède aux membres
publics de sa classe de base.
Exemple :
Soit la méthode afficheE de la classe Employe :
106
classe de base
public void afficheE () {
affiche() ;
System.out.println("Je travaille dans la societe " + societe) ; }
Employe e = new Employe("SocieteX") ;

e.setNom("Alaoui");
e.setDepartement(75) ;
e. afficheE() ;
//affiche : Je m’appelle Alaoui
//J’habite dans le 75
//Je travaille dans la societe SOCIETEX
Note: Une méthode d’une classe dérivée n’a pas accès aux
membres privés de sa classe de base.
107
Le modificateur d'accès protected
 Un membre déclaré protected est accessible aux
classes du même paquetage, ainsi qu'à ses classes
dérivées.
 Exemple :
Soit A définit dans un package Pack1
Soit B et C définis dans un package Pack2
108
Le modificateur d'accès protected- exemple
class A { class C extends B {
protected int n ; //accès au champ n de la classe A
} }
class B extends A { class D {
/accès au champ n de la classe A //pas d'accès au champ n de la classe A,
//Attention : toute méthode de la classe sauf si les classes A et D sont dans le
B n’a accès au champ n de la classe A même paquetage
que pour des objets de la classe B ou }
d’une classe dérivée de B
public void f(A a, B b, C c)

{
a.n ; //erreur de compilation : n est
considéré comme un champ privé de la
classe A
b.n ; //ok
c.n ; //ok
}}
109
Récapitulatif sur les droits d’accès
Modificateurs d’accès pour les classes
Modificateur Signification pour une

classe
Public Accès toujours possible
Aucun Accès possible depuis les

classe du même paquetage
110
Récapitulatif sur les droits d’accès
Modificateurs d’accès pour les membres d’une classe
Modificateur Signification pour un membre
Public accès possible partout où la classe

est accessible
Aucun accès possible depuis toutes les
classes du même paquetage
protected accès possible depuis toutes les
classes du même paquetage ou
depuis les classes dérivées
private accès restreint à la classe
111
dérivé
 Lorsqu'on construit une instance de la classe dérivée,

on obtient un objet :
 dont une partie est construite grâce à la définition de la

classe dérivée
 et une partie grâce à la définition de la superclasse
112
dérivé
En Java, le constructeur de la classe drivée doit prendre
en charge l’intégralité de la construction de l’objet.
=>Le constructeur de la classe dérivée doit faire appel au

constructeur de la classe de base en appelant
explicitement la méthode super() ainsi que la liste des
paramètres appropriés.
113
dérivé –Remarque-
 les constructeurs ne sont pas hérités, mais on peut

appeler ceux de la classe mère avec super(…)
 l’appel du constructeur de la classe de base (appel de la

méthode super()) doit être la première instruction
dans la définition du constructeur de la classe
dérivée.
114
Exemple1
class ClasseDeBase{ class ClasseDerivee1 extends
ClasseDeBase {
public ClasseDeBase(int i) { public ClasseDerivee1(int i, int j) {
super(i+j); // appel du constructeur
// constructeur de la classe de base ClasseDeBase
System.out.println("ClasseBase:"+i); System.out.println(" Classe dérivée1: "

} + i+ " , "+j);
} }}
class ClasseDerivee2 extends
ClasseDerivee1{
public ClasseDerivee2(int i) {
super(i,i+300); // appel du
constructeur ClasseDerivee1
System.out.println(" Classe dérivée2: "
+ i);}}
115
Exemple1
public class Test {
ClasseDerivee2 objA=new ClasseDerivee2(7);
}}
Sorties en console:
 Classe de Base : 314
 Classe dérivée1: 7 , 307
 Classe dérivée2: 7
116
Les cas possibles pour la constructions de
classes dérivées Exemple 1:
class ClasseDeBase{
public ClasseDeBase(arguments) { // Constructeur de
la classe de base
}}
class ClasseDerivee extends ClasseDeBase {
// Pas de constructeur }
⇒On obtient une erreur de compilation ?

Un constructeur de la classe dérivée doit être défini et
doit appeler le constructeur de la classe de base.
117
Exemple 2:
class ClasseDeBase{
public ClasseDeBase(arguments1) { // constructeur de la
classe de base
…
}}
public ClasseDerivee(arguments2) { // constructeur de la
classe dérivée
/* Première instruction = Appel de super (arguments1)
C’est obligatoire sinon une erreur */
….
}}
118
Exemple 3:
class ClasseDeBase{
public ClasseDeBase(arguments1) { // constructeur de la classe
de base
… }
public ClasseDeBase() { // constructeur sans paramètre de la
classe de base
… }}
public ClasseDerivee(arguments2) { // constructeur de la classe
dérivée
// l’appel de super () n’est pas obligatoire.
/* si super() n’est pas explicitement appelé, alors le
constructeur sans paramètres de la classe de base est
appelé par défaut. */
….
}}
119
Exemple 4:
class ClasseDeBase{
// Pas de constructeur
… }
// Pas de constructeur
….}
 La création d’un objet de type ClasseDerivee entraîne

l’appel de constructeur par défaut qui appelle le
constructeur par défaut de la ClasseDeBase.
120
Exemple pratique:
class ClasseDeBase{ public class TestHeritage{
public ClasseDeBase() { public static void main (String args[]) {
System.out.println(" Classe de Base: "); ClasseDerivee2 objA=new
}} ClasseDerivee2();
class ClasseDerivee1 extends }}
ClasseDeBase {
public ClasseDerivee1() {
// Appel implicite du constructeur
sans paramètre de ClasseDeBase
System.out.println(" Classe dérivée1: ");
}}
class ClasseDerivee2 extends En console :
ClasseDerivee1{ Classe de Base :
public ClasseDerivee2() { Classe dérivée1:
// Appel implicite du constructeur Classe dérivée2:
sans paramètres de ClasseDerivee1
System.out.println(" Classe dérivée2: "
);}}
121
Résumé
 Si on n'appelle pas le constructeur de la superclasse, le
constructeur par défaut est utilisé si:
 aucun constructeur n’est défini

 au moins un constructeur sans paramètre est défini
sinon le compilateur déclare une erreur
122
Notions de Surdefinition
 On sur définit une méthode quand une nouvelle

méthode a le même nom, mais pas la même signature,
qu’une autre méthode de la même classe
123
Notions de Redéfinition
 On redéfinit une méthode quand une nouvelle

méthode a le même nom et la même signature qu’une
méthode (non privée) héritée de la classe mère.
 Une méthode redéfinie dans une classe dérivée

"masque" la méthode correspondante de la classe de
base.
124
class ClasseDeBase{
public f(arg) {
… }}
class ClasseDerivee1 extends ClasseDeBase {
public f(arg) { // la méthode f() est redéfinie dans
ClasseDerivee1
… }}
class ClasseDerivee2 extends ClasseDeBase{
public f(arg){ // la méthode f() est redéfinie dans
ClasseDerivee2
…. }}
125
Visibilité:
 Lorsqu'un attribut ou une méthode ont été définis

dans une classe et sont redéfinis dans une classe
dérivée (qui en hérite)
=>alors les éléments visibles dans la classe dérivée sont
ceux redéfinis dans cette classe.
=>Les éléments de la classe de base (héritée) sont alors
masqués.
126
Règle :
 On peut avoir les mêmes méthodes dans des classes

héritant les unes des autres.
 Dans ce cas, c'est la classe la plus dérivée de l'objet qui
détermine la méthode à exécuter, sans que le
programmeur ait à faire des tests sur le type de l'objet à
traiter (voir exemple suivant).
127
- Exemple- Soit f() est une méthode définie dans
la classe A. On suppose les liens
A* d’héritage suivants:
- Les classes B et C héritent de A

- Les classes D et E héritent de B
- La classe F hérite de C
*: signifie redéfinition de f().
B C*
 Dans class A: la méthode f() de A
 Dans classe B: la méthode f() de A
 Dans classe D: la méthode f() de D
 Dans classe E: la méthode f() de A
 Dans classe C: la méthode f() de C
D* E F  Dans classe F: la méthode f() de C
128
Class Point{ Class Pixel extends Point {
private int x, y; Private int couleur ;
Public Point ( int a , int b) { x=a; y=b;}
Public Pixel (int a , int b , int c ){
Public void affiche () { super (a,b);
System.out.println(" x= "+ x+"y= "+y);} couleur= c; }
Public void deplace ( int dx , int dy ) { Public void affiche() {

x+=dx ; y+=dy; } Super.affiche();
System.out.println(" couleur= "
} +couleur);}
}
Public class TestPoint {

Public static void main (String[] args){
Pixel p= new Pixel (3,9,2);
p.Affiche();
}
}
129
Résumé:
 La redéfinition d'une méthode d'une classe consiste à

fournir dans une sous classe une nouvelle
implémentation de la méthode.
 Cette nouvelle implémentation masque alors

complètement celle de la superclasse
130
Résumé:
 Grâce au mot clé super, la méthode redéfinie dans la

sous classe peut réutiliser du code écrit dans la
méthode de la super classe, qui n'est plus visible
autrement.
 super a un sens uniquement dans une méthode

(comme le mot clé this).
131
Exceptions
 Une Classe final ne peut pas avoir de classes filles.
 La redéfinition d'une méthode public ne peut être

private
 Une méthode final ne peut pas être redéfinie
132
Exemple2
 Soit f() une méthode définie dans une classe de base.

 Soit g() une méthode définie dans la classe dérivée.
 Dans la méthode g(), l’instruction super. sert à
désigner un membre de la classe de base.
Par exemple:
super.f() désigne la méthode f() de la classe de base
133
Attention
 On ne peut remonter plus haut que la classe mère pour

récupérer une méthode redéfinie :
pas de « super.super.»
134
class B extends A {
class A { public void g(){
public void f(){ super.f(); // désigne la méthode f() de la
System.out.println("Je suis dans la classe classe mère A
de base A"); System.out.println(« Et je suis aussi
} dans la class derivée B");
} }
}

public class TestRedefinition {
B b = new B();
b.g();
}}
Question : Affichage ?
135
Sous type
 Le type B est un sous-type de A si on peut affecter une
expression de type B dans une variable de type A.
 Les type primitifs

- int est un sous type de float (int i; float x=i;)
- float est un sous type de double (float y; double z=y;)
 Les objets
Les sous-classes d’une classe A sont des sous types de A. Dans ce
cas on peut écrire:
A a = new B(…); // la variable a est de type A, alors que l’objet
référencé par a est de type B.
A aa; B b=new B();
aa=b; // aa de type A, référence un objet de type B
136
Définition(Voir exemple point en haut)
 La classe (ou le type) réelle de l’objet est la classe du
constructeur qui a créé l’objet
Exemple: Soit B une sous classe de A
A a = new B(…); // B est la classe (type) réelle de l’objet a
 Le type (la clase) déclaré de l’objet est le type qui est

donné au moment de la déclaration de la variable qui
référence l’objet.
Exemple: Soit B une sous classe de A
A a = new B(…); // A est le type déclaré de l’objet a
137
Public Point ( int a , int b) { x=a; y=b;}
Public void deplace ( int dx , int dy ) { super (a,b);
x+=dx ; y+=dy; } couleur= c; }
Getters/ Setters} Getters/Setters }

Point p= new Pixel (3,9,2);// Pixel est la classe du constructeur qui a créer l’objet
// Point est le type déclaré à la création de l’objet
Question: en utilisant les getters afficher x, y et couleur;
138
public Point ( int a , int b) { x=a; y=b;}
public void affiche () { super (a,b);
System.out.println(" x= "+ x+"y= "+y);} couleur= c; }
public void deplace ( int dx , int dy ) { Public void affiche() {

x+=dx ; y+=dy; } Super.affiche();
System.out.println(" couleur= "
Getters/ Setters} +couleur);}
Getters/Setters }

Point p= new Pixel (3,9,2);// Pixel est la classe du constructeur qui a créer l’objet
// Point est le type déclaré à la création de l’objet
System.out.println(p.gettX());
System.out.println(p.getCouleur()); // Erreur
System.out.println(((Pixel)p).gettCouleur()); // Cast }
139
Cas des tableaux
 Soit B une classe qui hérite de la classe A, alors on peut
écrire :
A[] tab = new B[5];
Attention:
Dans tab[] il faut les valeurs de type réel et non celles du type
déclaré (c’est à dire des valeur de type B et non de type A).
Par exemple, si on a les instructions suivantes:
A[] tab = new B[5];
A a = new A();
tab[0] = a;
=>Passe à la compilation mais provoquera une erreur à
l’exécution car tab[0] reçoit une valeur de type A et non une
valeur de type B.
140
141
Exemple 1
 Soit B est une classe qui hérite de la classe A.
 Soit f() une méthode qui est redéfinie dans B
 Soit g() une méthode définie dans A.
 Soit h() une méthode définie dans B.
142
Exemple 1
class A { public class TestPolymorphisme {
public void f(){ public static void main(String [] args ) {
System.out.println("Méthode f(): Classe
de base A");} A a=new A();
public void g(){ B b = new B();
System.out.println("Méthode g():
Classe de base A");} a.f(); //appelle la méthode définie dans
} A
class B extends A { a=b; // le type déclaré de a est A. Le
public void f(){ type réel de a est B
System.out.println("Méthode f(): Classe a.f(); // appelle la méthode définie dans
B dérivée de Classe A"); } B
public void h(){ a.g(); // appelle la méthode définie dans
System.out.println("Méthode h(): A
Classe B dérivée de Classe A"); } b.g(); // appelle la méthode définie
} dans A
}}
143
Exemple 1
Note:
 La même écriture a.f(); peut correspondre à des appels
différents de la méthode f(). Ceci est réalisé grâce au
polymorphisme.
144
Polymorphisme- définition
 Le Polymorphisme veut dire que le même service peut

avoir un comportement différent suivant la classe dans
laquelle il est utilisé.
 C’est un concept fondamental de la programmation

objet, indispensable pour une utilisation efficace de
l’héritage.
145
Remarque 1
 Quand on manipule un objet via une référence à une
classe mère, ce sont toujours les méthodes (non
statiques) de la classe effective de l'objet qui sont
appelées
A objA = new B();
objA.f();
/*Appel de f() redéfinie dans B (classe effective réelle de
l’objet). Bien que objA est une référence de type A
(Classe déclarée de l’objet). */
146
Remarque 1- suite - important
class A { La méthode f() est statique, la

public static int f(int x) variante utilisée est déterminée par
{return(x+5) ; } la classe de la référence x c’est-à-dire
public int g(int x) {return (3) ; } A),
} donc a.f(2)=A.f(2)= 2+5.
class D extends A {
public static int f(int x) La méthode g() est dynamique, la
{return(x+4) ; } variante utilisée est déterminée par
public int g( int x) {return la vraie classe de l’objet référé par x
(x+8) ; }} (c’est-à-dire D),
qu’affichera le code suivant ? donc a.g(3)=3+8.
D d=new D() ;
A a =d; D’ou la réponse 77.
System.out.println(a.f(2)*a.g(3)) ;
147
La liaison dynamique
 Lors d'un appel de la forme x.f(…) où x est supposé être une
variable de classe C, le choix de la méthode f est déterminé
ainsi :
 à la compilation : on détermine, dans la classe C ou ses
classes ascendantes, la meilleure méthode f convenant à
l'appel (règles de surdéfinition), ce qui définit du même coup
la valeur de retour de f ;
 à l'exécution : on recherche la méthode f de signature et de
type de retour voulus, à partir de la classe C‘ correspondant au
type effectif de l'objet référencé par x (qui est obligatoirement
du type C ou d'un type descendant). Si cette classe C' ne
comporte pas de méthode appropriée, on remonte dans la
hiérarchie jusqu'à ce qu'on en trouve une (au pire, on
remontera jusqu'à la classe C).
148
Exemple
class A { A a = new A(…);
public void f (float x) { … } B b = new B(…);
} int n ;
class B extends A { a.f(n) ; //appel de la méthode f(float)
public void f (float x) { … } de la classe A avec
//redéfinition de f de A conversion d’ajustement de n de type
public void f (int n) { … } int en float
//surdéfinition de f de A et de B b.f(n) ; //appel de la méthode f(int) de
} la classe B
a = b ; //l'objet a contient une référence
à un objet de
type B
a.f(n) ; //appel de la méthode f(float)
de la classe B
à la compilation, choix de la méthode
f(float) de A
à l'exécution, choix de la méthode
f(float) de B
149
Remarque 2 - Important
 Si on a:
B b = new B();
b.h(); // appelle la méthode h() définie dans B
A a=new B();
a.h(); /* erreur à la compilation même si la classe réelle
possède la méthode h().
En effet la classe déclarée (A) ne possède pas la méthode
h(). */
150
Note
Liaison tardive (late binding)
 Le polymorphisme est obtenu grâce au mécanisme de

la liaison retardée (tardive) « late binding »:
la méthode qui sera exécutée est déterminée

– seulement à l’exécution, et pas dès la compilation
– par le type réel de l’objet qui reçoit le message (et pas
par son type déclaré)
151
Liaison retardée: cas des méthodes redéfinies
 Soit B la classe réelle d’un objet objB (B est la classe du
constructeur qui a créé l’objet objB) et soit A la classe
de déclaration de l’objet objB.
A objB = new B();
 Si on a l’instruction : objB.f(); quelle méthode sera

appelée?
152
1. Si la méthode f() n’est pas définie dans une classe

ancêtre de la classe de déclaration (la classe A)
alors erreur de compilation.
153
2. Si non
– Si la méthode f() est redéfinie dans la classe B, alors
c’est cette méthode qui sera exécutée
– Sinon, la recherche de la méthode f() se poursuit dans

la classe mère de B, puis dans la classe mère de cette
classe mère, et ainsi de suite, jusqu’à trouver la
définition d’une méthode f() qui sera alors exécutée.
=> La méthode appelée ne dépend que du type réel (

classe B)de l’objet et non du type déclaré (classe A).
154
 Soit B une classe qui hérite de la classe A, et soit f()

une méthode définie dans A et redéfinie dans B.
 Soit C une classe qui hérite de la classe B.
A a = new B();
a.f(); // La méthode f() appelée est
celle définie dans B.
155
 Maintenant si on:
A a = new C(); // ok car C hérite de B
qui hérite de A
a.f();
- Si la méthode f() est redéfinie dans C alors la

méthode appelée est celle définie dans C.
- Si la méthode f() n’est pas redéfinie dans C alors
c’est la méthode f() redéfinie dans B qui est
appelée.
156
Utilités du polymorphisme
 Le polymorphisme permet d’éviter les codes qui
comportent de nombreux embranchements et tests.
 Exemple
- Considérons une classe A.
- Supposons que les classes B et C héritent de la super
classe A.
- Dans un tableau hétérogène, on ranges des objets de
type B et C.
- Ensuite on affiche le contenu du tableau.
157
Utilités du polymorphisme
instanceof :
 Soit b est une instance d'une classe B alors:
- (b instanceof B) retourne true : signifie que b est une

instance de B.
- si B est une sous classe de A alors (b instanceof A)
retourne true.
158
Exemple
Class A { public class TestPolymorphisme {
public void f() {} // méthode vide public static void main(String[] args) {
public void g() {} // méthode vide A [] objA = new A[3]; // objA tableau
} d’objets
class B extends A { objA[0]=new B(); // création de l’objet
public void f() {// traitement propre à B objA[0]
System.out.println("traitement dans objA[1]=new C(); // création de l’objet
Classe B "); objA[1]
} objA[2]=new C(); // création de l’objet
} objA[2]
class C extends A{ // Pour chaque élément du tableau,
public void g() {// traitement propre à C faire le traitement correspondant
System.out.println("traitement dans for (int i=0; i < objA.length; i++) {
ClasseC "); if (objA[i] instanceof B)
} objA[i].f();
} else if (objA[i] instanceof C)
objA[i].g();
}} }
159
Exemple réécrit en exploitant le polymorphisme
Class A { public class TestPolymorphisme {
public void f() {} // méthode vide public static void main(String[] args) {
} A [] objA = new A[3]; // objA tableau
class B extends A { d’objets
public void f() {// traitement propre à B objA[0]=new B();
System.out.println("traitement dans objA[1]=new C
Classe B "); objA[2]=new C();
}
} for (int i=0; i < objA.length; i++)
class C extends A{ objA[i].f();
public void f() {// traitement propre à C
System.out.println("traitement dans /* On n’a pas besoin de faire des tests: la
Classe C "); méthode appelée correspond à la
} méthode de la classe effective de l’objet :
} principe du polymorphisme.*/
}}
160
161
Classe abstraite
 Une classe abstraite est une classe déclarée avec le mot
clé abstract.
 Elle est non instanciable, elle se sert uniquement de la
classe mère.
Exemple:
abstract class A { … }
 Dans une classe abstraite on peut trouver:
- des champs,
- des méthodes ,
- des méthodes abstraites.
162
Méthode abstraite
 Une méthode abstraite est déclarée avec le mot clé
abstract.
 Dans ce cas on la déclare sans donner son implémentation
(sans spécifier le corps de la méthode). On ne fournit que :
- le type de la valeur de retour

- et la signature (l’entête de la méthode).
 Exemple:
abstract public void f(int i, float x);
abstract public double g();
163
Les règles
 On ne peut pas instancier une classe abstraite.
- On peut créer une référence sur un objet de type A

A objA; // autorisé
- On ne peut pas créer un objet de type A, car il est

interdit de créer une instance (un objet) d’une classe
abstraite.
A objA = new A(); // n’est pas autorisé.
164
Les règles
 Soit B une classe qui hérite de A. Si B n’est pas
abstraite alors on peut écrire:
A a = new B();
 Une méthode static ne peut être abstraite (car on ne

peut pas redéfinir une méthode static).
 Une classe qui définit au moins une méthode abstraite

doit être obligatoirement déclarée abstraite.
165
Les règles
 Soit une classe fille qui hérite d’une classe mère qui
définit des méthodes abstraites. Alors la classe fille
doit implémenter toutes ses méthodes abstraites sinon
elle doit être déclarée abstraite.
 Une méthode déclarée abstraite doit obligatoirement

être déclarée public.
166
Intérêt des classe abstraites:
 Le principe est que la classe mère définit la structure

globale d’un algorithme et laisse aux classes filles le
soin de définir des points bien précis de l’algorithme.
 Par exemple quand on ne connaît pas à priori le

comportement par défaut d’une opération commune à
plusieurs sous-classes
167
Exemple
« Abstract » Animal
Courir()
Lapin Tortue
Courir() Courir()
168
Exemple
public abstract class Animal {
public abstract void courir(); }
public class Lapin extends Animal {

public void courir() {
//Implémentation de la méthode courir pour un lapin
System.out.println("je cours très vite ");}}
public class Tortue extends Animal {

public void courir() {
//Implémentation de la méthode courir pour une tortue
System.out.println("je cours lentement ");}}
169
Interfaces définition
 Une interface définit les en-têtes d'un certain nombre
de méthodes, qui sont par essence abstraites et
publiques, ainsi que des constantes.
 Une interface est déclarée avec le mot clé interface.
 Elle est dotée des mêmes droits d'accès qu'une classe

public.
170
Interfaces exemple 1
public interface I {
void f(int n) ;
void g() ;
// les méthodes f et g sont par essence des méthodes
abstraites et publiques ; il n’est pas nécessaire de les
déclarer avec le mot clé abstract et le modificateur
public
static final int MAXI = 100 ; //constantes

}
171
Interfaces exemple 2
 On peut dériver une interface à partir d'une autre
interface .
public interface I1 { La définition de l'interface I2 est
void f() ; totalement équivalente à :
static final int MAXI = 100 ;
}
public interface I2 extends I1 { public interface I2 {

void g() ; } void f() ;
void g() ;
static final int MAXI = 100 ;
}
172
Implémentation d’une interface
 Une classe peut implémenter une ou plusieurs
interfaces à l'aide du mot clé implements.
 Les méthodes d'une interface doivent être définies par

toutes les classes implémentant l'interface.
 Les constantes d'une interface sont accessibles à toutes

les classes implémentant l'interface.
173
Exemple
public interface I1 {
void f() ;
static final int MAXI = 100 ; }
public interface I2 {
void g() ; }
class A implements I1, I2 {

//les méthodes f et g des interfaces I1 et I2 doivent être
définies dans la classe A
//dans toutes les méthodes de la classe A on a accès à la
constante MAXI
}
174
interface
 Une classe dérivée peut implémenter une ou plusieurs
interfaces.
public interface I {
void f(int n) ;
void h() ;
}
class A implements I1, I2 { … }
class B extends A implements I {
// les méthodes f et g de l'interfaces I sont soit déjà définies
dans la classe A, soit elles doivent l'être dans la classe B
}
175
Interface & polymorphisme
 Soit une classe C implémentant une interface I. Il
existe une conversion implicite d’une référence à un
objet de type C en une référence à un objet de type I.
public interface Mammifere { … } //La méthode suivante peut prendre
public interface Terrestre { … } indifféremment comme paramètre un
public interface Marin { objet de type Tortue ou un objet de type
public String vitesseDeNage() ;} Baleine :
class Tortue implements Terrestre, Marin { public void

public String vitesseDeNage() { … }} afficheVitesseDeNage(Marin m) {
System.out.println("Vitesse de nage : "
class Baleine implements Mammifere, + m.vitesseDeNage()) ; }
Marin {
public String vitesseDeNage() { … }}
176
Variables de type interface
 Une interface ne permet pas d'instancier des objets.
 mais on peut définir des variables de type interface,
qui peuvent référencer des objets d'une classe
implémentant une interface.
 Exemple
public interface I { … }
class A implements I { … }
I i ; //ok
i = new I(…) ; //erreur de compilation
i = new A(…) ; //ok
177
Interfaces ou classes abstraites ?
 Comme une classe abstraite,
- une interface joue le rôle d’un outil de

spécification en forçant toutes les classes
implémentant l’interface à définir ses méthodes ;
- une interface peut se dériver ;
- on peut utiliser des variables de type interface
178
Interfaces ou classes abstraites ?
 Mais :
- une classe peut implémenter plusieurs interfaces
(alors qu'une classe ne pouvait être dérivée que d'une
seule classe abstraite) ;
- la notion d'interface se superpose à celle de

dérivation.
 Conclusion : La notion d'interface est donc une notion

plus riche que celle de classe abstraite.
179
Exercice
 Supposons que nous voulions manipuler deux formes

géométriques, rectangle (donné par son point haut,
gauche, sa largeur et sa longueur) et cercle (donné par
son centre et son rayon).
 Nous désirons pouvoir déplacer ces formes

géométriques, calculer leur surface et leur périmètre.
180
Exercice
class Rectangle{ class Cercle{
int x, y, largeur, longueur; int x, y, rayon;
Rectangle(int x, int y, int la, int lo){ Cercle(int x, int y, int r){
this.x = x; this.x = x;
this.y = y; this.y = y;
largeur = la; rayon = r; }
longueur = lo; }
void deplace( int dx, int dy){ x+=dx; void deplace( int dx, int dy){
y+=dy; } x+=dx; y+=dy; }
double perimetre(){ double perimetre(){

return 2*(largeur+longueur); } return 2*Math.PI*rayon; }
double surface(){ double surface(){

return largeur*longueur; } return Math.PI*rayon*rayon; }
} }
181
Exercice
 avec classe abstraite : on peut factoriser la méthode
deplace
Forme
Deplace( int dx, int dy)
Rectangle Cercle
182
public abstract class Forme {
int x, y;
Forme(int x, int y){
this.x = x; this.y = y;
}
void deplace( int dx, int dy){
x+=dx; y+=dy; }
abstract double perimetre();
abstract double surface(); }
public class Cercle extends Forme { public class Rectangle extends Forme{
int rayon; int largeur, longueur;
Cercle(int x, int y, int r){ Rectangle(int x, int y, int la, int lo){
super(x, y); super(x, y);
rayon = r; } largeur = la;
longueur = lo;
double perimetre(){ }
return 2*Math.PI*rayon; } double perimetre(){
return 2*(largeur+longueur); }
double surface(){
return Math.PI*rayon*rayon;}} double surface(){
return largeur*longueur; }}
183
public class Test {
public static void main(String[] args) {
Rectangle r= new Rectangle(0, 0, 10, 5);

System.out.println("xr :"+ r.x);
System.out.println("yr :"+ r.y);
r.deplace(2, 3);
System.out.println("xr après déplacement :"+ r.x);
System.out.println("yr après déplacement:"+ r.y);
System.out.println("Longueur :"+ r.longueur);
System.out.println("largeur :"+ r.largeur);
System.out.println("surface rectangle :"+ r.surface());
System.out.println("perimetre rectangle :"+ r.perimetre());
Cercle c= new Cercle(0,0,3);

System.out.println("xc :"+ c.x);
System.out.println("yc :"+ c.y);
c.deplace(2, 3);
System.out.println("xc après déplacement :"+ c.x);
System.out.println("yc après déplacement:"+ c.y);
System.out.println("Rayon :"+ c.rayon);
System.out.println("surface cercle :"+ c.surface());
System.out.println("perimetre cercle :"+ c.perimetre()); }} 184
185
Les collections
 une collection est un objet qui contient d’autres objets

exemple: un tableau est une collection.
 En java il existe 3 types de collections : les listes (List) ,

les ensembles ( Set) , et les tables associatives (MAP).
 Package: java.util
186
Les interfaces de collections
 Les interfaces de collections Java sont les suivantes :
Collection
Set
List
SortedSet HashSet
Vector ArrayList LinkedList

TreeSet
187
Les interfaces de collections
Map
SortedMap HashMap HashTable
TreeMap
188
Problème
 les tableaux ne répondent pas toujours à tous les

besoins
 quand un nombre inconnu d’objets sont à stocker…

 on pourrait créer un très grand tableau, mais
 ce n’est pas très « propre »
 ce n’est jamais assez grand !
189
Les collections
 Note :
Les collections sont dynamiques : elles prennent

en charge leur allocation mémoire
=> chaque fois qu’une allocation est pleine alors
elle augmente dynamiquement sa capacité.
190
Solution : java.util.ArrayList
 la classe java.util.ArrayList. C’est la classe la plus
utilisée
 un ArrayList se comporte comme un tableau il

contient plusieurs objets (de la classe Object
uniquement)
 ne peut contenir des types primitifs
 il accède à ses éléments à l’aide d'un index
 il grossit automatiquement
 il existe des méthodes pour ajouter ou enlever un élément
191
Création d’un ArrayList
 il est possible d’indiquer la taille initiale dans le
constructeur
 Il y a 2 constructeurs :
 ArrayList()
 ArrayList(int initialCapacity)
192
Modification d’un élément
 Il y a deux manières d’ajouter un élément
 à la fin d'un ArrayList avec la méthode
 boolean add(Object newElement)
 à une position donnée

void add(int index, Object newElement)
throws IndexOutOfBoundsException
- le paramètre index indique où insérer le nouvel
élément
- si position incorrecte, une exception est levée
193
Modification d’un élément
 pour remplacer un objet à une position donnée
Object set(int index, Object newElement)
 cette méthode fonctionne comme

void add(int index, Object newElement)
 sauf que l’élément à la position index est remplacé
194
Accès aux éléments
 pour accéder à un élément,
 il n’y a pas d’indexation comme pour les tableaux
 il faut utiliser la méthode spécialisée
Object get(int index) throws
IndexOutOfBoundsException
 exemple :
ArrayList <A> a = new ArrayList<A>();
a.get(i); // retourne l’élément d’indice i
195
Accès aux éléments
 pour tester le contenu, il existe la méthode
boolean isEmpty()
 pour connaître le nombre d’éléments dans la liste, il
faut utiliser la méthode : int size()
 exemple :
if (!a.isEmpty()) {
for (int i=0; i<a.size(); i++){
System.out.println(a.get(i)); }
}
196
Recopie d’élément
 pour recopier une liste dans un tableau, il faut utiliser
la méthode
Object[ ] toArray()
 exemple :
ArrayList a = new ArrayList();
Object[] tab = new Object[a.size()];
tab = a.toArray();
197
Recherche d’élément
 pour savoir si un objet est présent ou non dans une
liste, il faut utiliser la méthode
boolean contains(Object obj)
 pour connaître la position d’un élément dans une liste,
on peut utiliser deux méthodes
 pour avoir la première occurrence, il faut utiliser
int indexOf(Object obj)
 pour avoir la dernière occurrence, il faut utiliser
int lastIndexOf(Object obj)
198
Suppression d’élément
 Pour supprimer un élément à une position donnée, il

faut utiliser la méthode
Object remove(int index)
199
Résumé
 boolean add(Object obj)
 void add(int indice, Object obj)
 boolean contains(Object obj)
 Object get(int indice)
 int indexOf(Object obj)
 int lastIndexOf(Object obj)
 void remove(int indice)
 void set(indice, Object obj)
 int size()
200
Les principales méthodes de la classe ArrayList
l.add(e); Ajoute un élément e à la fin de la liste
l.add(i,e); Ajoute un élément e à la position i en décalant les
éléments d’indice (i+1) d’une case à droite
l.get(i); Retourne l’élément d’indice i
l.set(e,i); Remplace l’objet d’indice i par e
l.remove(e); Supprime l’élément e
l.remove(i); Supprime l’élément d’indice i
l.contains(e); True si e appartient à l
False si e n’appartient pas à l
l.size La taille de l
l.isEmpty(); True si l est vide
False si l n’est pas vide
l.clear(); Vider l
201
Note
 La classe java.util.Vector est une classe héritée de Java

Elle n'est conservée dans l'API actuelle que pour
des raisons de compatiblité ascendante et elle ne
devrait pas être utilisée dans les nouveaux
programmes.
 Dans tous les cas, il est préférable d'utiliser un

ArrayList.
202
Exemple
public class Employe { import java.util.ArrayList;
private String nom, prenom; public class Test {
private double salaire; public static void main(String [] args) {
ArrayList l = new ArrayList();
public Employe (String n, String p)
{ Employe emp1 = new Employe("Ji", "ala");
nom = n; Employe emp2 = new Employe("Pe", "San");
prenom = p; l.add(emp1);
} l.add(emp2);
public Employe (String n, String p,
double s) { if (!l.isEmpty()) {
this(n,p); for (int i = 0; i<l.size(); i++)
salaire = s; {
} System.out.println(((Employe)
public String getNom() l.get(i)).getNom());
{ }
return nom; l.remove(1); }
for (int i = 0; i<l.size(); i++)
}} {
System.out.println(((Employe)
l.get(i)).getNom()); }}}
203
La classe LinkedList
 la liaison entre les éléments se fait
grâce à deux pointeurs (un qui pointe
vers l'élément précédent et un qui
pointe vers l'élément suivant).
 Le pointeur précédent du premier
élément doit pointer vers NULL (le
début de la liste).
Le pointeur suivant du dernier élément
doit pointer vers NULL (la fin de la
liste).
 Pour accéder à un élément la liste peut
être parcourue dans les deux sens :en
commençant avec la tête, le pointeur
suivant permettant le déplacement
vers le prochain élément.
 en commençant avec la queue, le
pointeur précédent permettant le
déplacement vers l'élément précédent.
204
Les principales méthodes de la classe LinkedList
l.addFirst(e); Ajoute un élément e au début de la liste
l.addLast(e); Ajoute un élément e à la fin de la liste
l.getFirst(); Retourne le premier élément de la liste
l.removeFirst(); Supprime le premier élément de la liste
l.removeLast(); Supprime le dernier élément de la liste
l.contains(e); True si e appartient à l
False si e n’appartient pas à l
l.size La taille de l
l.isEmpty(); True si l est vide
False si l n’est pas vide
l.clear(); Vider l
205
Parcourir une liste
List<E> l;
l= new ArrayList<E> ();
 En utilisant un itérateur :
Un itérateur est un objet permettant de parcourir une
collection élément par élément.
Iterator<E> it = l.iterator();
while (it.hasNext()) {
E e = it.next();
// traitement de e
}
206
Parcourir une liste
List<E> l;
l= new ArrayList<E> ();
 Sans utiliser un itérateur :
On utilise une boucle « for »
for (E e : l)
{
// traitement de e
}
207
Les ensembles Set
 Les ensembles sont des collections qui n’acceptent pas
de répétition ( ou duplication) d’élément.
 TreeSet : des ensembles triés
 HashSet : des ensembles non triés
208
Les principales méthodes de la classe Set
ens.add(e); Ajoute un élément e à ens

ens.remove(e); Supprime l’élément e de l’ens
ens.contains(e); True si e appartient à ens
False si e n’appartient pas à ens
ens.size La taille de ens
ens.isEmpty(); True si ens est vide
False si ens n’est pas vide
ens.clear(); Vider ens
209
Exemple 1
Set<String> fruits =new TreeSet<String>();
fruits.add("orange");
fruits.add("fraise");
fruits.add("orange"); // ne sera pas ajouté
System.out.println(fruits.size()); // 2
fruits.remove("orange");
fruits.add(" banane");
Iterator<String> it = fruits.iterator();
while (it hasNext() )
{
System.out.println(it.Next());
}
210
Exemple 2
Set<String> fruits =new HashSet<String>();
fruits.add("orange");
fruits.add("fraise");
fruits.add("orange"); // ne sera pas ajouté
System.out.println(fruits.size()); // 2
fruits.remove("orange");
fruits.add("banane");
Iterator<String> it = fruits.iterator();
while (it hasNext() )
{
System.out.println(it.Next());
}
211
Les tables associatives: Map
Une carte est une collection de paires clé/valeur. L’interface
Map possède trois méthodes essentielles :
 boolean put(Object key, Object value)

//ajoute la paire key/value dans la carte. Si la clé key était déjà
présente dans la carte, l’ancienne valeur est remplacée par
la nouvelle (une clé est unique)
 Object get(Object key)

//renvoie la valeur associée à la clé key dans la carte ou null si
la clé n’a pas été trouvée dans la carte
 void remove(Object key)

//supprime la paire de la carte dont la clé est key
212
Les tables associatives: Map
L’interface Map possède trois méthodes qui permettent
de parcourir le contenu d’une carte :
 Set keySet()
//renvoie l’ensemble des clés de la carte
 Collection values()
//renvoie l’ensemble des valeurs de la carte
 Set entrySet()
//renvoie la collection des paires clé/valeur de la carte
213
Les principales méthodes de la classe Map
Map<K,V> m = new HashMap<K,V>();
m.Put(key,value); Ajoute l’association (key,value) à m

m.containsKey(key); boolean
m.containsValue(value); boolean
m.keys(); Ensemble des clés
m.values(); Ensemble des valeurs
Set<K> ens= m.keys(); création d’un ensemble de key
Set<V> liste = m.values(); Création d’une liste de value
214
Remarque
 Les collections en java permettent de socker seulement
des objets et non des valeurs primitives, on utilise des
classes enveloppes ( Wapper class)
int Integer
float Float
double Double
boolean Boolean
byte Byte
char Character
long Long
short Short
215
Exemple
Map<String,Integer> scores = new HashMap<String,Integer>();
scores.put("Mohammed", new Integer(3));// autoboxing

scores.put("Amina", new Integer(9));
Integer s =scores.get("Mohammed");
System.out.println("score moha"+ s.intValue());
Set<String> joueurs = scores.Keys();

For ( String j : joueurs )
System.out.println(j);
216
Remarque
 L’autoboxing est la transformation automatique d’une

valeur primitive en un objet d’une classe enveloppe.
217
Exercice 1
 Ecrire une classe Pile permettant de gérer des piles
d’entiers . Avec condition que le dernier élément
empiler soit le premier élément dépiler (LIFO : Last in
First out).
218
Correction
import java.util.*; public int sommet(){
int s = (l.getFirst()).intValue();
public class Pile { return s;
}
private LinkedList<Integer> l; public int taille(){
return l.size();
public Pile() { }
l = new LinkedList<Integer>(); public void affiche(){
} for (Integer e : l)
public void empiler(int x){ System.out.println(e); }}
l.add(x);
}
public int depiler(){
int s = (l.getLast()).intValue();
l.removeLast();
return s;
}
219
Correction
public class Test {
Pile p1,p2;
p1 = new Pile();
p2 = new Pile();
p1.empiler(1);
p1.empiler(4);
p1.empiler(13);
System.out.println("p1:");p1.affiche();
while (p1.taille()!= 0)
p2.empiler(p1.depiler());
System.out.println("p2:");p2.affiche();
}}
220
Exercice 2
 Ecrire une classe Ensemble permettant de gérer les
ensembles d’entiers avec les méthodes suivantes :
 Soit A = {1,2, 3,5} ; et B = {2,4,3,6} ;
 Inclus : {2, 3} є {2,4,3,6}
 Intersection: {1,2, 3,5} ∩ {2,4,3,6} = {2,3,4}
 Union : {1,2, 3,5} ∪ {2,4,3,6} = {1,2,4,5}
 Différence : {1,2, 3,5} \ {2,4,3,6} ={ 1,5}
 Différence : {2,4,3,6} \ {1,2, 3,5} = {4,6}
221
Correction
import java.util.*; public Ensemble Intersection
public class Ensemble { (Ensemble E){
private HashSet<Integer> ens; Ensemble I = new Ensemble();
public Ensemble(){ for ( Integer e : this.ens)
ens = new HashSet<Integer>(); if (E.ens.contains(e))
} I.ens.add(e);
public boolean Inclus (Ensemble E){ return I;}
for ( Integer e : this.ens) public Ensemble Union (Ensemble
if (!E.ens.contains(e)) return false; E){
else return true; Ensemble U = new Ensemble();
return true; for (Integer e : this.ens) U.ens.add(e);
} for (Integer e: E.ens) U.ens.add(e);
public void ajouter(int x){ return U;
this.ens.add(x); }
} public Ensemble difference
public void afficher(){ (Ensemble E){
System.out.print("{"); Ensemble D = new Ensemble();
for ( Integer e : this.ens) for ( Integer e : this.ens)
System.out.print(e);System.out.print("}"); if (!E.ens.contains(e)) D.ens.add(e);
System.out.println(); } return D;}}
222
Correction
public class Test {
Ensemble A,B;
A = new Ensemble();
B= new Ensemble();
A.ajouter(1);
A.ajouter(2);
A.ajouter(3);
A.ajouter(5);
B.ajouter(2);
B.ajouter(4);
B.ajouter(3);
B.ajouter(6);
System.out.print("l'ensemble A =" ); A.afficher();
System.out.print("l'ensemble B =" );B.afficher();
System.out.print("Intersection de A et B : ");A.Intersection(B).afficher();
System.out.print("Union de A et B : ");A.Union(B).afficher();
System.out.print("A - B : ");A.difference(B).afficher();
System.out.print("B - A : ");B.difference(A).afficher(); }}
223
Exercice3
1) Ecrire une classe Client (int idClient, String nom, String
ville) avec les méthodes suivantes :
 Constructeur par défaut ( sans argument)
 Setters + Getters
2) Ecrire une classe GestionCli (ArrayList<Client>)

permettant de gérer un ensemble de clients avec au
moins les méthodes suivantes :
 ajouterClient
 supprimerClient
 supprimerById
 findById
 findByName
3) Ecrire une classe principale de Test
224
Correction
public void setVille(String ville) {
public class Client { this.ville = ville;
public int idCli; }
public String nom;
public String ville; public void setIdCli(int idCli) {
public Client(){} this.idCli = idCli;
public String getNom() { }

return nom; public int getIdCli() {
} return idCli;
public void setNom(String nom) { }
this.nom = nom;
} @Override
public String getVille() { public String toString() {
return ville; return "Client [idCli=" + idCli + ",
} nom=" + nom + ", ville=" + ville + "]";
}}
225
import java.util.*; public ArrayList<Client> findByNom (
public class GestionCli { String nom){
private ArrayList<Client> cli ; ArrayList<Client> l = new
public GestionCli(){ ArrayList<Client>();
cli = new ArrayList<Client>(); } for ( Client c : this.cli)
public void ajouterCli (Client c){ if (c.getNom().equals(nom))
this.cli.add(c); { l.add(c); System.out.println(l); }
} return l; }
public void afficher(){ public Client supprimerClient ( Client c)
System.out.println(this.cli); { Client cl = new Client();
} for ( int i= 0; i<cli.size();i++)
public Client findById (int id){ if (this.cli.get(i).equals(c))
Client c = new Client(); cl=this.cli.get(i);
for ( int i=0;i<cli.size();i++) this.cli.remove(cl);
if (cli.get(i).getIdCli()==id) return cl; }
{ public void supprimerById(int id){
c= this.cli.get(i); System.out.print("a supprimer : ");Client
System.out.println(c); c=findById(id);
} return c; } if(c!=null){this.cli.remove(c);}
else System.out.println("identifiant
inexistant");}}
226
Correction
public class Test {
GestionCli g = new GestionCli();
Client a = new Client(1, "Sara", "tanger");
Client b= new Client(2, "fati", "Rabat");
g.ajouterCli(a);
g.ajouterCli(b);
g.afficher();
g.findById(1);
g.afficher();
g.findByNom("fati");
g.supprimerById(2);
g.afficher();
g.supprimerClient(b);
g.afficher();
}}
227
228
Généralités
 la sécurité d'une application peut être rendue instable
par toute une série de facteurs :
 Des problèmes liés au matériel : par exemple la perte
subite d'une connexion à un port, un disque
défectueux...
 Des actions imprévues de l'utilisateur, entrainant par
exemple une division par zéro...
 Des débordements de stockage dans les structures de
données...
229
Généralité
 Toutefois les faiblesses dans un logiciel pendant son
exécution, peuvent survenir :
 lors de calculs mathématiques interdits (comme la
division par zéro),
 lors de fausses manœuvres de la part de l’utilisateur,
 lorsque la connexion à un périphérique est inopinément
interrompue,
 lors d'actions sur les données.
=> Le logiciel doit donc se " défendre " contre de tels

incidents potentiels, nous nommerons cette démarche
la programmation défensive !
230
Programmation défensive
 La programmation défensive est une attitude de pensée
consistant à :
 prévoir que le logiciel sera soumis à des défaillances dues à
certains paramètres externes ou internes
 et donc à prévoir une réponse adaptée à chaque type de
situation.
 En programmation défensive il est possible de
 protéger directement le code à l’aide de la notion d’exception.
 L’objectif principal est d’améliorer la qualité "la robustesse "
d’un logiciel.
=>L’utilisation des exceptions avec leur mécanisme intégré,

autorise la construction rapide et efficace de logiciels
robustes.
231
Rôle d’une exception
 Une exception est chargée de signaler un
comportement exceptionnel (mais prévu) d’une
partie spécifique d’un logiciel.
 Dans les langages de programmation actuels, les

exceptions font partie du langage lui-même.
 C’est le cas de Java qui intègre les exceptions comme

une classe particulière : la classe Exception.
 Cette classe contient un nombre important de classes

dérivées.
232
Comment agit une exception
 Dès qu’une erreur se produit comme un manque de
mémoire , un calcul impossible, un fichier inexistant,
un transtypage non valide,...,
 un objet de la classe adéquate dérivée de la

classe Exception est instancié. Nous dirons que le
logiciel " déclenche une exception ".
233
Principe des exceptions
 Principe fondamental = séparer la détection et le
traitement des anomalies :
- signaler tout problème dès sa détection.
- mais regrouper le traitement des problèmes ailleurs, en
fonction de leur type
 Plutôt que de compliquer le code du traitement
normal, on traite les conditions anormales à part
 Le traitement « normal » apparaît ainsi plus simple et
plus lisible
234
Gestion des erreurs sans utiliser le
mécanisme des exceptions
 Considérons l’exemple de la classe point qui a:
- un constructeur a deux arguments qui permet de
positionner le point dans le plan.
 Le programme doit s’arrêter si au moins une des

coordonnées du point est négatif.
235
Exemple 1
public class Point { public class TestException {
private int x, y; public static void main(String[] argv) {
public Point(int x, int y) { int i=3;
if ((x < 0) || (y < 0)) { // Détection de // début du bloc susceptible de générer
l’erreur (l’Exception) une exception
System.out.println("Erreur de Point a = new Point(6,1);
Construction"); /* traitement Point b = new Point(3, 4);
en cas d’erreur (traitement de // Fin du bloc susceptible de générer
l’exception) */ une exception
System.exit(-1); System.out.println (" Exécution bien
} passée i= "+i);
else { this.x = x ; this.y = y; // }
traitement normal } }
} }
Sortie du programme:
Exécution bien passée i=3
//Les appels de Point(6,1) et Point(3,4) n’ont généré aucune exception

236
Exemple 2
public class Point { public class TestException {
private int x, y; public static void main(String[] argv) {
public Point(int x, int y) { int i=3;
if ((x < 0) || (y < 0)) { // Détection de // début du bloc susceptible de générer une
l’erreur (l’Exception) exception
System.out.println("Erreur de Point a = new Point(6,1);
Construction"); /* traitement Point b = new Point(-2, 4);
en cas d’erreur (traitement de // Fin du bloc susceptible de générer une
l’exception) */ exception
System.exit(-1); System.out.println (" Exécution bien passée
} i= "+i);
else { this.x = x ; this.y = y; /* }
traitement normal */ }} } }
Sortie du programme:
Erreur de Construction
//L’appel de Point(6,1) n’a pas généré d’exception, donc il a été exécuté normalement.
Par contre l’appel de Point(-2,4) a généré une exception et a provoqué l’arrêt
du programme (appel de System.exit(-1);). Par conséquent l’instruction
System.out.printl() dans TestException n’a pas été exécutée.
237
Gestion des erreurs en utilisant le mécanisme des
exceptions
 Dans l’exemple précédent, la détection de l’exception
et son traitement ne sont pas séparés.
 Java permet de séparer la détection de l’exception de
son traitement :
– Plutôt que de compliquer le code du traitement
normal, on traite les conditions anormales à part
– Le traitement « normal » apparaît ainsi plus simple et
plus lisible
– Le traitement des exceptions (erreurs) s’effectue dans
une zone du programme spéciale (bloc « catch »)
238
Pratiquement
 Le code dans lequel une exception peut se produire est
mis dans un bloc try,
try {
// Code dans lequel une exception peut se produire
}
 La gestion des exceptions est obtenue par des blocs
catch, où chaque bloc catch est associé à une exception
donnée.
239
Attention
 Le bloc catch doit être juste après le bloc try, sinon
erreur de compilation.
catch ( Type1Exception e) {
// de type Type1Exception qui hérite de Exception
/* code de la gestion des exceptions */
}
catch ( Type2Exception e) {
// de type Type2Exception qui hérite de Exception
/* code de la gestion des exceptions */
}
240
Explication
 Lorsqu’une exception se produit dans le bloc try, alors :
– un saut est effectué vers un bloc (s) catch

– les blocs catch sont vérifiés un après l ’autre jusqu’à ce
qu’on trouve un bloc correspondant à l ’exception
– le code du bloc catch est exécuté
241
Test1
public class Test { Sortie du programme:
public static void main(String[] argv) { Erreur de Construction
try { // dans ce bloc une exception
peut se produire
Point b = new Point(-2, 4); L’appel de Point(-2,4); génère une
Point a = new Point(6, 1); exception, donc un saut est effectué vers
} le bloc catch().
catch (ErrConst e) { // Erreur de type L’exécution du code du bloc catch() a
ErrConst qui hérite de Exception provoqué l’arrêt du programme (appel
// dans ce bloc on traite les exceptions de System.exit(-1);),
System.out.println("Erreur de par conséquent l’appel de Point(6,1) et
Construction"); les instructions après le bloc try {} n’ont
System.exit(-1); pas été exécutées.
}
System.out.println(" Excution bien
passée"); }}
242
Test2
public class Test { Sortie du programme:
public static void main(String[] argv) { Exécution bien passée
try {
Point a = new Point(9, 5);
Point b = new Point(3, 7); Les appels de Point(9,5) et Point(3,7)
} n’ont pas généré d’exceptions donc le
catch (ErrConst e) { // Erreur de type code
ErrConst qui hérite de Exception du bloc catch() { } n’a pas été exécuté
System.out.println("Erreur de par conséquent l’exécution est allée
Construction"); au-delà du bloc try.
System.exit(-1);
}
System.out.println(" Exécution bien
passée");
}
}
243
Lancement (déclenchement) d’une exception
 Une méthode déclare qu’elle peut générer une

exception par le mot clé throws.
 Ensuite la méthode lance une exception, en créant une

nouvelle valeur (un objet) d’exception en utilisant le
mot clé throw
244
Exemple
public void Point (int x, int y) throws ErrConst {

// Déclare que le constructeur Point() peut générer une exception
if ((x <0) || (y<0)) throw new ErrConst();
// Détection de l’exception et Création d’une nouvelle valeur d’exception
this.x = x ; this.y = y; // traitement normal
}
ErrConst est une classe qui hérite de la classe Exception. Elle peut être définie de
la manière suivante:
class ErrConst extends Exception { }
245
Un Premier exemple complet
class ErrConst extends Exception {}
class Point {
private int x, y;
public Point(int x, int y) throws ErrConst {// déclare une exception
if ((x < 0) || (y < 0)) throw new ErrConst(); // déclenche une exception
this.x = x ; this.y = y; // traitement normal
}}
public class Test {

public static void main(String[] argv) {
try{
Point b = new Point(-2, 4);
}
catch (ErrConst e) { // Erreur de type ErrConst qui hérite de Exception
System.out.println("Erreur de Construction");
System.exit(-1);
}}}
246
Un Deuxième exemple complet
 Supposons maintenant que la classe Point possède une
méthode déplace() et que le point doit rester dans le
plan positif.
 Dans ce cas, le constructeur Point() et la méthode

deplace() doivent déclencher une exception.
247
class ErrConst extends Exception {}

class ErrDepl extends Exception {}
class Point {
private int x, y;
public Point(int x, int y) throws ErrConst { // déclare une excéption
if ((x < 0) || (y < 0)) throw new ErrConst(); // déclenche une exception
this.x = x ; this.y = y; }
public void deplace (int dx, int dy) throws ErrDepl{
if ((x+dx < 0) || (y+dy < 0)) throw new ErrDepl();
x = x+dx ; y = y+dy; }
}
248
public class Test {
try {
Point a = new Point(1,4);
a.deplace(0,1);
Point b = new Point(7, 4);
b.deplace(3,-5);
}
catch (ErrConst e) {
System.exit(-1);
}
catch (ErrDepl ed) {
System.out.println("Erreur de Déplacement");
System.exit(-1); }
}}
Sortie :
Erreur de Déplacement
249
Bloc : finally
 c’est une instruction optionnelle qui est exécutée
quelle que soit le résultat du bloc try (c’est à dire qu’il
ait déclenché ou non une exception)
 Il permet de spécifier du code dont l’exécution est
garantie quoi qu’il arrive.
 Exemple:
try { . . . }
catch (…) { . . . }
finally { . . . }
250
Exemple
public class TestFinally {
try {
Point b = new Point(-2, 4);
}
catch (ErrConst e) { // Erreur de type ErrConst qui hérite de Exception
} finally {
System.out.println("Fin du Programme");
}}}
Affichage:
Fin du Programme
// Dans toutes les exécutions (déclenchement ou non d’exception), les

instructions du bloc finally seront exécutées.
251
Constructeurs des exceptions
 La création d'exception personnalisée peut être
réalisée en rajoutant des constructeurs et des membres
supplémentaires.
 Par convention, toutes les exceptions doivent avoir au

moins 2 constructeurs :
– un sans paramètre
– un autre dont le paramètre est une chaîne de
caractères utilisée pour décrire le problème
252
Méthodes de la classe Throwable
 getMessage() : retourne le message d’erreur décrivant
l’exception
 printStackTrace() affiche sur la sortie standard la

liste des appels de méthodes ayant conduit à
l’exception
 Exception(): constructeur sans argument
 Exception(String): Constructeur avec Argument
253
définir un constructeur personnalisé qui a
pour argument une chaîne de caractères:
class ErrConst extends Exception {
public ErrConst() {} public class TestException {
public ErrConst(String msg) {
super(msg); public static void main(String[]
}} argv) {
class Point { try {
private int x, y; Point a = new Point(6, 1);
public Point(int x, int y) throws ErrConst Point b = new Point(-2, 4);
{ }
if ((x < 0) || (y < 0)) throw new catch (ErrConst e) {
ErrConst(" Erreur aux points x=" +x+" et System.out.println(e.getMessage());
y=" +y); System.exit(-1);
this.x = x ; this.y = y; }
} }
} }
Sortie:
Erreur au point x= -2 et y=4
254
définir un constructeur personnalisé qui a 2
arguments de type int
Sortie:
255
class ErrConst extends Exception { public class TestException {
private int x,y; public static void main(String[] argv)
public ErrConst(int a , int b) { {
x=a; try {
y=b; } Point a = new Point(6, 1);
public int getX() { Point b = new Point(-2, 4);
return x; } }
public int getY() { catch (ErrConst e) {
return y; System.out.println("x="+ e.getX()+" et
}} "+"y="+e.getY());
class Point { System.exit(-1);
private int x, y; }
public Point(int x, int y) throws }
ErrConst { }
if ((x < 0) || (y < 0))
throw new ErrConst(x, y){};
this.x = x ; this.y = y; }}
Sortie:
256
Méthode printStackTrace():
class ErrConst extends Exception{} public class ExceptionTestStack {
class Point { public static void main(String[] argv) {
private int x, y; try {
public Point(int x, int y) throws Point a = new Point(6, 1);
ErrConst { Point b = new Point(-2, 4);
if ((x < 0) || (y < 0)) throw new }
ErrConst(); catch (ErrConst e) { // Erreur de type
this.x = x ; this.y = y; ErrConst qui hérite de Exception
} System.out.println("Erreur de
} Construction");
e.printStackTrace();
System.exit(-1); }
}}
Sortie du Programme:
ErrConst
at Point.<init>(Point.java:7)
at TestException.main(TestException.java:6)
257
Les classes d’erreurs/exceptions
 La classe java.lang.Throwable (classe fille de
Object) est la superclasse de toutes les erreurs et
exceptions rencontrées dans le langage de
programation Java.
 Java.lang est un package qui rassemble les classes de

base de Java. Toutes les classes et interfaces de
java.lang sont automatiquement importées par le
compilateur.
258
Arbre d’héritage des exceptions
Throwable
Error Exception
RuntimeException IOException
Exceptions implicites Exceptions explicites

259
 Les exceptions standard se classent en deux catégories:
 les exceptions explicites : qui correspondent aux

exceptions que nous venons d’étudier : une méthode
susceptible de lever une exception explicite doit soit la
traiter, soit la propager en la déclarant dans son en-tête
avec le mot clé throws ;
 les exceptions implicites : une méthode susceptible
de lever une exception implicite peut la traiter, mais
elle n’est pas obligée de la déclarer dans son en-tête
avec le mot clé throws.
260
Quelques sous-classes de RuntimeException
(Exceptions implicites)
 NullPointerException: Tentative d'utiliser une référence
null
 ClassCastException : Tentative de cast d'un objet dans
un type incorrecte.
 IndexOutOfBoundsException : Un indice (sur un
tableau, une chaîne) ou un intervalle défini par deux
indices ont dépassé les limites inférieures ou supérieures.
Ses sous-classes :
 ArrayIndexOutOfBoundsException, pour les tableaux
(indice négatif ou supérieur ou égal à la taille du tableau).
 StringIndexOutOfBoundsException, pour les chaînes de
caractères.
261
Quelques sous-classes de RuntimeException
(Exceptions non contrôlées par le compilateur)
 ArrayStoreException : Tentative de stocker dans un tableau
un élément qui n'est pas du type des éléments du tableau ou
castable dans ce type.
 ArithmeticException: Une exception est survenue sur une
opération arithmétique, comme une division d'un entier par
zéro. )
 NegativeArraySizeException : Tentative de créer un tableau
ou une chaîne avec une taille négative.
 IllegalArgumentException : Une méthode a été appelée avec
un mauvais argument ou invoquée sur un mauvais objet. Sa
sous-classe NumberFormatException
 NumberFormatException : Tentative de convertir dans un type
numérique une chaîne de caractères mal formatée.
262
263
Les éléments d’interface
 Il y a deux types d’éléments dans une interface, des
conteneurs (containers) et des composants (components).
 Les conteneurs , sont susceptibles de contenir des éléments,
ils constituent la base de l’interface (Panel, Frame,
Window...).
 Les composants sont ajoutés à un conteneur, il s’agit de
boutons, cases à cocher, ..(Button, Checkbox, Scrollbar, ...).
 En plus de ces éléments, le paquetage java.awt fournit des

gestionnaires de mise en page (FlowLayout, BorderLayout),
 la classe Event qui permet de détecter tous les événements

externes (entrées clavier, clic de souris, ...), des exceptions.
264
La petite interface
import javax.swing.JFrame;
public class LaPlusPetite {
public static void main(String[ ] args) {
JFrame cadre = new JFrame("La plus petite interface");
cadre.setSize(300, 200);
cadre.setVisible(true);
}
}
La case de fermeture
ne fonctionne pas
265
La petite interface qui se ferme
import javax.swing.JFrame;
public static void main(String[ ] args) {
cadre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}}
fonctionne
266
La petite interface avec un message
import javax.swing.*;
cadre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JLabel etiquette = new JLabel("Bonjour et bienvenue !");
cadre.getContentPane().add(etiquette);
}}
fonctionne
267
Structuration, hériter de JFrame
La personnalisation
public class Simplette extends JFrame {
se fait dans le
public Simplette() { constructeur
super("Une interface simplette...");
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(300, 200);
JLabel etiquette = new JLabel("Simplette, mais bien structuree...");
this.getContentPane().add(etiquette);
}
public static void main(String[] args) { Où bien là :
JFrame cadre = new Simplette(); this.setVisible(true);
}
}
268
Exemple, actions sur des boutons
import java.awt.*;
public class Simplette extends JFrame {
public Simplette() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); On ajoute des
setSize(300, 100); boutons
JLabel etiquette = new JLabel("Ca va?");
JButton boutonOui = new JButton("Oui");
JButton boutonNon = new JButton("Non");
getContentPane().setLayout(new FlowLayout());
getContentPane().add(etiquette);
getContentPane().add(boutonOui);
getContentPane().add(boutonNon);
}
JFrame cadre = new Simplette();
}} 269
Exemple, actions sur des boutons
import java.awt.*;
public class Simplette2 extends JFrame {
public Simplette2() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); On ajoute des
setSize(300, 100); boutons
JLabel etiquette = new JLabel("Quelle couleur ??");
JButton boutonVert = new JButton("Vert");
JButton boutonRouge = new JButton("Rouge");
getContentPane().add(boutonVert);
getContentPane().add(boutonRouge);
}
JFrame cadre = new Simplette2();
}} 270
Les événements et leur gestion
271
Contrôleur d’événement
 Le rôle des contrôleurs est d’intercepter certains
événements et d’effectuer un traitement associé au
type de l’événement.
 Un événement peut être produit par un click sur un

bouton, la sélection d’un élément d’une liste, un
déplacement de souris, la pression d’une touche du
clavier,
272
Evénement
 Un événement graphique est représenté dans le
langage Java comme un objet dont la classe hérite de
java.awt.event.
ActionEvent : Se produit lorsqu’une action est effectuée sur un composant.
Ex : click sur un bouton.
ItemEvent : Se produit lorsqu’une sélection a été effectuée sur un
composant. Ex : cochage d’une case.
KeyEvent : Se produit lorsque un événement provient du clavier.
Ex : pression d’une touche.
MouseEvent : Se produit lorsque un événement provient de la souris.
Ex : déplacement de la souris.
WindowEvent : Se produit lorsqu’une action est effectuée sur une fenêtre.
Ex : click sur l’icone de fermeture d’une fenêtre.
273
Interface Listener
 Le contrôleur qui intercepte un certain type
d’événement doit implémenter une des interfaces
héritant de java.util.EventListener.
 L’interface à implémenter dépend du type

d’événement à intercepter. La table suivante présente
les interfaces correspondant aux événements décrits
ci-dessus.
274
Quelques interfaces pour contrôleur
Contrôleur Evénement Méthodes à implémenter
ActionListener ActionEvent actionPerformed(ActionEvent)
ItemListener ItemEvent - itemStateChanged(ItemEvent)
KeyListener KeyEvent - keyPressed(KeyEvent)
- keyReleased(KeyEvent)
- keyTyped(KeyEvent)
MouseListener MouseEvent - mouseClicked(MouseEvent)
- mouseEntered(MouseEvent)
- mouseExited(MouseEvent)
- mousePressed(MouseEvent)
- mouseReleased(MouseEvent)
WindowListener WindowEvent - windowActivated(WindowEvent)
- windowClosed(WindowEvent)
- windowClosing(WindowEvent)
- windowDeactivated(WindowEvent)
- windowDeiconified(WindowEvent)
- windowIconified(WindowEvent)
- windowOpened(WindowEvent
275
import javax.swing.*; import java.awt.*; import java.awt.event.*;
public class Simplette1 extends JFrame implements ActionListener{
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); On définit un
setSize(300, 100); auditeur
boutonVert.addActionListener(this);
boutonRouge.addActionListener(this);
getContentPane().add(boutonVert);
getContentPane().add(boutonRouge);
}
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("Vert"))
getContentPane().setBackground(Color.GREEN);
else
getContentPane().setBackground(Color.RED);
}
JFrame cadre = new Simplette1();
276
cadre.setVisible(true); }}
import javax.swing.*; import java.awt.*; import java.awt.event.*;
public class Simplette1 extends JFrame implements ActionListener{
JPanel panneau;
On définit un
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(300, 100); auditeur
panneau=new JPanel();
boutonVert.addActionListener(this);
boutonRouge.addActionListener(this);
panneau.add(etiquette);
panneau.add(boutonVert);
panneau.add(boutonRouge);
this.setContentPane(panneau);
}
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("Vert"))
panneau.setBackground(Color.GREEN);
else
panneau.setBackground(Color.RED);}
277
JFrame cadre = new Simplette1(); cadre.setVisible(true); }}
Les gestionnaires de disposition
 le FlowLayout choisi par défaut pour les Applet et Panel,
place les composants de gauche à droite et de haut en bas,
setLayout(new FlowLayout()) indique que le conteneur
courant utilise un gestionnaire FlowLayout, et add(nom du
composant) indique que l’on rajoute le composant cité,
 le BorderLayout est choisi par défaut pour les Window,

Dialog et Frame et dispose les composants selon 5 attributs
(North, South, West, East et Center).
add() a 2 paramètres : la position et le composant à rajouter,
278
Les gestionnaires de disposition
 le GridLayout met chaque composant sur une case
d’une grille dont on donne la dimension à la création
du gestionnaire. Cela se passe de la même manière que
pour un FlowLayout, mais les composants disposent
d’un espace de taille identique,
 CardLayout permet de gérer des panneaux comme

des cartes, une seule étant visible à la fois,
 GridBagLayout est le plus flexible et le plus

compliqué des gestionnaires !..
279
FlowLayout());
import java.awt.*;
class Disposition1 extends JFrame {
Disposition1() {
setSize(250, 150);
for (int i = 1; i <= 5; i++)
getContentPane().add(new JButton("Bouton " + i));
setVisible(true);
}
new Disposition1();
}
}
280
FlowLayout());
import java.awt.*;

Disposition1() {
setSize(350, 150);
for (int i = 1; i <= 5; i++)
setVisible(true);
}
new Disposition1();
}
}
281
BorderLayout()
import java.awt.*;

Disposition1() {
JPanel p = new JPanel(new BorderLayout());
p.add(new JButton("Bouton 1"), BorderLayout.NORTH);
p.add(new JButton("Bouton 2"), BorderLayout.EAST);
p.add(new JButton("Bouton 3"), BorderLayout.SOUTH);
p.add(new JButton("Bouton 4"), BorderLayout.WEST);
p.add(new JButton("Bouton 5"), BorderLayout.CENTER);
this.setContentPane(p);
this.setSize(450, 200);
this.setVisible(true);
}
new Disposition1();
}} 282
GridLayout(Ligne, Cologne));
import java.awt.*;

Disposition1() {
setSize(250, 150);
getContentPane().setLayout(new GridLayout(3, 2));
for (int i = 1; i <= 5; i++)
setVisible(true);
}
new Disposition1();
}
}
283
liste de choix ( Jlist() )
import javax.swing.*; import java.awt.*; import javax.swing.event.*;
public class FenetreListeNoms extends JFrame implements
ListSelectionListener {
JList liste = new JList();
JLabel etiquette = new JLabel(" ");
public FenetreListeNoms() {
String choix[] = {" Janvier", " Fevrier", " Mars", " Avril", " Mai"};
liste = new JList(choix);
liste.addListSelectionListener(this);
add(etiquette, BorderLayout.WEST);
add(liste, BorderLayout.EAST);
pack();
setVisible(true); }
public void valueChanged(ListSelectionEvent evt) {
etiquette.setText((String)liste.getSelectedValue());
}}
class EssaiFenetreNoms {
public static void main(String[] arg) {
284
new FenetreListeNoms(); }}
Message d’avertissement
import java.awt.event.*;
import java.awt.*;
public class Dialogue1 extends JFrame implements ActionListener {
JButton bouton = new JButton("Voir avertissement");
public Dialogue1() {
add(bouton, BorderLayout.NORTH);
bouton.addActionListener(this);
setLocation(100, 100);
pack();
setVisible(true);}
public void actionPerformed(ActionEvent evt) {
JOptionPane.showMessageDialog(this, "Ce n'est qu'un simple message",
"avertissement", JOptionPane.WARNING_MESSAGE);
}}
class EssaiDialogue1 {
public static void main(String[] arg) {
new Dialogue1(); }}
285
Conseille
 Toujours consulter :
http://docs.oracle.com/javase/6/docs/api/
286
287

Cours-Programmation Orienté Objet Java

Transféré par

Informations du document

Titre original

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

Cours-Programmation Orienté Objet Java

Transféré par

Droits d'auteur :

Formats disponibles

Licence 2- Réseau Télécom

Langages Bas niveau Langage de plus Langages de

 Pour exécuter, Sun fournit le programme java qui

public class Bonjour

 Un nom d’attribut doit commencer par une minuscule.

 Une constante s’écrit en majuscules.

 Sur plusieurs lignes

 Sur une seule ligne

La déclaration et l’initialisation d’une variable peut se faire sur plusieurs lignes.

Ex: String chaine;

Les types numériques entiers

byte short int long

Les types numériques flottants

 Permet de gérer les caractères. Ex: char unChar = ‘A’;

Le type chaîne de caractères

 Une chaîne est placée entre doubles quottes.

Ex: String chaine = " Bonjour ";

Opérateur Signification Opérateur Signification

x <= y Inférieur ou égal x|y OU binaire

x == y Egalité x && y ET logique

implicites  pas de perte d’information

explicites  passage d’un type donné vers un autre

for (initialisation; condition; modification)

Les branchements conditionnels

Public La classe est accessible partout.

Private La classe n’est accessible que du fichier où elle a été définie.

Abstract La classe contient des méthodes abstraites. Elle ne peut pas

public Static void main(String[] args){

Le nom est Alaoui, le prénom est Aymen et l’âge est 25 ans.

public class Personne {

 Accès public : Les membres d’une classe C, définies avec

 Accès private :Les membres d’une classe C, définies

 les constructeurs qui permettent d'initialiser les

 les méthodes d'accès qui fournissent des informations

 les méthodes d'altération qui modifient l'état d'un

modificateur_d'accès type_de_retour nom_méthode

 les variables de type primitif (chapitre précédent)

 les variables de type classe.

 L’emplacement mémoire d’une variable de type

 L’emplacement mémoire d’une variable de type classe

//Les variables p1 et p2 désignent le même objet.

 déclarer une variable de type C qui réserve un

 appeler l’opérateur unaire new qui permet d’allouer un

//création d’un objet de type Personne référencé par p1

 On notera que les champs d'un objet peuvent être soit de

entier (byte, short, int, long) 0

// En règle générale, il est préférable d’effectuer les

// En règle générale, il est préférable d’effectuer les

Personne p1 = new Personne("Sarah") ;

//Création d’un objet de type Personne référencé par p1.

 Java fournit un constructeur par défaut.

 Le constructeur par défaut est sans arguments et initialise

 Dès qu’une classe possède au moins un constructeur, le

//On pourra écrire :

 Encapsulation est l'enveloppement des attributs et

 Le contrôle d'accès aux membres de l’objet : Les

 Accessibles pour l’extérieur par des méthodes

 Plusieurs niveaux de visibilité peuvent être définis en

 public: accès depuis l’extérieur (par une classe

 Accès par défaut: lorsqu’aucun de ces spécificateurs

Classe La classe peut être

=>Pour afficher la valeur de l’attribut nom (champs

=>Pour modifier la valeur de l’attribut nom (champs