Chapitre 1 POO

10/4/2022
POO: Programmation-Orientée Objet

(en Java)
(2L-BI)
Hamdi Hassen
Université de sousse
Institut Supérieur de Gestion (ISG)
Hamdi Hassen,
hhassen2006@yahoo.fr
1
Plan du cours
Chapitre I. Introduction et Eléments de Base III.1. L’Héritage (Généralisation-Spécialisation, Mise en oeuvre
du Langage Java dans Java, Redéfinition de méthodes, Masquage d’attributs,
Introduction: Compatibilité de types par défaut dans l’héritage, Super classe
Programmation procédurale VS programmation OO Object, Classes et Méthodes finales)
Programmation objet pourquoi? Comment? Un exemple en Java III.2. Le Polymorphisme
I.1. Présentation Générale du langage (Spécificités, Byte code III.3. Les Classes Abstraites
et Machine virtuelle Java, JDK) Chapitre IV. Les Interfaces
I.2. Syntaxe de Base du Langage (Types de Données IV.1. Principe, Déclaration et Implémentation, Méthodes par défaut
élémentaires, Opérateurs, Instructions simples, Structures de IV.2. Utilisation des interfaces
Contrôle, Structure d’un programme, Appel de méthodes et IV.3. Interfaces et Héritage Multiple
transmission de paramètres, notion de package)
I.3. Tableaux et Chaînes de Caractères
Chapitre V. Collections d’Objets
V.1. Principe et Utilisation de Collections (Listes, Files, Ensembles,
Chapitre II. Classes et Objets Tableaux associatifs)
II.1. Concepts de base de la POO (Objet, Classe, Abstraction, V.2. Collections typées (Types génériques)
Encapsulation,
Composition)
Chapitre VI. La Gestion des Exceptions
VI.1. Types et hiérarchie d’Exceptions
II.2. Définition de Classes (Membres, Modificateurs d’accès)
VI.2. Le Gestionnaire d’Exceptions try-catch
II.3. Référence, Création, Manipulation et Destruction d’Objets
VI.3. Propagation d’exceptions (throws)
II.4. Constructeurs et surcharge de Constructeurs
VI.4. Cas des exceptions non prédéfinies
II.5. Surcharge de Méthodes
II.6. Propriétés Statiques d’une classe Chapitre VII. Interface Graphique Utilisateur
Chapitre III. Héritage, Polymorphisme et Classes Abstraites VII.1. Eléments d’une interface graphique (Swing)
VII.2. La Gestion des évènements
VII.3. Génération d’interfaces graphiques à l’aide d’un assistant
graphique 2
1
10/4/2022
Chapitre I. Introduction et Eléments de Base

du Langage Java
A) Programmation
procédurale VS
programmation OO
2
10/4/2022
A) Programmation procédurale VS programmation OO
C’est quoi la programmation procédurale?
Dans la programmation procédurale le programme est divisé

en petites parties appelées procédures ou fonctions. Comme son
nom l’indique, la programmation procédurale contient une
procédure étape par étape à exécuter. Ici, les problèmes sont
décomposés en petites parties et ensuite, pour résoudre chaque 5
partie, une ou plusieurs fonctions sont utilisées.
C’est quoi la Programmation Orientée Objet (POO)?
Dans la programmation orientée objet le programme est divisé

en parties appelées objets.
La programmation orientée objet est un concept de programmation
qui se concentre sur l’objet plutôt que sur les actions et les données
6
plutôt que sur la logique.
3
10/4/2022
Table de comparison
Programmation Orientée Objet
Programmation Procédurale
Le programme principal est divisé en Le programme principal est divisé en
Programmes
petites parties selon les fonctions. petit objet en fonction du problème.
Les données et les fonctions de chaque
Chaque fonction contient des données
Les données objet individuel agissent comme une
différentes.
seule unité.
Pour ajouter de nouvelles données au Le passage de message garantit
Permission programme, l’utilisateur doit s’assurer l’autorisation d’accéder au membre d’un
que la fonction le permet. objet à partir d’un autre objet.
Exemples Pascal, Fortran PHP5, C ++, Java.
Les spécificateurs d’accès public, private,
Accès Aucun spécificateur d’accès n’est utilisé.
et protected sont utilisés.
Les fonctions communiquent avec
Un objet communique entre eux via des
La communication d’autres fonctions en gardant les règles
messages.
habituelles.
La plupart des fonctions utilisent des Chaque objet contrôle ses propres
Contrôle des données
données globales. données.
Les fonctions ou les algorithmes ont plus
Les données prennent plus d’importance
Importance d’importance que les données dans le
que les fonctions du programme.
programme.
Le masquage des données est possible,
Il n’y a pas de moyen idéal pour masquer
Masquage des données ce qui empêche l’accès illégal de la
les données.
fonction depuis l’extérieur.
7
Conclusion
Les failles de la programmation procédurale posent le
besoin de la programmation orientée objet.
La programmation orientée objet corrige les défauts
du programmation procédurale en introduisant le concept
«objet» et «classe».
Il améliore la sécurité des données, ainsi que l’initialisation
et le nettoyage automatiques des objets.
La programmation orientée objet permet de créer plusieurs
instances de l’objet sans aucune interférence.
4
10/4/2022
B) Généralités
Problème du logiciel:
Taille
Coût : développement et maintenance
Fiabilité
Solutions :
Modularité
Réutiliser le logiciel
Certification
Comment?
Typage…
Histoire:
Fonctions et procédures (60 Fortran)
Typage des données (70) Pascal Algol
Modules: données + fonctions regroupées
(80) ada
Programmation objet: classes, objets et
héritage
10
5
10/4/2022
B) Principes de base de la POO
Objet et classe:
Classe = définitions pour des données
(variables) + fonctions (méthodes) agissant
sur ces données
Objet = élément d’une classe (instance)
avec un état
(une méthode ou une variable peut être
de classe = commune à la classe ou
d’instance = dépendant de l’instance
)
11
Principes de bases (suite)
Encapsulation et séparation de la
spécification et de l’implémentation
Séparer l’implémentation de la spécification.
Ne doit être visible de l’extérieur que ce qui est
nécessaire, les détails d’implémentation sont « cachés »
Héritage:
Une classe peut hériter des propriétés d’une
autre classe: un classe peut être une extension
d’une autre classe.
12
6
10/4/2022
Principes de bases de la POO

Mais surtout notion de polymorphisme:
Si une classe A est une extension d’une classe B:
A doit pouvoir redéfinir certaines méthodes (disons f())
Un objet a de classe A doit pouvoir être considéré
comme un objet de classe B
13
Principes de bases
Polymorphisme:
Ici l’association entre le nom ‘f()’ et le code
(code de A ou code de B) a lieu dynamiquement (=à
l’exécution)
Liaison dynamique
On peut aussi vouloir « paramétrer » une classe
(ou une méthode) par une autre classe.
Exemple: Pile d’entiers
Dans ce cas aussi un nom peut correspondre à
plusieurs codes, mais ici l’association peut avoir
lieu de façon statique (au moment de la
compilation)
14
7
10/4/2022
C) Comment assurer la
réutilisation du logiciel?
Type abstrait de données
définir le type par ses propriétés (spécification)
Interface, spécification et implémentation
Une interface et une spécification (=les
propriétés à assurer) pour définir un type
Une (ou plusieurs) implémentation du type
abstrait de données
Ces implémentations doivent vérifier la spécification
15
Comment assurer la
Pour l’utilisateur du type abstrait de

données
Accès uniquement à l’interface (pas
d’accès à l’implémentation)
Utilisation des propriétés du type abstrait
telles que définies dans la spécification.
(L’utilisateur est lui-même un type
abstrait avec une interface et une
spécification)
16
8
10/4/2022
Comment assurer la
Mais en utilisant un type abstrait

l’utilisateur n'en connaît pas
l’implémentation
il sait uniquement que la spécification du
type abstrait est supposée être vérifiée
par l'implémentation.
Pour la réalisation concrète, une
implémentation particulière est choisie
Il y a naturellement polymorphisme
17
Notion de contrat (Eiffel)
Un client et un vendeur
Un contrat lie le vendeur et le client (spécification)
Le client ne peut utiliser l’objet que par son
interface
La réalisation de l’objet est cachée au client
Le contrat est conditionné par l’utilisation correcte
de l’objet (pré-condition)
Sous réserve de la pré-condition le vendeur s’engage
à ce que l’objet vérifie sa spécification (post-
condition)
Le vendeur peut déléguer: l’objet délégué doit
vérifier au moins le contrat (héritage)
18
9
10/4/2022
Généralités…
Un peu plus qu’un langage de programmation:
“gratuit”! (licence GPL: General Public license)
Indépendant de la plateforme
Langage interprété et byte code
Orienté objet (classes héritage)
Nombreuses bibliothèques
Multi-thread
Distribué (WEB) applet, servlet, …
Dernière version Java SE 7 (GPL)
Site:http://www.java.com/fr
19
Plateforme Java
La compilation génère un .class en bytecode (langage
intermédiaire indépendant de la plateforme).
Le bytecode est interprété par un interpréteur Java
JVM
Compilation javac
interprétation java
20
10
10/4/2022
Langage intermédiaire et
Interpréteur…
Avantage: indépendance de la
plateforme
Échange de byte-code (applet)
Inconvénient: efficacité
21
Plateforme Java
La plateforme java: software au-dessus d’une
plateforme exécutable sur un hardware (exemple
MacOs, linux …)
Java VM
Java application Programming Interface (Java API):
22
11
10/4/2022
Tout un environnement…
Java 2 sdk: JRE (java runtime environment + outils
de développements compilateur, debogueurs etc…)
23
Tout un environnement…
JVM: Java Virtual Machine
JDK: Java Development Kit
JRE: Java Runtime Environment
24
12
10/4/2022
Trois exemples de base
Une application
Une applet
Une application avec interface
graphique
25
Application:
Fichier Appli.java:
/**
* Une application basique...
*/
class Appli {
public static void main(String[] args) {
System.out.println("Bienvenue en I2...");
//affichage
}
}
26
13
10/4/2022
Compiler, exécuter…
Créer un fichier Appli.java
Compilation:
javac Appli.java
Création de Appli.class (bytecode)
Interpréter le byte code:
java Appli
Attention aux suffixes!!!
(il faut que javac et java soient dans $PATH)
Exception in thread "main" java.lang.NoClassDefFoundError:
Il ne trouve pas le main -> vérifier le nom!
Variable CLASSPATH ou option -classpath
27
Remarques
Commentaires /* … */ et //
Définition de classe
une classe contient des méthodes (=fonctions) et des
variables
Pas de fonctions ou de variables globales (uniquement dans
des classes ou des instances)
Méthode main:
public static void main(String[] arg)
public
static
Void
String
Point d’entrée
28
14
10/4/2022
Remarques
Classe System
out est une variable de la classe System
println méthode de System.out
out est une variable de classe qui fait
référence à une instance de la classe
PrintStream qui implémente un flot de
sortie.
Cette instance a une méthode println
29
Remarques…
Classe: définit des méthodes et des variables
(déclaration)
Instance d’une classe (objet)
Méthode de classe: fonction associée à (toute la)
classe.
Méthode d’instance: fonction associée à une
instance particulière.
Variable de classe: associée à une classe (globale
et partagée par toutes les instances)
Variable d’instance: associée à un objet
(instancié)
Patience…
30
15
10/4/2022
Exemple applet
Fichier MonApplet.java:
/**
* Une applet basique...
*/
import java.applet.Applet;
import java.awt.Graphics;
public class MonApplet extends Applet { public
void paint(Graphics g){
g.drawString("Bienvenue en en L3...", 50,25);
}
}
31
Remarques:
import et package:
Un package est un regroupement de classes.
Toute classe est dans un package
Package par défaut (sans nom)
classpath
import java.applet.*;
Importe le package java.applet
Applet est une classe de ce package,
Sans importation il faudrait java.applet.Applet
32
16
10/4/2022
Remarques:
La classe Applet contient ce qu’il faut

pour écrire une applet
… extends Applet:
La classe définie est une extension de la
classe Applet:
Elle contient tout ce que contient la classe
Applet
(et peut redéfinir certaines méthodes (paint))
Patience!!
33
Remarques…
Une Applet contient les méthodes paint start et
init. En redéfinissant paint, l’applet une fois
lancée exécutera ce code redéfini.
Graphics g argument de paint est un objet qui
représente le contexte graphique de l’applet.
drawString est une méthode (d’instance) qui affiche une
chaîne,
50, 25: affichage à partir de la position (x,y) à partir du
point (0,0) coin en haut à gauche de l’applet.
34
17
10/4/2022
Pour exécuter l’applet

L’applet doit être exécutée dans un
navigateur capable d’interpréter du
bytecode correspondant à des applet.
Il faut créer un fichier HTML pour le
navigateur.
35
Html pour l’applet

Fichier Bienvenu.html:
<HTML>
<HEAD>
<TITLE> Une petite applet </TITLE>
<BODY>
<APPLET CODE=‘MonApplet.class' WIDTH=200
Height=50>
</APPLET>
</BODY>
</HTML>
36
18
10/4/2022
Html
Structure avec balises:
Exemples:
<HTML> </HTML>
url:
<a target="_blank" href="http://
www.liafa.jussieu.f/~hf">page de hf</a>
Ici:
<APPLET CODE='MonApplet.class' WIDTH=200
Height=50>
</APPLET>
37
Exemple interface graphique

Fichier MonSwing.java:
/**
* Une application basique... avec interface graphique
*/
import javax.swing.*;
public class MonSwing {
private static void creerFrame() {
//Une formule magique...
JFrame.setDefaultLookAndFeelDecorated(true);
//Creation d'une Frame
JFrame frame = new JFrame("MonSwing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Afficher un message
JLabel label = new JLabel("Bienvenue en L3...");
frame.getContentPane().add(label);
//Afficher la fenêtre
frame.pack();
frame.setVisible(true);
}
creerFrame();
}
}
38
19
10/4/2022
Remarques
Importation de packages
Définition d’unconteneur top-level JFrame,
implémenté comme instance de la classe JFrame
Affichage de ce conteneur
Définition d’uncomposant JLabel, implémenté
comme instance de JLabel
Ajout du composant JLabel dans la JFrame
Définition du comportement de la Jframe sur un
click du bouton de fremeture
Une méthode main qui crée la JFrame
39
Éléments de Base
40
20
10/4/2022
Les types de Base
Taille Valeurs
byte 1 octet signé
short 2 octets signé
int 4 octets signé
long 8 octets signé
float 4 octets signé
double 8 octets signé
char 2 octets Codage Unicode
boolean 1 bit 2 valeurs : true
41
ou false
Déclarations des
variables
Les variables peuvent être déclarées n’importe où
dans un bloc
Les affectations non implicites doivent être castées
(sinon erreur à la compilation,).
int i = 258;
long l = i; // conversion implicite lors d’une affectation
float f = i / 2.0 // conversion par promotion arithmétique
byte b = i; // erreur
byte b = (byte) i; // conversion explicite
Initialisation des variables sinon erreur à la compilation
42
21
10/4/2022
Les opérateurs
Types d’opérateurs Listes des opérateurs
Arithmétiques +, -, *, /, %, ++,--, +=, -=,…
Binaire bit à bit <<, >>,…
logiques !, &&, ||
De comparaison ==, !=, <,>,<=, >=
43
Les structures de contrôle
Essentiellement les mêmes qu’en C

if, switch, for, while, do while
Go to n’existent plus
Les expressions logiques sont de type
booléen, pas de type entier
Plus les blocs labellisés
44
22
10/4/2022
LES CONSTRUCTEURS EN JAVA
Les constructeurs sont utilisés pour initialiser l’état de l’objet. Comme les méthodes, un constructeur contient
également une collection d'instructions qui sont exécutées au moment de la création de l'objet.
Chaque fois qu'un objet est créé à l'aide du mot-clé new, au moins un constructeur (il peut s'agir d'un constructeur
par défaut) est appelé pour affecter des valeurs initiales aux données membres de la même classe.
Un constructeur est appelé lors de la création d'un objet ou d'une instance.
public class Personne {

private String nom;
private int age;
public Personne(String nom, int age) {

System.out.println("Je suis le constructeur");
this.nom = nom;
this.age = age;
// méthode principale (main)

public static void main(String args[]) {
Personne p = new Personne(“mohamed", 32);
}
}
45
Types de constructeur
Il existe deux types de constructeur en Java

•Constructeur sans argument : Un constructeur sans paramètre est appelé constructeur par défaut. Si nous ne
définissons pas de constructeur dans une classe, le compilateur crée un constructeur par défaut (sans argument) pour la
classe. Et si nous écrivons un constructeur avec des arguments ou sans arguments, le compilateur ne crée pas de
constructeur par défaut
Le constructeur par défaut fournit les valeurs par défaut à l'objet, telles que 0, null, etc., en fonction du type.

private String nom;
private int age;
// constructeur par défaut

public Personne() {
public void affiche() {

System.out.println("nom : " + nom);
System.out.println("age : " + age);
}

Personne p = new Personne();
p.affiche();
}
} 46
23
10/4/2022
Constructeur paramétré:
Un constructeur qui a des paramètres est appelé constructeur paramétré. Si nous voulons initialiser
les champs de la classe avec vos propres valeurs, utilisez un constructeur paramétré.
private String nom;
private int age;
// constructeur paramétré
public Personne(String nom, int age) {
this.nom = nom;
this.age = age;
public void affiche() {

System.out.println("nom : " + nom);
System.out.println("age : " + age);
}

Personne p = new Personne(“mohamed", 32);
p.affiche();
}
47
}
Les structures de contrôle…

Class LabelApp{
public static void main(String args[]){
partie: while (true) {
tour : for ( int t=0; t<nbNiveaux; t++) {
choix : do {
…
switch (c){
case ‘1’: continue tour;
case ‘2’: continue partie;
case ‘3’: braek partie;
defualt : System.out.println ("Erreur");
break;
}
}//end choix
while(true)
}//end tour
t = 2; // erreur, t est local au for
}//end partie
} 48
}
24
10/4/2022
En plus…
Entrées-sorties
49
Scanner
Scanner sc = new Scanner(System.in);
for(boolean fait=false; fait==false;){
try {
System.out.println("Répondre o ou O:"); String s1
=sc.next(Pattern.compile("[0o]"));
fait=true;
} catch(InputMismatchException e) {
sc.next();
}
}
if (sc.hasNextInt()){ int i=
sc.nextInt();
System.out.println("entier lu "+i);
}
System.out.println("next token :"+sc.next());
sc.close();
50
25
10/4/2022
Scanner
if (sc.hasNextInt()){ int
i= sc.nextInt();
System.out.println("entier lu "+i);
}
System.out.println("next token :"+sc.next()); sc.close();
String input = "1 stop 2 stop éléphant gris stop rien"; Scanner s =
new(Scanner(input).useDelimiter("\\s*stop\\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();
}
51
Les classes…
System
System.out variable (static) de classe
PrintStream
PrintStream contient print (et printf)
System.in variable (static) de classe
InputStream
Scanner
52
26
10/4/2022
Chapitre II Classes et objets
53
Classes et objets
I) Introduction
II) Classe: membres et modificateurs
III) Champs: modificateurs
IV) Vie et mort des objets,
Constructeurs
V) Méthodes
VI) Exemple
classes et objets
54
27
10/4/2022
I) Introduction
Classe
Regrouper des données et des méthodes
Variables de classe
Méthodes de classe
Classes<->type
Objet (ou instance)
Résultat de la création d’un objet
Variables d’instance
Variables de classe
Toute classe hérite de la classe Object
classes et objets
55
II) Classes
Membres d ’une classe sont:
Champs = données, attributs
Méthodes = fonctions
Classes imbriquées
classes et objets
56
28
10/4/2022
Modificateur de classe
Précède la déclaration de la classe

Annotations (plus tard…)
public (par défaut package)
abstract(incomplète, pas d’instance)
final(pas d’extension)
Strictfp (technique…)
Le modificateur strictfp permet de contrôler le comportement de la virgule flottante
strictfp class NomClasse {...}
strictfp interface INomInterface {...}
strictfp type méthode(){...}
57
classes et objets
III) Champs Un membre marqué dans une classe comme étant protégé (mot
clé protected) peut être manipulé :
•Dans la classe qui définit ce membre,
•Dans les classes qui dérivent de la classe considérée,
Modificateurs •Et dans toutes les classes (et les types) définies dans le même
annotations package que celle qui définit le membre protégé
Contrôle d’accès
private le mot clé transient; l'interface
protected Serializable qui est un marqueur indiquant
public que la classe peut être sérialisée
package
static (variables de classe) Les variables volatiles ne sont pas mises en
final (constantes) cache dans les registres ni dans les caches
transient où elles sont cachées des autres
processeurs Donc, la lecture d'une
Volatile variable volatile renvoie toujours
Initialisations l'écriture la plus récente par un thread
Création par opérateur new
classes et objets
58
29
10/4/2022
IV) Vie et mort des objets,

constructeurs
Création d’une instance: opérateur new

Objet mort = plus aucune référence à
cet objet -> garbage collector
on peut exécuter du code spécifique quand
un objet est détruit :
protected void finalize() throws Throwable
classes et objets
59
Références
Une variable est (en général) une référence à

un objet
Type primitif: directement une valeur
Type référence : une référence à un objet
(existant ou créé par new)
null : référence universelle
conséquences:
dans le passage par valeur un type référence correspond à
un passage par référence
‘a== b‘teste si les a et b référencent le même objet
Méthode equals qui peut être redéfinie (défaut
classes et objets this==obj)
60
30
10/4/2022
Exemple
int i=0;
int j=0;
(i==j) // vrai
class A{
int i=0;
}
A a;
A b=new A();
a=b;
(a==b) // vrai
b=new A();
(a==b) // faux
classes et objets
61
Rappel sur les Constructeurs
Appelés par l’opérateur new pour créer un

objet
Peuvent avoir des paramètres (avec
surcharge)
Initialisent les objets
Constructeur par défaut (si aucun
constructeur n’est défini)
Constructeur de copie
classes et objets
62
31
10/4/2022
Statique - dynamique
Statique <-> à la compilation

Dynamique <-> à l’exécution
Le type d’une variable est déterminé à
la compilation (déclaration et portée)
Avec la possibilité de l’héritage une
variable peut être une référence sur un
objet d’un autre type que le type de sa
déclaration
classes et objets
63
Static
Une variable (une méthode) déclarée
static est une variable (méthode) de
classe: elle est associée à la classe (pas à
une instance particulière).
Statique parce qu’elle peut être créée au
moment de la compilation (pas de new()).
Statique -> les initialisations doivent avoir
lieu à la compilation.
classes et objets
64
32
10/4/2022
Initialisations
private static long nextId = 0;

Bloc d’initialisation
private static long netxId = 0;
{
idNum = nextId++;
}
classes et objets
65
Initialisation static
public class Puissancedeux {
static int[] tab = new int[12];
static{
tab[0]=1;
for(int i=0; i< tab.length-1;i++)
tab[i+1]= suivant(tab[i]);
}
static int suivant(int i){
return i*2;
}
}
classes et objets
66
33
10/4/2022
V) Méthodes
Modificateurs:
Annotations
Contrôle d’accès (comme pour les variables)
abstract
static n’apas accès aux variables d’instances
final ne peut pas être remplacée
synchronized
native (utilisation de fonctions « native »)
strictfp
classes et objets
67
Méthodes…
Contrôler l’accès:
//…
public void setNom(String n){
nom=n;
}
public void setOrbite(Astre a){
orbite=a;
}
public String getNom(){
return nom;
}
public Astre getOrbite(){
return orbite;
}
classes et objets
68
34
10/4/2022
Méthodes main
for(int j =0; j<args.length;j++){
System.out.print(args[j] + " ");
}
}
Le main est le point d’accès et peut avoir des arguments:
classes et objets
69
Forme générale d’une classe

modifier class classname {
modifier data-type field1;
modifier data-type field2;
…
modifier data-type fieldN;
modifier Return-Type methodName1 (parameters)
{ // statements}
…
modifier Return-Type methodNameM (parameters)
{ // statements}
}
70
35
10/4/2022
Autre Exemple
/* Voiture.java */
public class Voiture
{
public String nom;
public int matricule;
public int puissance;
}
71
Suite de Exemple…
class Interrupteur { // Interrupteur est le nom de la
classe
boolean open; // Ceci est un attribut
void setState (boolean newstate) { // Ceci est une

méthode
open = newstate;
}
void printState() { // Ceci est une deuxième
méthode
if (open) System.out.println (" l’interrupteur
est ouvert");
else System.out.println ("l’interrupteur est
fermé");
}
72
}
36
10/4/2022
Conventions de nommage
Le nom des classes commence par une
majuscule, suivi de minuscules, une majuscule
apparaissant dans chaque nouveau mot
constituant ce nom
Le nom des méthodes et attributs débute par
une minuscule, suivi de minuscules, une
majuscule apparaissant dans chaque nouveau
mot constituant ce nom
Le nom des variables locales est écrit en
minuscule
Le nom des attributs constants est écris en
majuscule
73
Modificateur de classe
public
Une classe est soit public, soit privée :
Une classe public est visible en dehors du pacakage dans laquelle est définie
Par défaut une classe est privé, elle est publique si sa définition est précédée du
mot clé public
final
Une classe définie comme final ne peut pas être dérivée
74
37
10/4/2022
Object
Voiture maVoiture;
maVoiture = new Voiture( );
maVoiture.nom = « Golf 4 »;
maVoiture.matricule = 66066;
maVoiture.puissance = 6;
75
Les attributs (== les champs)

Les attributs sont les données contenues dans
les objets d’une certaine classe
Lors de la création d’un objet, ses attributs
sont initialisés par défaut :
à zéro pour les valeurs numériques
à null pour les références
à false pour le boolean
Les attributs peuvent être initialisés de
manière spécifique par le programmeur:
Lors de leur déclaration
Dans le constructeur
76
38
10/4/2022
Exemple
class Date {
int jour; // par défaut, un attribut est initialisé à zéro
int mois = 1;
int an;
final int MAX_MOIS = 12; // Ceci est une constante
Date (int _an) {an = _an;} // Ceci est un constructeur
void print() {System.out.println( jour + « / » + mois + « / » + an
);}
}
…
Date d = new Date (2002); // Création d’un nouvel objet de la
classe Date. d est une référence sur cet objet
d.print(); // Invocation de la méthode print
77
Modificateur d’attribut
final :
Permet de spécifier que cet attribut est une constante
Un attribut final doit être initialisé avant son utilisation
static :
Permet d’indiquer que cet attribut est commun à tous
les objets de la classe concerné
Un attribut static peut être accédé par le nom de la
classe elle même
L’accessibilité des attributs est pondéré par
des critères de visibilité (public, private,…)
78
39
10/4/2022
Les méthodes
Considérée comme une fonction qui est
membre d’une certaine classe
Définit le comportement des objets
Syntaxiquement très proche des fonctions C
Accessible via une instance de la classe ou via
la classe (pour les méthodes statiques)
d.print // on invoque la méthode print de l’instance ‘d’
a = Math.sqrt (2.0); // on invoque la méthode statique
‘sqrt’ de la classe Math
79
La surcharge
des méthodes
Permet de définir des méthodes portant le même
nom, mais acceptant des paramètres de type
différent et / ou en nombre différent
class Test {
void print (int i) {…}
void print (float f) {…}
void print (int i, int j) {…}
}
…
Test t = new Test();
int i;
t.print(i); // => la première méthode est appelée
80
40
10/4/2022
Les méthodes statiques
Définies avec le mot clé static

Elles ressemblent aux fonctions globales dans des
autres langages de programmation
Elles ne peuvent accéder que les attributs static
On fait appel à une méthode statique à travers le nom
de la classe
ClassName.functionName(arguments);
Par exemple, la classe Math à une méthode statique
appelé cos qui prend une valeur de type double
comme argument
Math.cos(3.5)
La méthode main est statique – parce que le système
appelle main avant de créer des objets
81
Les constructeurs
Permettent d’initialiser les objets de la classe

concernée
Lors de la création d’un objet, un constructeur est
automatiquement appelé
Un constructeur a le même nom que la classe, ne
retourne jamais de valeur et peut prendre des
paramètres
Toute classe possède un constructeur par défaut,
implicite qui peut être redéfini.
Une classe peut avoir plusieurs constructeurs qui
diffèrent par le nombre et la nature de leurs paramètres
82
41
10/4/2022
Destruction d’un objet

La destruction des objets est prise en charge
par le garbage collector (GC)
Le GC détruit les objets pour lesquels il
n’existe plus de référence
Si l’objet possède la méthode finalize, celle-ci
est appelée automatiquement avant la
destruction de l’objet
83
Destruction d’un objet…
public class Circle {

…
void finalize() {
system.out.println(" Je suis garbage collector ");
}
}
…
Circle c1;
if (condition) {
Circle c2 = new Circle(); // c2 référence sur une
nouvelle // instance
c1 = c2; c1 est une référence sur c2
}
c1 = null; // L’instance c1 ne possède plus de référence. Elle
n’est plus // accessible. A tout moment le gc peut détruire l’objet
84
42
10/4/2022
Les références
Permettent de désigner et manipuler les
objets.
La notion de référence est assez proche de
celle de pointeur
Beaucoup plus simple et sécurisant qu’un vrai
pointeur
85
Les références…
La création d’un objet
La création d’un objet se fait à l’aide de
l’opérateur new qui se charge de:
1. Allouer l’espace mémoire nécessaire pour stocker les
attributs de l’objet en cours de construction
2. Appeler le constructeur de l’objet adéquat pour
initialiser les attributs de l’objet
3. Retourner une référence sur l’objet créé
Il est possible de copier une référence et de
disposer à un instant t de plusieurs
référence sur un même objet
Lorsque le nombre de références tombe à
zéro, la mémoire est automatiquement
libérer par le GC
86
43
10/4/2022
La création d’un
objet…
… Objet Voiture
if (test) { clio 1
Voiture clio = new Voiture(" Clio "); " Clio "
Voiture bmw = new
Voiture(" BMW ");
bmw
Objet Voiture
if (moi.estUnFirmeur()) { 2
Voiture mavoi = bmw; " BMW "
mavoi
…
}
…
}
87
Les références…
La référence sur l’objet courant
Le mot clé this représente une référence sur

l’objet courant
this peut être utile :
Lorsqu’une variable locale (ou un paramètre) cache, en portant le même nom, un
attribut de la classe
Pour déclencher un constructeur depuis un autre
88
44
10/4/2022
La référence sur l’objet

courant…
class Date {
int jour = 1;
int mois = 1;
int an = 1990;
Date() {an = 2002;} // peut aussi s’écrire : this.an

= 2002
Date (int an) {
this.an = an; // le paramètre an cache
l’attribut an
}
Date( int jour, int mois, int an) {
this.jour = jour;
this.mois = mois;
this(an); // appel au deuxième
constructeur
}
} 89
Les références…
La référence vide
Le mot clé null permet de représenter la référence qui ne
référence rien
C’est la valeur par défaut d’initialisation des attributs
représentant des références
class Test {
Voiture v1; // Initialisée à null par défaut
void methode() {
if (v1 == null) v1 = new Voiture(« Volvo »);
}
}
…
if ( refDeTypeInconnu instanceof Voiture) {
…Traitement pour une voiture
}
90
45
10/4/2022
Les tableaux
Un tableau dans Java est toujours un objet
Permet de contenir plusieurs éléments du même
type (type de base ou classe)
Déclaration :
int array_of_int[];
int[] array_of_int;
Color rgb_cube[][][];
Création et initialisation :
int[] primes = {1, 2, 3, 5, 7, 7+4};
array_of_int = new int[42];
rgb_cube = new Color[256] [256] [256];
array_of_int[0] = 3;
91
Les tableaux…
Chaque élément d’un tableau de type de base
est initialisé à zéro par défaut
Chaque élément d’un tableau de références à
des objets est initialisé à null par défaut
Les indices des tableaux commencent à partir
de 0
Utilisation des tableaux
int l = array_of_int.length; // l = 42
int e = array_of_int[50];
// lève l’exception ArrayIndexOutOfBoundsException
92
46
10/4/2022
Chapitre III Héritage
93
Chapitre III: Héritage

Le transtypage (ou cast)
est la conversion d'une
A) Extensions généralités expression d'un certain
Affectation et transtypage type en une expression
d'un autre type.
B) Méthodes
Surcharge et signature
C) Méthodes (suite)
Redéfinition et liaison dynamique
D) Conséquences
Les variables
E) Divers
Super, accès, final
F) Constructeurs et héritage
94
47
10/4/2022
Principes généraux
Toute classe dans Java est une sous classe de la
classe Object
Une classe ne peut hériter (extends) que d’une
seule classe
Une sous-classe peut redéfinir une ou plusieurs
des méthodes dont elle hérite
Il est possible d’interdire qu’une classe puisse être
héritée
Il est possible d’interdire qu’une méthode soit re-
définie dans une sous-classe
Le mot clé extends permet de décrire les relations
d’héritage
95
Exemple
public class Ellipse {
public double r1, r2;
public Ellipse(double r1, double r2) {
this.r1 = r1;
this.r2 = r2;
}
public double area (){…}
void print() {}
}
final class Circle extends Ellipse {

public Circle(double r) {super(r,r);}
public double getRadius () {return r1;}
void print () {System.out.println (" le rayon est : " + r1);}
96
48
10/4/2022
Exemple…
The java instanceof operator is used to
test whether the object is an instance of
Ellipse e = new Ellipse (2.0, 4.0); the specified type (class or subclass or
Circle c = new Circle(2.0); interface)
System.out.println( "Aire de c: " + c.area());

System.out.println( e instanceof Ellipse); //true
System.out.println( e instanceof Circle); //false
System.out.println( c instanceof Circle); //true
System.out.println( c instanceof Ellipse); //true
e = c; // OK : tout cercle est une ellipse
System.out.println( e instanceof Circle); //true
System.out.println( e instanceof Ellipse); //true
e.print() // la référence e est de type Ellipse mais l’objet réellement référencé
est de type Circle => c’est la méthode Circle.print() qui est réellement appelé
double r = e.getRadius() // erreur à la compilation
c = e; // erreur type incompatible, nécessité de casting
c = (Circle) e; The process of converting the value of one data type ( int
, float , double , etc.) to another data type is known as
casting 97
Accès à la super-classe
d’une classe : super(…)
class Mere {
int attribut;
Mere() {attribut = 1;}
Mere(int attribut) {this.attribut = attribut;}
void print() {System.out.println(" base"+ attribut);}
}
class Fille extends Mere {
boolean flag;
Fille(int a) { super(a);
flag = true;
}
void print() { System.out.println(" dérivée");
super.print();
}
}
98
49
10/4/2022
Accès à la super-classe
d’une classe : super(…)
…
Fille f = new Fille(2);
Mere m = f;
m.print();
// affiche :
dérivée
base 2
99
Le masquage des variables
class A {
int x;
void m() {…}
}
class B extends A {
int x;
void m() {…}
}
class C extends B {
int x, a;
void m() {…}
void test() {
a = super.x; // a reçoit la valeur de la variable x de la classe B
a = super.super.x; // erreur syntaxique
a = ((B) this).x; // a reçoit la valeur de la variable x de la classe B
super.m(); // Appel de la méthode m de la classe B
super.super.m(); // erreur syntaxique
((B) this).m(); // Appel de la méthode m de la classe C (et non B)
}
10
0
50
10/4/2022
Méthodes et classes
abstraites : abstract
Une méthode abstraite est une méthode dont
on donne le prototype, sans décrire
l’implémentation
Une méthode abstraite doit être redéfinie dans
une sous-classe pour pouvoir être utilisée
Une classe abstraite ne peut jamais être
directement instanciée avec l’opérateur new
Une classe héritant d’une classe abstraite doit
donner une implémentation à toutes les
méthodes abstraites de sa super-classe
10
1
Les classes
abstraites
Une classe abstraite est une classe ayant au moins

une méthode abstraite.
Une méthode abstraite est une méthode dont on
donne le prototype, sans décrire l’implémentation
Une classe abstraite ne peut pas être instancié (new)
Une classe dérivée d’une classe abstraite ne
redéfinissant pas toutes les méthodes abstraites est
elle même abstraite
10
2
51
10/4/2022
Les classes
abstraites…
class abstract Shape {
public abstract double perimeter ( );
}
class Circle extends Shape {
…
public double perimeter ( ) { return 2*Math.PI*r; }
}
class Rectangle extends Shape {
…
public double perimeter ( ) { return 2*( height +width ); }
}
…
Shape[ ] shapes = { new Circle(2), new Rectangle(2,3), new Circle( 6 ) };
double sum_of_perimeters = 0;
for (int i = 0; i < shapes.length; i++)
sum_of_perimeters = shapes[i].perimeter( );
10
3
A) Extension: généralités
Principe de la programmation objet:
un berger allemand est un chien
il a donc toutes les caractéristiques des chiens
il peut avoir des propriétés supplémentaires
un chien est lui-même un mammifère qui est lui-même
un animal: hiérarchie des classes
On en déduit:
Hiérarchie des classes (Object à la racine)
et si B est une extension de A alors un objet de
B est un objet de A avec des propriétés
supplémentaires
10
4
52
10/4/2022
Extension: généralités
Quand B est une extension de la classe A:
Tout objet de B a toutes les propriétés d’un
objet de A (+ d’autres).
Donc un objet B peut être considéré comme un
objet A.
Donc les variables définies pour un objet de A
sont aussi présentes pour un objet de B (+
d’autres). (Mais elles peuvent être occultées)
Idem pour les méthodes : Les méthodes de A sont
présentes pour B et un objet B peut définir de
nouvelles méthodes.
Mais B peut redéfinir des méthodes de A.
10
5
Extension de classe
Si B est une extension de A
pour les variables:
B peut ajouter des variables (et si le nom est
identique cela occultera la variable de même nom
dans A)
(occulter = continuer à exister mais "caché")
Les variables de A sont toutes présentes pour un
objet B, mais certaines peuvent être cachées
pour les méthodes
B peut ajouter de nouvelles méthodes
B peut redéfinir des méthodes (même signature)
10
6
53
10/4/2022
Remarques:
pour les variables
c'est le nom de la variable qui est pris en compte (pas le type).
dans un contexte donné, à chaque nom de variable ne correspond
qu'une seule déclaration.
(l'association entre le nom de la variable et sa déclaration est faite à la
compilation)
pour les méthodes
c'est la signature (nom + type des paramètres) qui est prise en
compte:
on peut avoir des méthodes de même nom et de signatures
différentes (surcharge)
dans un contexte donné, à un nom de méthode et à une signature
correspond une seule définition
(l'association entre le nom de la méthode et sa déclaration est faite à la
compilation, mais l'association entre le nom de la méthode et sa
définition sera faite à l'exécution)
10
7
Extension (plus précisément)

Si B est une extension de A
(class B extends A)
Les variables et méthodes de A sont des
méthodes de B (mais elles peuvent ne pas être
accessibles: private)
B peut ajouter de nouvelles variables (si le nom
est identique il y a occultation)
B peut ajouter des nouvelles méthodes si la
signature est différente
B redéfinit des méthodes de A si la signature est
identique
10
8
54
10/4/2022
En conséquence:
Une variable déclarée comme étant de classe
A peut référencer un objet de classe B ou
plus généralement un objet d’une classe
dérivée de A:
un tel objet contient tout ce qu’il faut pour être
un objet de classe A
Par contre une variable déclarée de classe B
ne peut référencer un objet de classe A:
il manque quelque chose!
10
9
Affectation downcast/upcast
class A{
public int i;
//...
}
class B extends A{
public int j;
//...
}
public class Affecter{ static
void essai(){
A a = new A(); B
b = new B();
//b=a; impossible que signifierait b.j??
a=b; // a référence un objet B
// b=a;
b=(B)a; // comme a est un objet B ok!!
}
}
11
0
55
10/4/2022
B) Méthodes: Surcharge
Méthodes et signature:
Signature: le nom et les arguments avec leur type (mais pas
le type de la valeur retournée)
Seule la signature compte:
int f(int i)
char f(int i)
Les deux méthodes ont la même signature: c'est interdit
Surcharge possible:
Des signatures différentes pour un même nom
int f(int i)
int f(double f)
Le compilateur détermine par le type des arguments quelle
fonction est utilisée (on verra les règles…)
11
1
Surcharge
Un même nom de fonction pour plusieurs

fonctions qui sont distinguées par leur
signature
(Java, C++, Ada permettent la surcharge)
En C ’/’est surchargé
3/2 division entière -> 1
3.0/2 division réelle -> 1,5
11
2
56
10/4/2022
Surcharge
public int f(int i){
return i;
}
// public double f(int i){
// return Math.sqrt( i);
// }
public int f(double i){
return (int) Math.sqrt( i);
}
public int f(char c){
return c;
}
11
3
Remarques
La résolution de la surcharge a lieu à la
compilation
La signature doit permettre cette résolution
(quelques complications du fait du
transtypage:
Exemple: un char est converti en int
Exemple: upcasting
)
11
4
57
10/4/2022
C) Méthodes: Redéfinition
Un classe hérite des méthodes des

classes ancêtres
Elle peut ajouter de nouvelles méthodes
Elle peut surcharger des méthodes
Elle peut aussi redéfinir des méthodes
des ancêtres.
11
5
Exemple
class Mere{
void f(int i){ System.out.println("f("+i+") de
Mere");
}
void f(String st){ System.out.println("f("+st+") de
Mere");
}
}
11
6
58
10/4/2022
Exemple (suite)
class Fille extends Mere{ void
f(){ //surcharge
System.out.println("f() de Fille");
}
// char f(int i){
// même signature mais type de retour différent
// }
void g(){ //nouvelle méthode
System.out.println("g() de Fille"); f();
f(3);
f("bonjour");
}
void f(int i){ // redéfinition
System.out.println("f("+i+") de Fille");
}
}
11
7
Exemple
Mere m=new Mere();

Fille f=new Fille();
m.f(3);
f.f(4);
m=f;
m.f(5);
//m.g();
((Fille)m).g();
f.g();
}
11
8
59
10/4/2022
Résultat
f(3) de Mere
f(4) de Fille
f(5) de Fille
g() de Fille
f() de Fille
f(3) de Fille
f(bonjour) de Mere
g() de Fille
f() de Fille
f(3) de Fille
f(bonjour) de Mere
11
9
D) Conséquences
Et les variables?
Un principe:
Une méthode (re)définie dans une classe A ne
peut être évaluée que dans le contexte des
variables définies dans la classe A.
Pourquoi?
12
0
60
10/4/2022
Exemple
class A{
public int i=4;
public void f(){
System.out.println("f() de A, i="+i);
}
public void g(){
System.out.println("g() de A, i="+i);
}
}
class B extends A{
public int i=3;
public void f(){
System.out.println("f() de B, i="+i);
g();
}
}
12
1
Exemple suite:
A a=new B();
a.f();
System.out.println("a.i="+a.i);
System.out.println("((B) a).i="+((B)a).i);
Donnera:
f() de B, i=3
g() de A, i=4
a.i=4
((B) a).i=3
12
2
61
10/4/2022
Remarques:
La variable i de A est occultée par la variable

i de B
La variable i de A est toujours présente dans
tout objet de B
Le méthode g de A a accès à toutes les
variables définies dans A (et uniquement à
celles-là)
La méthode f de B redéfinit f. f() redéfinie a
accès à toutes les variables définies dans B
12
3
E) Divers
super
Le mot clé super permet d’accéder aux
méthodes de la super classe
En particulier super permet d’appeler dans
une méthode redéfinie la méthode d’origine
(exemple: super.finalize() appelé dans une
méthode qui redéfinit le finalize permet
d'appeler le finalize de la classe de base)
12
4
62
10/4/2022
Exemple
class Base{
protected String nom(){
return "Base";
}
}
class Derive extends Base{
protected String nom(){
return "Derive";
}
protected void print(){
Base maref = (Base) this;
System.out.println("this.name():"+this.nom());
System.out.println("maref.name():"+maref.nom());
System.out.println("super.name():"+super.nom());
}
this.name():Derive
maref.name():Derive
super.name():Base
12
5
Contrôle d’accès
protected: accès dans les classes dérivées
Le contrôle d’accès ne concerne pas la
signature
Une méthode redéfinie peut changer le
contrôle d’accès mais uniquement pour
élargir l’accès (de protected à public)
Le contrôle d’accès est vérifié à la
compilation
12
6
63
10/4/2022
Interdire la redéfinition
Le modificateur final interdit la

redéfinition pour une méthode
(Bien sûr une méthode de classe ne peut
pas être redéfinie! Mais, elle peut être
surchargée)
Une variable avec modificateur final
peut être occultée
12
7
E) Constructeurs et héritage
Le constructeurs ne sont pas des méthodes

comme les autres:
le redéfinition n’apas de sens.
Appeler un constructeur dans un
constructeur:
super() appelle le constructeur de la super classe
this() appelle le constructeur de la classe elle-
même
Ces appels doivent se faire au début du code du
constructeur
12
8
64
10/4/2022
Constructeurs
Principes:
Quand une méthode d’instance est
appelée l’objet est déjà créé.
Création de l’objet (récursivement)
1. Invocation du constructeur de la super classe
2. Initialisations des champs par les
initialisateurs et les blocs d’initialisation
3. Une fois toutes ces initialisations faites, appel
du corps du constructeur (super() et this() ne
font pas partie du corps)
12
9
Exemple
class X{
protected int xMask=0x00ff;
protected int fullMask;
public X(){
fullMask = xMask;
}
public int mask(int orig){
return (orig & fullMask);
}
}
class Y extends X{
protected int yMask = 0xff00;
public Y(){
fullMask |= yMask;
}
}
13
0
65
10/4/2022
Résultat
xMask yMask fullMask
Val. par défaut des champs 0 0 0
Appel Constructeur pour Y 0 0 0
Appel Constructeur pour X 0 0 0
Initialisation champ X 0x00ff 0 0
Constructeur X 0x00FF 0 0x00FF
Initialisation champs de Y 0x00FF 0xFF00 0x00FF
Constructeur Y 0x00FF 0xFF00 0xFFFF
13
1
La classe Object
Toutes les classes héritent de la classe
Object
méthodes:
public final Class<? extends Object> getClass()
public int hashCode()
public boolean equals(Object obj)
protected Object clone() throws
CloneNotSupportedException
public String toString()
protected void finalize() throws Throwable
(wait, notify,notfyall)
13
2
66
10/4/2022
Exemple
class A{
int i;
int j;
A(int i,int j){
this.i=i;this.j=j;}
}
class D <T>{
T i;
D(T i){
this.i=i;
}
}
13
3
Suite
public static void main(String[] args) { A
a=new A(1,2);
A b=new A(1,2); A
c=a;
if (a==b)
System.out.println("a==b"); else
System.out.println("a!=b"); if
(a.equals(b))
System.out.println("a equals b");
else
System.out.println("a not equals
b");
System.out.println("Objet a: "+a.toString()+" classe "+a.getClass());
System.out.println("a.hashCode()"+a.hashCode());
System.out.println("b.hashCode()"+b.hashCode());
System.out.println("c.hashCode()"+c.hashCode());
D <Integer> x=new D<Integer>(10);
System.out.println("Objet x: "+x.toString()+" classe "+x.getClass());
}
13
4
67
10/4/2022
Résultat:
a!=b
a not equals b
Objet a: A@18d107f classe class A
a.hashCode()26022015
b.hashCode()3541984
c.hashCode()26022015
Objet x: D@ad3ba4 classe class D
13
5
En redéfinissant equals
class B{
int i;
int j;
B(int i,int j){
this.i=i;this.j=j;
}
public boolean equals(Object o){
if (o instanceof B)
return i==((B)o).i && j==((B)o).j; else
return false;
}
}
13
6
68
10/4/2022
Voir exercise en annexe
13
7
Polymorphisme (1) :
Recherche dynamique des
méthodes
Capacité pour une entité de prendre plusieurs formes.
le mécanisme de "lookup" dynamique :
déclenchement de la méthode la plus spécifique d’un

objet, c'est-à-dire celle correspondant au type réel de
l'objet,
Cette dynamicité permet d'écrire du code plus générique.
13
8
69
10/4/2022
Polymorphisme (2):
Recherche dynamique des
méthodes
Employe jean = new Employe();
jean.calculePrime();
Employe
salaire : Double
calculePrime()
Employe jean = new Cadre();
jean.calculePrime();
Cadre
calculePrime()
13
9
Polymorphisme (3) :
Sur-définition de méthodes
Dans une même classe, plusieurs méthodes peuvent
posséder le même nom, pourvu qu'elles diffèrent en
nombre et/ou type de paramètres.
On parle de surdéfinition ou surcharge, on encore en
anglais d’overloading.
Le choix de la méthode à utiliser est fonction des
paramètres passés à l'appel.
Très souvent les constructeurs sont surchargés (plusieurs
constructeurs prenant des paramètres différents et
initialisant de manières différentes les objets)
14
0
70
10/4/2022
Polymorphisme (4) :
Quelques précisions cependant :
le type de retour seul, ne suffit pas à distinguer deux
méthodes de signatures identiques par ailleurs,
les types des paramètres doivent être "suffisamment"
différents pour qu'il n'y ait pas d'ambiguïtés,
Ne pas confondre surcharge et redéfinition (même si
très proche)
on redéfinit dans une sous-classe des méthodes héritées
de sa superclasse.
on surcharge quand plusieurs méthodes dans une même
classe ont le même nom mais des paramètres différents.
14
1
Polymorphisme (5) :
public int max (int m, int n)
{ if (m > n ) return m;
return n;
}
public int max (int n1, int n2, int n3)

{ return(max(max(n1,n2),n3));
}
14
2
71
10/4/2022
Polymorphisme (6) :
public int max (byte m, int n) Calcul a = new Calcul();
{ if (m > n ) return m; int x; byte y;
return n; a.max(x,y);
}
a.max(y,x);
public int max (int m, byte n)
{ if (m > n ) return m; a.max(y,y); ??
return n;
}
14
3
Classe abstraite (1)
Il peut être nécessaire au programmeur de créer une classe

déclarant une méthode sans la définir (c'est-à-dire sans en
donner le code). La définition du code est dans ce cas
laissée aux sous-classes : classe abstraite
Une classe abstraite est une classe ayant au moins une
méthode abstraite.
Une méthode abstraite ne possède pas de définition.
Une classe abstraite ne peut pas être instanciée (new).
Une classe dérivée d'une classe abstraite ne redéfinissant
pas toutes les méthodes abstraites est elle-même abstraite.
Elle doit être marquée avec le mot réservé abstract. 14
4
72
10/4/2022
Classe abstraite (2)
class abstract Shape {

public abstract double perimeter();
}
class Circle extends Shape {
...
public double perimeter() { return 2 * Math.PI * r ; }
}
class Rectangle extends Shape {
...
public double perimeter() { return 2 * (height + width); }
}
Shape[] shapes = {new Circle(2), new Rectangle(2,3), new Circle(5)};
double sum_of_perimeters = 0;
for(int i=0; i<shapes.length; i++)
sum_of_perimeters += shapes[i].perimeter();
14
5
L'héritage multiple? Les interfaces
14
6
73
10/4/2022
L'héritage multiple????
Considérons un cas où la classe A hérite la
classe B et la classe C. Les classes B et C
ont la même méthode show().
public class A extends B, C { ... }!!!!! NON NON
Maintenant, le compilateur Java ne peut pas décider quelle méthode show() il

doit hériter. Pour éviter toute ambiguïté, l’héritage multiple n’est pas pris en
charge en Java.
En Java, une classe ne peut pas hériter plusieurs classes. Par

conséquent, l’héritage multiple est interdit
l'héritage multiple n’existe pas en JAVA

147
Interface (1)
Une classe peut implémentée plusieurs interfaces

différentes
Cas de conflits de noms :
interface I1 Class A implements I1, I2 { }
{ void f(int n); 2 méthodes f à surdéfinir et une
seule méthode g à définir
void g();}
interface I2 Si dans I2 on aura int g(); au lieu
de void g(); ??
{ void f(float n);
void g();}
14
8
74
10/4/2022
C'est tellement utile qu'on aimerais parfois qu'un objet

hérite de plusieurs classe, afin de lui associé plusieurs
types
Les Interfaces! Solution

Une interface est une liste de noms de méthodes (uniquement les signatures des méthodes).
Permettent de créer des sous-types mais sans créer de classe de base.
Une interface est un prototype de classe. Elle définit la signature des méthodes qui doivent être
implémentées dans les classes construites à partir de ce prototype.
On dit qu'une classe implémente une interface, si elle définit les méthodes de l'interface.
En java on déclare qu'une classe implémente une interface avec le mot clé implements.
Une interface définit un type (comme une classe) et les classes qui implémentent cette interface
sont donc des sous-types.
149
Exemple
public interface IA
{ void methodA();
}
public A implements IA
{ void methodA() { //code } }

public interface IB
{ void methodB();
}
public abstract B implements IB
{ void methodB() { //code } }
public C implements IA, IB

{ private IB b = new B();
private IA a = new A();
public void methodB()
{ b.methodB();
}
public void methodA()
{ a.methodA(); } 150
75
10/4/2022
Example
animal
pigeon canary
15
1
/ interface
interface Animal {
public void animalSound(); // interface method
(does not have a body)
public void sleep(); // interface method (does not
have a body) }
// Pig "implements" the Animal
interface class Pig implements Animal
{ public void animalSound() { // The body of
animalSound() is provided here
System.out.println("The pig says: ……"); }
public void sleep()
{ // The body of sleep() is provided here
System.out.println(“….."); } }
class MyMainClass {
public static void main(String[] args)
{ Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep(); } }
15
2
76
10/4/2022
interface class cana implements Animal

{ public void animalSound() { // The body of animalSound()
is provided here
System.out.println("The cana says: ……"); }
public void sleep()
{ // The body of sleep() is provided here
System.out.println(“….."); } }
public X implements Cana, Pig

{ private int x ;
public void animalSound(); // interface method (does not have a
body) public void sleep(); // interface method (does not have a
body) }
class MyMainClass {
{ Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep();
{ can mycan = new cana(); // Create a cana object
x myX = new x(); // Create an x object
myX.animalSound();
myX.sleep(); } }
} }
15
3
Exemple
person
Ici, la classe de base est
Personne, Mère et Femme, mais
lorsque Femme et Mère sont la
même personne et c'est de cette
personne que nous parlons.
Mother wife
classe WifeAndMother étend

femme, mère Cela ne fonctionnera
pas, pour cela, nous devons
WifeAndMother
utiliser des interfaces.
Regardons le code -
15
4
77
10/4/2022
class Person
{
String name;
Person(String n) public class Test
{ {
name = "Person: " + n;
public static void main(String args[])
}
} {
class Mother extends Person Person p = new Person(“mohamed");
{ Mother m = new Mother(“hayet");
Mother(String n)
{ Wife w = new Wife("Rania");
super(n); System.out.println("p is a " + p.name);
name = "Mother: " + n; System.out.println("m is a " + m.name);
}
System.out.println("w is a " + w.name);
void FeedChildren()
{ m.FeedChildren();
System.out.println(name + " is feeding the kids w.CallHusband();
..."); }
}
} }
class Wife extends Person classe WifeAndMother étend
{ femme, mère Cela ne fonctionnera
Wife(String n)
{ pas, pour cela, nous devons
super(n); utiliser des interfaces.
name = "Wife: " + n;
} Regardons le code -
void CallHusband()
{
System.out.println(name + " is calling the
husband ...");
}
} 15
5
class Person
{
String name; public class Test
Person(String n) {
{ public static void main(String args[])
name = "Person: " + n;
}
{
} Person p = new Person("mohamed");
interface Mother WifeAndMother w = new WifeAndMother("Rania");
{ System.out.println("p is a " + p.name);
public void FeedChildren();
} System.out.println("w is a " + w.name);
interface Wife w.FeedChildren();
{ w.CallHusband();
public void CallHusband();
}
}
class WifeAndMother extends Person implements Wife, }
Mother
{
WifeAndMother(String n)
{
super(n);
name = "Wife and mother: " + n;
}
public void FeedChildren()
{
System.out.println(name + " is feeding the
children.");
}
public void CallHusband()
{
System.out.println(name + " is calling her
husband.");
} 15
} 6
78
10/4/2022
Interface (2)
Si le programmeur veut s'assurer qu'une certaine
catégorie de classes (pas forcément reliées par des
relations de généralisation / spécialisation) implémente
un ensemble de méthodes, il peut regrouper les
déclarations de ces méthodes dans une interface.
De telles classes pourront ainsi être manipulées de
manière identique.
Les classes désirant appartenir à la catégorie ainsi
définie :
déclareront qu'elles implémentent cette interface,
fourniront le code des méthodes déclarées dans cette
interface.
15
7
Interface (3)
Cela peut être vu comme un contrat entre la classe et

l’interface
la classe s’engage à implémenter les méthodes définies
dans l’interface
Mots réservés : interface et implements
15
8
79
10/4/2022
Interface (4)
Une interface correspond à une classe où toutes

les méthodes sont abstraites.
Le modificateur abstract est facultatif
Une classe peut implémenter (implements) une ou
plusieurs interfaces tout en héritant (extends)
d'une classe.
Comme pour les classes, l’héritage est possible
entre les interfaces
15
9
Les packages et l’encapsulation
16
0
80
10/4/2022
Les packages
Un package regroupe un certain nombre de classes qui

sont proche dans une seule famille
Les packages sont eux même organisés
hérarchiquement
Les nom des packages suivent le schéma:
name.subname
Une classe Watch appartenant au package time.clock
doit se trouver dans le fichier time/clock/Watch.class
Les packages permettent au compilateur et à la JVM de
localiser les fichier contenant les classes à charger
L’instruction package indique à quel package la ou les16
classe(s) du fichier .java 1
Les packages…
Il y a deux manières d’utiliser une classe stockée

dans un package:
En utilisant le non du package suivi du nom de la classe
java.util.Date now = new java.util.Date();

System.out.println(now);
16
2
81
10/4/2022
Les packages…
Il y a deux manières d’utiliser une classe stockée

dans un package:
En utilisant le non du package suivi du nom de la classe
En utilisant le mot clé import
import java.util.Date; // Doit être en tète du fichier

// Ne permet d’importer que la classe
// Date de java.util
Date now = new Date();
System.out.println(now);
16
3
La structure de stockage
des classes et des
packages
Seules les classes public sont accessibles d’un autre
package
Il ne peut y avoir qu’une seule classe public dans un fichier
Les fichiers des classes qui font partie d’un package
doivent être placés dans une hiérarchie des packages
// Fichier Classe1.java dans le répertoire test/util/

package test.util;
public class Classe1{
public void test () {…}
}
16
4
82
10/4/2022
Les principaux
packages du JDK
java.applet Classes de base pour les Applets
java.awt Interface utilisateur
java.lang Classes faisant partie du langage
java.io Entrées/Sorties, fichiers,…
java.math Utilitaires mathématiques
java.net Accès au réseau
java.security Gestion de la sécurité
java.sql Accès aux bases de données
java.util Conteneurs, dates,…
java.util.zip Pour compresser/décompresser
165
Les règles de visibilité
Pour les classes :

public : accès à tous
private : accès pour les classes du même fichier
Pour les méthodes et les attributs
public
protected
private
friendly (prise par défaut)
16
6
83
10/4/2022
Les règles de visibilité…
Accessible Méthodes de Classes Classes du Classes Classes

aux : la même dérivées dans même dérivées dans des autres
classe le même package un autre package
package package
public X X X X X
protected X X X X
friendly X X X
private X
167
Les règles de visibilité…

Pour respecter l’encapsulation des objets :
1. Les attributs doivent toujours être privés
2. Les attributs constants (final) peuvent être publics
ou privés
3. Les méthodes à usage strictement interne doivent
être privées
4. Si un attribut doit pouvoir être accessible de
l’extérieur : définir des méthodes publiques
permettant d’y accéder
16
8
84
10/4/2022
class Personne {
private String nom;
…
public Personne( String nom) {this.nom = nom;}
public String getNom( ) {return nom;}
}
…
Personne moi = new Personne ("Abdelhedi " );
System.out.println (moi.getNom( ));
16
9
Les classes imbriquées et

les classes anonymes
Il est possible de définir des classes dans des
classes :
Les classes imbriquées : Elles possèdent un nom et sont
définies au même niveau qu’une méthode ou un attribut
Les classes anonymes : Elles ne possèdent pas de nom et
sont définies là où elles sont utilisées
La visibilité de ces classes est limitée aux
méthodes de la classe dans lesquelles elles
sont définies
Elles ont accès à tous les éléments de cette
classe (même privés)
17
0
85
10/4/2022
Exemple de classes
imbriquées
class PileEnt {
private int s; pivate int p[ ] = new int[100];
public PileEnt ( ) {s = -1;}
public void empiler (int e) {s = s+1; p[s] = e;}
public void depiler ( ) { s = s-1;}
public int sommet ( ) {return p[s];}
public class Parcours {
private int courant;
public Parcours ( ) { courant = s;}
public void suivant ( ) { courant --;}
public int element ( ) { return p[courant]; }
}
}
PileEnt p = new PileEnt ( ); …
PileEnt.Parcours parc1 = p.new Parcours ( );
PileEnt.Parcours parc2 = p.new Parcours ( );
Parc1.element (); parc2.element ( );
17
1
Chapitre VI. La Gestion des Exceptions
17
2
86
10/4/2022
Problématique?
Java ne sait pas calculer cette

int i= 5 / 0; division mais elle génère une
int j=i+10; exception qu’il est possible
for (int k=0;k<j;k++) de récupérer. Après un
System.out.println(k); éventuel traitement, on poursuit
l'exécution du programme.
Dans ce cas précis c’est une exception

ArithmeticException qui est
produite. Si aucun code n'est prévu
pour traiter l'exception, le programme
s'arrêtera et l ’exception s'affichera sur
la console.
17
3
Exception (1) : Définition
Une exception est un signal qui indique que quelque chose

d'exceptionnel est survenu en cours d'exécution.
Deux solutions alors :
– laisser le programme se terminer avec une erreur,
– essayer, malgré l'exception, de continuer l'exécution
normale.
Lancer une exception consiste à signaler quelque chose
d'exceptionnel.
Capturer l'exception consiste à signaler qu'on va la traiter.
17
4
87
10/4/2022
Exception (2) :
Quelques exceptions prédéfinies
Division par zéro pour les entiers
– ArithmeticException
Tentative de création d'un tableau de taille négative

– NegativeArraySizeException
Dépassement de limite d'un tableau

– ArrayIndexOutOfBoundsException
17
5
Les Exceptions (3) ,

solution
int i= 5 / 0;
int j=i+10;
for (int k=0;k<j;k++)
System.out.println(k); Maintenant on décide de gérer l’exception
try
{ Quand une ArithmeticException est
int i= 5 / 0; levée, les instructions en dessous
int j=i+10; sont ignorées. Le programme
for (int k=0;k<j;k++) continue au niveau du bloc
System.out.println(k); de traitement catch de l'exception.
}
catch (ArithmeticException e)
{
System.out.println("exception, " +e); Après exécution du bloc
} de traitement, le programme
//Suite du programme se poursuit
17
6
88
10/4/2022
Exceptions (4) : Les

exceptions standard
catch (NegativeArraySizeException e)
{ System.out.println(" Exception taille tableau negative : " + e.getMessage());
}
catch (ArrayIndexOutOfBoundsException e)
{ System.out.println(" Exception indice tableau : " + e.getMessage()); }
}
}
taille voulue : -2
Exception taille tableau negative : -2
taille voulue : 10
indice : 15
Exception indice tableau : 15
17
7
Exceptions (5) :
Utilisation
Java exige qu'une méthode susceptible de lever une exception indique quelle
doit être l'action à réaliser.
– Sinon, il y a erreur de compilation.
Le programmeur a le choix entre :
– écrire un bloc try / catch pour traiter l'exception,
– laisser remonter l'exception au bloc appelant grâce à un throws.
C'est ce qu'on appelle : "Déclarer ou traiter".
Le bloc try est exécuté…
– … jusqu'à ce qu'il se termine avec succès
– … ou bien qu'une exception soit levée, les clauses catch sont examinées
l'une après l'autre dans le but d'en trouver une qui traite cette exception.
17
8
89
10/4/2022
Exceptions (6) : Utilisation
try
{ Autant de blocs catch que l'on veut.
...
}
catch (<une-exception>)
{
...
}
catch (<une_autre_exception>)
{
...
}
...
17
9
throws FirstException, SecondException

throws FirstException, SecondException
Handling More Than One Type of Exception
In Java SE 7 and later, a single catch block can handle more than one type of exception
try
{ Class Point
... { public Point(int x, int y) throws ErrConst1, ErrConst2
} { if ((x <0) || (y<0)) throws ErrConst3, ErrConst4
catch (<une-exception1>)
this.x = x; this.y = y;
catch (<une-exception2>)
catch (<une-exception3>) }
{
...
}
catch (<une_autre_exception>)
{
...
}
...
18
0
90
10/4/2022
Clone() method in
Java
Object cloning refers to the creation of an exact copy of an object. It
creates a new instance of the class of the current object and
initializes all its fields with exactly the contents of the
corresponding fields of this object.
Livre l1 = new Livre("Contes","Grimm",14.40,254)

Livre l2= l1.clone()
18
1

try
{
...
}
………..
catch (<une-exception>) // erreur : catch doit être contigu au bloc try

{
...
}
Règle : Toute méthode susceptible de déclencher une

exception qu’elle ne traite pas localement doit mentionner
son type dans une clause throws figurant dans son en-
tête.
18
2
91
10/4/2022
Exceptions (8) : Exemples
Class Point
{ public Point(int x, int y) throws ErrConst
{ if ((x <0) || (y<0)) throw new ErrConst();
}
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;
}
public void affiche()
{ System.out.println("coord : " + x + " " + y);
}
private int x, y;
}
18
3
class ErrConst extends Exception { }

class ErrDepl extends Exception { }
public class Except
{ public static void main (String args[])
{ try
{ Point a = new Point(1,4);
a.affiche();
a.deplace(-3,5);
a = new Point (-3,5);
a.affiche();
}
18
4
92
10/4/2022
catch (ErrConst e)
{ System.out.println(" Erreur construction " );
System.exit(-1);
}
catch (ErrDepl e)
{ System.out.println(" Erreur deplacement " );
System.exit(-1);
}
}
}
Coord : 1 4
Erreur deplacement
18
5
La construction suivante serait rejeté par le compilateur

// définition des classes Point, ErrConst et ErrDepl
public class Except
{ try
a.deplace(2,5);
}
catch (ErrConst e)
System.exit(-1);
} 18
6
93
10/4/2022
Exceptions (11) : Transmission

d’information au gestionnaire
d’exception
Class Point
{ if ((x <0) || (y<0)) throw new ErrConst(x,y);
}
}
private int x, y;
}
class ErrConst extends Exception {
ErrConst (int abs, int ord)
{this.abs = abs; this.ord = ord;} public int abs, ord; }
18
7
Exceptions (11) : Transmission d’information au

gestionnaire d’exception
public class Exinfo1 Catch (ErrConst e)

{ public static void main (String args[]) {System.out.println(" Erreur
construction Point" );
{ try
System.out.println("coord
souhaitees " + e.abs + " " +
a.affiche(); e.ord);
a = new Point (-3,5); System.exit(-1);
a.affiche(); }
} }
Coord : 1 4 }
Erreur construction Point
Coord souhaitees : - 3 5
18
8
94
10/4/2022

d’information au gestionnaire
d’exception
Class Point
{ if ((x <0) || (y<0)) throw new ErrConst(" Erreur construction avec coordonnees
" + x + " " + y);
}
}
private int x, y;
}
class ErrConst extends Exception {
ErrConst (String mes) {super(mes);}}
18
9

d’information au gestionnaire d’exception
public class Exinfo2 Catch (ErrConst e)

{ public static void main (String args[]) {System.out.println(
e.getMessage());
{ try
System.exit(-1);
}
a.affiche();
}
}
a.affiche();
}
Coord : 1 4
Erreur construction avec coordonnees : - 3 5
19
0
95
10/4/2022
Exceptions (14) : Poursuite de l’exécution
// définition des classes Point, ErrConst et ErrDepl

public class Suitex
System.out.println(" Avant bloc try " );
{ try
a.affiche();
a.affiche();
}
19
1
Exceptions (15) : Poursuite de l’exécution
catch (ErrConst e)
}
catch (ErrDepl e)
{ System.out.println(" Erreur deplacement " );
}
System.out.println(" apres bloc try " );
}
}
Avant bloc try
Coord : 1 4
Erreur construction
Apres bloc try
19
2
96
10/4/2022
Exemple
Prenons l’exemple de l’exercise livre
1. Gérer les exceptions standards ou prédéfinies qui peuvent être déclencher lors de la création de la
classe livre (2 pts)
2. Définir une exception Errprixlivre qui permet d’afficher un message d’erreur dans le cas où le prix
de n’importe quel livre est négative lors de la construction des classes. (2 pts)
19
3
Les applets, les servlets, les flux

d’entrées / sorties, … avec Java
19
4
97
10/4/2022
•Les applets et les servlets Java

Applet et servlet sont les petits programmes ou applications Java. Mais, les deux sont traités dans un
environnement différent. La différence fondamentale entre une applet et une servlet réside dans le fait
qu'une applet est exécutée côté client alors qu'une servlet est exécutée côté serveur. Les deux d'entre
eux diffèrent dans de nombreux contextes, étudions la différence entre applet et servlet à l'aide du
tableau de comparaison
Base de comparaison Applet Servlet

Exécution L'applet est toujours exécuté du La servlet est toujours exécutée
côté client. côté serveur.
Paquets importer java.applet. *; import javax.servlet. *;

importer java.awt. *; import java.servlet.http. *;
etc …. ….
19
5
Creer une applet java ‘ exemple-appl’ qui

calculi la somme des elements d’un tableau
19
6
98
10/4/2022
Les Applets
Une applet est un programme Java qui s'exécute dans un logiciel de navigation supportant Java
import java.applet.Applet;
import java.awt.Graphics;
public class gemoetry extends Applet { // Overriding paint()
public void paint(Graphicsg)

{
g.drawString(“bonjour", 20, 20);
}}
19
7
Transformation d’une application en une applet ?

Écriture d’un fichier HTML permettant de lancer une applet ?
Le code HTML
<HTML>
<HEAD>
<TITLE> Une petite applet </TITLE>
<BODY>
<APPLET CODE=‘ geometry.class' WIDTH=200 Height=50>
</APPLET>
</BODY>
</HTML>
19
8
99
10/4/2022
Les Servlets
A la base, les serveurs web sont seulement capables de renvoyer des fichiers présents sur le
serveur en réponse à une requête d'un client. Cependant, pour permettre l'envoi d'une page
HTML contenant par exemple une liste d'articles répondant à différents critères, il faut créer
dynamiquement cette page HTML. Plusieurs solutions existent pour ces
traitements. Les servlets Java sont une de ces solutions.
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ServletDemo extends HttpServlet {
private String message;
public void init() throws ServletException{
// Do required initialization
message = "Servlet Demo";

19
9
}
public void doGet(HttpServletRequest request,HttpServletResponse response) throws
ServletException, IOException{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println(message);
}
}
20
0
100
10/4/2022
•Les Flux d’entrées / sorties avec Java

Un programme a souvent besoin d'échanger des informations, que ce soit pour recevoir des
données d'une source ou pour envoyer des données vers un destinataire.
Les fichiers et les répertoires sont encapsulés dans la classe File du package java.io. Il n'existe pas
de classe pour traiter les répertoires car ils sont considérés comme des fichiers. Une instance de la
classe File est une représentation logique d'un fichier ou d'un répertoire.
Si le fichier ou le répertoire existe, de nombreuses méthodes de la classe File permettent d'obtenir
des informations sur le fichier. Sinon plusieurs méthodes permettent de créer des fichiers ou des
répertoires. Voici une liste des principales méthodes :
Méthode Rôle
boolean canRead() Indiquer si le fichier peut être lu
boolean canWrite() Indiquer si le fichier peut être modifié
boolean createNewFile() Créer un nouveau fichier vide
Créer un nouveau fichier dans le répertoire par défaut des fichiers

File createTempFile(String, String)
temporaires. Les deux arguments sont le nom et le suffixe du fichier
File createTempFile(String, String, Créer un nouveau fichier temporaire. Les trois arguments sont le nom, le
File) suffixe du fichier et le répertoire
Détruire le fichier ou le répertoire. Le booléen indique le succès de

boolean delete()
l'opération
20
1
Demander la suppression du fichier à l'arrêt de la

deleteOnExit()
JVM
boolean exists() Indique si le fichier existe physiquement
String getAbsolutePath() Renvoyer le chemin absolu du fichier
String getPath Renvoyer le chemin du fichier
boolean isAbsolute() Indiquer si le chemin est absolu
boolean isDirectory() Indiquer si le fichier est un répertoire
boolean isFile() Indiquer si l'objet représente un fichier
long length() Renvoyer la longueur du fichier
Renvoyer la liste des fichiers et répertoires contenus

String[] list()
dans le répertoire
boolean mkdir() Créer le répertoire
Créer le répertoire avec création des répertoires

boolean mkdirs()
manquants dans l'arborescence du chemin
boolean renameTo() Renommer le fichier
20
2
101
10/4/2022
Exemple1
Ecrire un programme Java pour créer un nouveau fichier text "fichier1.txt" dans lequel on
écrit le texte suivant "Début du texte 1";
import java.io.*;
public class NouveauFichier {
public static void main(String args[]) throws Exception {
FileWriter fw1 = new FileWriter("fichier1.txt"); // Écrase le fichier s'il existe déjà
BufferedWriter bw1 = new BufferedWriter(fw1);
bw1.write("Début du texte ");
bw1.close();
}
}
20
3
Exemple 2
Ecrire un programme Java pour écrire et lire un fichier texte/image
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class ExempleBufferedWriter {

try {
String content = "Ceci est le contenu ajouté au fichier";
File file = new File("test.txt");
// créer le fichier s'il n'existe pas

if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file.getAbsoluteFile());

BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close();
System.out.println("Modification terminée!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
20
4
102
10/4/2022
Exemple 3
Ecrire un programme Java pour écrire et lire un fichier image à travers un dossier compressé
(fichier ZIP)
import java.io.FileInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util .*;
import javax.imageio.ImageIO;
import java.lang.Math;
20
5
class ff1000{
public static void main(String[] args)throws IOException{
String zipname = "ap.zip";

try {
FileInputStream fis = new FileInputStream(zipname);
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
ZipEntry entry;
while ((entry = zis.getNextEntry()) != null) {
System.out.println("Unzipping: " + entry.getName());
int size;
byte[] buffer = new byte[2048];
FileOutputStream fos = new FileOutputStream(entry.getName());
BufferedOutputStream bos = new BufferedOutputStream(fos, buffer.length);
while ((size = zis.read(buffer, 0, buffer.length)) != -1) {
bos.write(buffer, 0, size);
}
bos.flush();
bos.close();
}
zis.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
//////////////////////////////////////
20
6
103
10/4/2022
String zipname1 = "t1000.zip";

try {
FileInputStream fis1 = new FileInputStream(zipname1);
ZipInputStream zis1 = new ZipInputStream(new BufferedInputStream(fis1));
ZipEntry entry1;
while ((entry1 = zis1.getNextEntry()) != null) {
System.out.println("Unzipping: " + entry1.getName());
….
Suite du code
207
Chapitre VII. Interface Graphique

Utilisateur
20
8
104
10/4/2022
Modèle événementiel du
JDK 1.1
Le modèle événementiel de JDK 1.1 se compose :
d'objets sources d'événements
d'objets événements
d'objets récepteurs d'événements
Ces objets interagissent de façon standard en invoquant des méthodes pour

permettre le déclanchement et la gestion des événements
actionPerformed(unEvnt ) JButton Source
Récepteur MonBouton
d’événements unObjet d’événements
2
Activer
getSource()
3 1 new ActionEvent( )
ActionEvent
unEvnt
20
9
Sources et écouteurs
d’événements
Événements générés par des sources d’événements (« event sources »)

Source d’événements, un objet capable de :
déterminer quand un événement « intéressant » s'est produit
d'avertir (« notify ») des objets récepteurs (« event listeners ») de l'occurrence de
cet événement
actionPerformed(unEvnt ) 2 JButton Source

Récepteur MonBouton
d’événements unObjet ... d’événements
Activer
actionPerformed(unEvnt ) 3
Implémente l’interface
d’écoute ActionListener
21
0
105
10/4/2022
Rappel
JFrame
Construction de l’interface graphique
EditeurGraphique
JPanel
BarreOutils 2
ZoneDessin
3
BarreEtat
Gestion de l’interaction MouseEvent
1
Déplacement de la souris sur la zone de dessin doit mettre à jour les coordonnées du curseur
dans la barre d’état
• Type d’événement : MouseEvent (MOUSE_MOVED, MOUSE_DRAGGED) 1
• Source : la zone de dessin 2
• Récepteur : la zone de dessin également 3
21
1
rappel
Code de la classe lançant l’application
public class EditeurGraphique extends JFrame {

final static int HAUTEUR = 450;
final static int LARGEUR = 750;
public EditeurGraphique { L’objet zone graphique a connaissance de
l’objet barre d’état pour pouvoir agir sur lui
BarreEtat barreEtat = new BarreEtat(); lors de la réception des MouseEvent
setTitle("Ma première Fenêtre");

setSize(LARGEUR,HAUTEUR);
setJMenuBar(new MenuEditeur());
this.getContentPane().add(new BarreOutils(),"North");
this.getContentPane().add(new ZoneGraphique(barreEtat),"Center");
this.getContentPane().add(barreEtat,"South");
barreEtat.afficheInfo("coordonnées du cruseur");
setVisible(true);
}

{
new EditeurGraphique();
}
21
} // MyFrame 2
106
10/4/2022
rappel
Code de la classe représentant la zone graphique
import java.awt.*;
import java.awt.event.*;
public class ZoneDessin extends JPanel implements MouseMotionListener {

private BarreEtat be;
1 L’objet zone dessin va être à
public ZoneDessin(BarreEtat be) { l’écoute des événements MouseEvent de
setBackground(Color.white); type MouseMotion
setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
this.be = be; L’objet zone dessin s’enregistre lui-même
this.addMouseMotionListener(this); 3 comme récepteur des événements
} MouseEvent de type MouseMotion qu’il est
susceptible de générer
public void mouseMoved(MouseEvent e) {
be.afficheCoord(e.getX(),e.getY());
} L’objet zone dessin utilise les informations
2 contenues dans l’objet MouseEvent qui lui
public void mouseDragged(MouseEvent e) { est transmis pour mettre à jour la barre
be.afficheCoord(e.getX(),e.getY()); d’état.
}
} // ZoneGraphique
21
3
Adaptateurs d’événements
Fermeture de la fenêtre
JFrame Clic doit

provoquer arrêt de l’application
EditeurGraphique
public class EditeurGraphique

extends JFrame {

public EditeurGraphique {
setSize(LARGEUR,HAUTEUR); Pas utilisable si on veut un
setJMenuBar(new MenuEditeur()); comportement plus spécifique, par
exemple ne quitter l'application que
this.getContentPane().add(new BarreOutils(),"North"); si l'utilisateur le confirme.
...
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
Il faut alors définir
setVisible(true); explicitement le code de
} gestion des événements sur
la fenêtre
21
4
107
10/4/2022
JFrame
Clic doit
provoquer arrêt de l’application
EditeurGraphique
2
WindowEvent
1 3
• Type d’événement : WindowEvent (WINDOW-CLOSING) 1

• Source : l’éditeur graphique (JFrame) 2
• Récepteur : l’éditeur graphique 3
21
5
Adaptateurs
Code de l’Editeur Graphique d’événements
import java.awt.event.*; Fermeture de la
public class EditeurGraphique extends JFrame {implements WindowListener {
public EditeurGraphique {
fenêtre 1 L’objet éditeur graphique
va être à l’écoute des
événements WindowEvent
BarreEtat barreEtat = new BarreEtat();

setSize(LARGEUR,HAUTEUR);
setJMenuBar(new MenuEditeur());
this.getContentPane().add(new BarreOutils(),"North");
this.getContentPane().add(new ZoneGraphique(barreEtat),"Center");
this.getContentPane().add(barreEtat,"South");
barreEtat.afficheInfo("coordonnées du cruseur");
this.addWindowListener(this) L’objet éditeur graphique s’enregistre lui-
2 même comme récepteur des
WindowEvent qu’il
setVisible(true);
est susceptible de générer
}
Mais maintenant il faut aussi implémenter

public static void main(String[] args) les méthodes de l’interface WindowListener
{
new EditeurGraphique();
}
21
} // MyFrame 6
108
10/4/2022
WindowEvent
définit plusieurs <interface> WindowListener
sous types d’événements
WINDOW_ACTIVATED WindowListener windowActivated(WindowEvent)
Invoked when a window is activated
WINDOW_CLOSED définit plusieurs
windowClosed(WindowEvent)
WINDOW_CLOSING méthodes, une pour Invoked when a window has been closed.
WINDOW_DEACTIVATED chacun de ces types windowClosing(WindowEvent)
Invoked when a window is in the process of being closed.
WINDOW_DEICONIFIED windowDeactivated(WindowEvent)
WINDOW_ICONIFIED Invoked when a window is de-activated.
WINDOW_OPENED
public class EditeurGraphique extends JFrame windowDeiconified(WindowEvent)
implements WindowListener { Invoked when a window is de-iconified.
windowIconified(WindowEvent)
public EditeurGraphique() { Invoked when a window is iconified.
… windowOpened(WindowEvent)
this.addWindowListener(this); Invoked when a window has been opened.
setDefaultCloseOperation(
WindowConstants.DO_NOTHING_ON_CLOSE); Dans le cas présent seuls les événements
this.setVisible(true); WINDOW_CLOSING nous intéressent.
} Mais quand on implémente une interface il faut
public void windowClosing(WindowEvent e){ implémenter toutes les méthodes qu’elle définit
if (JOptionPane.showConfirmDialog(this, public void windowActivated(WindowEvent e){;}
"Voulez-vous vraimment quitter ?", ...
null, JOptionPane.YES_NO_OPTION) == 0)
public void windowOpened(WindowEvent e){}
System.exit(0);
}
corps vide
} 21
7
Adaptateur d’événements
WindowAdapter dans
package java.awt.event
Étendre la classe WindowAdapter
et n’implémenter que la méthode
1 qui nous concerne
public class ClosingAdapter extends public class EditeurGraphique extends JFrame {

WindowAdapter {
public EditeurGraphique() {
public void windowClosing(WindowEvent e){ …
if(JOptionPane.showConfirmDialog(this, this.addWindowListener( new ClosingAdapter());
"Voulez-vous vraiment quitter ?", this.setVisible(true); Associer une instance de
null, JOptionPane.YES_NO_OPTION)
== 0)
} 2 cette classe à la fenêtre
System.exit(0); public static void main(String[] args){
} new EditeurGraphique();
}
} }
21
8
109
10/4/2022
Dessin des segments de droite
Gestion des événements souris

Déplacement de la souris sur
la zone de dessin met à jour
les coordonnées du curseur
dans la barre d’état
MOUSE_MOVED, MOUSE_DRAGGED
Appuyer sur un bouton de la
souris (MOUSE_PRESSED) définit
le début d’une droite
Relâcher le bouton de la
souris (MOUSE_RELEASED)
définit la fin de la droite
• type d’événement : MouseEvent
• source : zone de dessin < interface >
• interface d’écoute : MouseListener MouseListener
• récepteur : zone de dessin void mouseClicked(MouseEvent)
void mouseEntered(MouseEvent)
Comme pour la fermeture de la void mouseExited(MouseEvent)
fenêtre, seules deux des méthodes de void mousePressed(MouseEvent)
l’interface nous intéressent void mouseReleased(MouseEvent)
21
9
Des adaptateurs
aux classes internes
Gestion des boutons de la barre d’outil
Annule le dernier tracé

Efface toute la zone de dessin
• type d’événement : ActionEvent
• source : les JButton
• interface d’écoute : ActionListener
• récepteur ?
L’activation des boutons doit se traduire par un changement d’état de la zone de dessin.
Il semble naturel que cela soit la zone dessin qui récupère les événements et réalise les traitement adéquats.
22
0
110
10/4/2022
Des adaptateurs
import java.awt.*; 2) La zone dessin
import javax.swing.*; reçoit les événements
issus des boutons
public class ZoneDessin extends JPanel
, ActionListener {
implements MouseMotionListener {
1) C’est la zone private BarreEtat be; le code zone dessin
dessin qui dépend du code de la
effectue les public ZoneDessin(BarreEtat be) { barre d’outils.
….
traitements }
déclenchés par
les boutons public void mouseMoved(MouseEvent e) { ... }
• Quid si on supprime la
public void mouseDragged(MouseEvent e) { ... }
efface et barre d’outils et que
annule public void initieDroite(int x, int y) { ... } toutes les opérations
public void termineDroite(int x, int y) { ... } s’effectuent via la barre
public void efface() { ... }
public void annule() { ... } de menus ?
public void actionPerformed(ActionEvent e) • Lourdeur du code :

{ • si beaucoup de
selon l’origine de l’événement boutons à écouter
efface() ou annule()
}
• si plusieurs moyens
de déclencher ces
actions (boutons,
} // ZoneGraphique menus…) 22
1
Des adaptateurs
Le modèle événementiel de JAVA 1.1 peut rapidement devenir difficile à gérer

si un objet doit être à l’écoute d’un grand nombre d’objets sources,
il lui faut implémenter les interfaces appropriées à chacun de ces objets
si un objet est à l’écoute d’événements issus de deux objets (ou davantage) sources
d'événements du même type
l’objet récepteur ne peut implémenter qu’une seule fois l’interface réceptrice
d’événements, il lui faudra découvrir lui-même quel objet a émis l’événement
Cela peut conduire à du code difficile à lire et/ou difficile à écrire
Une solution : introduire un objet « médiateur » entre la source d’événements et le

récepteur d’événements
son rôle : adapter la source aux besoins spécifiques d’où le nom d’adaptateur
d’événements
22
2
111
10/4/2022
Des adaptateurs
import java.awt.*;
public class AdaptateurEfface implements ActionListener

{
ZoneDessin zone; Dans le code de BarreOutils
public adaptateurEfface(ZoneDessin z) {
zone = z; ...
} BarreOutils(ZoneDessin zd) {
public void actionPerformed(ActionEvent e) ...
{ JButton b;
zone.efface(); this.add(b= new JButton("Défaire"));
} b.addActionListener(new AdaptateurAnnule(zd));
} this.add(b = new JButton("Tout effacer"));
Adaptateurs d’événements b.addActionListener(new AdaptateurEfface(zd));
import java.awt.event.*; ...
import java.awt.*; }
...
public class AdaptateurAnnule implements ActionListener
{ • Simplification de ZoneDessin
ZoneDessin zone;
public AdaptateurEfface(ZoneDessin z) { • Meilleur découplage des différents
zone = z;
} éléments de l’interface utilisateur
public void actionPerformed(ActionEvent e) { Mais

zone.annule(); •multiplication du nombre de classes
}
•classes pas vraiment réutilisables
}
22
3
Classes internes
Trois types de classes internes :
Classe membre : définition de la classe à l’intérieur d’une classe, au même niveau que les
attributs et méthodes
class X {
class Member extends Superclass {…}
}
Classe locale : définition de la classe à l’intérieur d’une méthode
class X {
void work() {
class Local extends Superclass {…}
}
}
Classe anonyme : définition de la classe à l’intérieur d’une expression
class X {
void work() {
obj = new Superclass() {…}
}
} class Anonymous extends/implements Superclass
22
4
112
10/4/2022
Classes internes
classes membres
Classes membres
class X {
class Member extends Superclass {…}
}
Toute instance d’une classe membre est associée de manière interne à une instance de la
classe englobante
accès implicite aux membres (attributs/méthodes) définis dans la(les) classe(s)
englobante(s), (y compris les membres privés)
exemple : (d’après Java In a Nutshell, 2nd Edition, D. Flanagan, O ’Reilly)
Implémentation d’une liste chaînée
public class LinkedList {
private Linkable head;
public interface Linkable { ...
public Linkable getNext(); public void insert(Linkable node) {
public void setNext(Linkable node); ...
} }
Ajouter à la liste chaînée la possibilité de parcourir les public void remove(Linkable node) {
éléments à l’aide d’un Iterator ...
}
public interface Iterator { public Iterator iterator() {
public boolean hasNext(); ...
public Object next(); }
} }
22
5
Classes internes
Nécessité de passer classes membres
explicitement un objet
LinkedList dans le
Sans classe membre Avec une classe membre
constructeur et de rendre
public class LinkedList { accessible l'attribut head public class LinkedList {
...
...
public void insert(Linkable node) {
...
...
}
}
public void remove(Linkable node) {
... public void remove(Linkable node) { Plus besoin de passer
} ... l’objet LinkedList dans
}
public Iterator iterator() {
le constructeur
...
return new LinkedListIterator(this);
...
return new LinkedListIterator();
}
} }
private class LinkedListIterator implements Iterator{
private Linkable current;
class LinkedListIterator public LinkedListIterator() {

implements Iterator { current = head;
head;
}
private Linkable current; public boolean hasNext() {
return current != null;
public LinkedListIterator(LinkedList l) { }
public Object next() {
current = l.head; if(current == null)
} throw NoSuchElementException(«LinkedList»);
public boolean hasNext() { Object value = current;
return current != null; current = current.getNext();
} return value
public Object next() { }
if(current == null) }
throw NoSuchElementException("LinkedList");
Object value = current;
}
Accès direct aux membres (même privés) de la
current = current.getNext(); classe englobante
return value
}
}
22
6
113
10/4/2022
Comment cela marche ? Classes internes

classes
Toute instance d’une classe membremembres public class LinkedList {
...
est associée de manière interne à une public void insert(Linkable node) {
...
instance de la classe englobante }
public void remove(Linkable node) {
...
}
public Itrator iterator() {
}
return new LinkedListIterator();(this); 3
private class LinkedListIterator implements Iterator{
le compilateur insère auto- private Linkable current;
matiquement un attribut privé
private LinkedList container; 1
public LinkedListIterator() (LinkedList
{ l) {
pour contenir cette référence 1 container = l; 2
current = head;
}
le compilateur ajoute auto- public boolean hasNext() {
return current != null;
matiquement un argument caché à }
tous les constructeurs de la classe public Object next () {
if(current == null)
membre 2 throw NoSuchElementException(«LinkedList»);
Object value = current;
current = current.getNext();
et passe l’objet contenant en return value
}
valeur de cet argument 3 }
}
22
7
Classes internes
classes membres
Accès implicite aux champs (attributs/méthodes) définis dans la(les) classe(s)
englobante(s), (y compris les champs privés)
...
private class LinkedListIterator implements Iterator {

private Linkable current;
public LinkedListIterator() {
current = head;
}
...
}
this.current = this.head; this.current = LinkedList.this.head;
Pas d’attribut head dans Syntaxe pour faire référence explicitement à

la classe membre l’instance contenante de l’instance courante
de la classe membre
22
8
114
10/4/2022
Classes internes
classes membres
Hiérarchie d’imbrication et hiérarchie d’héritage sont totalement distinctes l’une de
l’autre
héritage : définit les champs (attributs, méthodes) dont hérite la classe membre
imbrication : définit les champs qui sont dans la portée (accessibles) de la classe membre.
import java.util.*;
public class A {
int a; public class C {
Vector a;
class B extends C ...
{ }
a ??
} En cas de conflit, le compilateur le signale :
Variable 'a' is inherited in inner class A.B, and hides a
variable of the same name in class A. An explicit 'this'
qualifier must be used to select the desired instance.
}
this.a est un Vector
A.this.a est un int
Restrictions sur les classes membres

ne peuvent avoir un nom identique à celui de l’une des classes englobantes
ne peuvent contenir de membres (attributs, méthodes ou classe) static
22
9
Classes internes
classes membres
Compilation de classes membres

La machine virtuelle JAVA n’a pas été modifiée pour la prise en compte des classes internes
Le compilateur doit convertir les classes internes en classes standard (top-level classes) que
l’interpréteur JAVA peut comprendre
C’est effectué à l’aide de transformations du code source (insertion ‘ $ ’ dans le nom des
classes internes, insertion d’attributs et paramètres cachés...).
class LinkedListIterator
{
}
javac LinkedList.class
LinkedList.java
LinkedList$LinkedListIterator.class
23
0
115
10/4/2022
Classes internes
classes locales
Classes locales : définies à l’intérieur d’un bloc de code

class X {
void work() {
class Local extends Superclass {…}
}
}
Une classe locale est une classe interne, elle partage bien des caractéristiques des classes
membres.
Une classe locale est aux classes membres ce qu’est une variable locale aux variables
d’instance
uniquement visible et utilisable dans le bloc de code où elle est définie
elle peut utiliser n’importe quelle variable locale (ou paramètre de méthode) visible à
l’endroit où elle est définie à condition qu’elle (ou qu’il) soit déclaré final
exemple : (toujours d’après Java In a Nutshell, 2nd Edition, D. Flanagan, O ’Reilly)
23
1
Classes internes
classes locales
Classe membre Classe locale
...
...
public void insert(Linkable node) { ...
...
}
} public void remove(Linkable node) {
public void remove(Linkable node) { ...
...
}
}
return new LinkedListIterator(); class LinkedListIerator implements Iterator {
} private Linkable current;
private class LinkedListIterator implements Iterator {
private Linkable current; public LinkedListIterator() {
current = head;
public LinkedListIterator () { }
current = head; public boolean hasMoreElements() {
} return current != null;
public boolean hasNext() { }
return current != null; public Object nextElement() {
} if(current == null)
public Object next () { throw NoSuchElementException(«LinkedList»);
if(current == null) Object value = current;
throw NoSuchElementException(«LinkedList»); current = current.getNext();
Object value = current; return value
current = current.getNext(); }
return value }
}
} return new LinkedListIterator();
} La définition de la classe est encore rapprochée

}
} de l’endroit où elle est utilisée -> augmente la
clarté du code (?)
23
2
116
10/4/2022
Classes internes
classes locales
Ce qui différencie une classe locale d’une classe membre est qu’elle a en plus
accès aux variables locales (et paramètres) visibles dans son bloc de définition.
public class A {
private int a;
javac ClasseA.java
...
public void methodeX(int param1, int param2){ A.java:13: local variable param2 is accessed from
int local1; within inner class; needs to be declared final
double local2; if (param2 == 0 && local2 < 0.0) {
local2 = ... ;
^
class B {
private int b;
A.java:13: local variable local2 is accessed from
within inner class; needs to be declared final
if (param2 == 0 && local2 < 0.0) {
^
public B() {
... 2 errors
} if (param2 == 0 && local2 < 0.0) {
...methodY() {
public void Compilation exited abnormally with code 1 at Mon
a} = ... ;
Mar 18 07:22:02
Pourquoi ?
}
...
} // fin classe B
...
new B()
...
} // fin methode x 23
... 3
Classes internes
classes locales
Ce qui différencie une classe locale d’une classe membre est qu’elle a en plus
accès aux variables locales (et paramètres) visibles dans son bloc de définition.
Mais à condition que ces variables et paramètres soient déclarés final
Comment et pourquoi ?
Une classe locale peut accéder aux
public class A { variables locales car le compilateur
private int a;
...
final ajoute automatiquement :
public void methodeX(int param1, int param2){
final
int local1; • des attributs privés pour stocker une
double local2; copie des variables locales 1
local2 = ... ;
class B { • des paramètres cachés aux
private
private int b;
attributCaché1; 1 constructeurs de la classe membre pour
private double attributCaché2;
(private int pCaché1, double pCaché2) { initialiser ces attributs privés créés
2
public B() { automatiquement.
...
} 2
...
} Le seul moyen de maintenir ces copies
B(param2,local2)
en accord avec les variables locales est
...
new B()
de définir ces dernières comme finales
...
} // fin methode x
...
} 23
4
117
10/4/2022
Classes internes
classes locales
Restrictions sur les classes locales
comme les classes membres elles ne peuvent contenir de champs (attributs ou

méthodes) static
comme les classes membres elles ne peuvent avoir le même nom que l’une des classes
englobantes
elles ne peuvent être déclarées public, protected, private ou static (de la

même manière que ces modifieurs ne sont pas autorisés pour des variables locales)
23
5
Classes internes
classes locales
Une utilisation très courante des classes locales est pour la réalisation d’adaptateurs
d’événements
Reprenons la gestion des boutons de la barre d’outils de l’éditeur graphique
Annule le dernier tracé

Efface toute la zone de dessin
• type d’événement : ActionEvent

• source : les JButton
• interface d’écoute : ActionListener
Récepteur : utilisation d’une classe locale dans le constructeur de la barre d’outils
23
6
118
10/4/2022
Des adaptateurs
Dans le code de BarreOutils
aux classes
import java.awt.*; import java.swing.*;
internes
public class BarreOutils extends JPanel {
public BarreOutils( final ZoneDessin zd) {

...
final
JButton bDefaire = new JButton("Défaire");
Variables this.add(bDefaire);
final
Classe interne
déclarées JButton bEffacer = new JButton("Tout effacer"); adaptateur
this.add(bEffacer);
finales pour les ...
class BOActionListener implements ActionListener { d’événements
rendre public void actionPerformed(ActionEvent e) {
accessibles if (e.getSource() == bDefaire)
zd.defaire();
dans le code else if (e.getSource() == bEffacer)
de la classe zd.efface();
interne }
Création d’une
}
instance de
BOActionListener boAL = new BOActionListener();
bDefaire.addActionListener(boAL);
la classe interne
bEffacer.addActionListener(boAL); qui est à l’écoute
des boutons
...
}
23
7
Classes internes
classes locales
Compilation de classes locales
A.java
public class A {
void methodA() {
class B
{ javac A.class
}
void methodB() {
class B extends C
{
} A$1$B.class
}
}
A$2$B.class
23
8
119
10/4/2022
Classes internes
classes anonymes
Classes locales : définies à l’intérieur d’un bloc de code
class X {
void work() {
obj = new Superclass() {…}
}
} class Anonymous extends/implements Superclass
Une classe anonyme est une classe locale sans nom

Permet de regrouper définition et instanciation d’une classe locale
Très couramment utilisées en tant qu’adaptateurs d’événements
23
9
Classes internes
classes anonymes
Avec une classe locale Avec des classes anonymes
Import java.swing.*; import java.awt.event.*;
import java.awt.event.*; import java.awt.*;
import java.awt.*; Import java.swing.*;
public BarreOutils(final ZoneDessin zd) {
public BarreOutils(final ZoneDessin zd) { ...
... JButton bDefaire = new JButton("Défaire");
final JButton bDefaire = new JButton("Défaire"); this.add(bDefaire);
this.add(bDefaire); JButton bEffacer = new JButton("Tout effacer");
final JButton bEffacer = new JButton("Tout effacer"); this.add(bEffacer);
this.add(bEffacer); ...
... bDefaire.addActionListener(
class BOActionListener implements ActionListener { new ActionListener() {
public void actionPerformed(ActionEvent e) { public void actionPerformed(ActionEvent e)
if (e.getSource() == bDefaire) {
zd.defaire(); zd.defaire();
else if (e.getSource() == bEffacer) }
zd.efface(); }
}
} );
bEffacer.addActionListener(
BOActionListener boAL = new BOActionListener(); new ActionListener() {
bDefaire.addActionListener(boAL); public void actionPerformed(ActionEvent e)
bEffacer.addActionListener(boAL); {
... zd.efface();
}
} }
);
Classe anonyme adaptateur ...
d’événements pour le JButton }
24
0
120
10/4/2022
Classes internes
classes anonymes
( liste
new NomDeClasse() { d’arguments ) new NomDinterface() {
{
corps de la classe corps de la classe
} }
classe anonyme sous-classe de la classe classe anonyme implémente l’interface

NomDeClasse NomDinterface
dans ce cas la classe anonyme est sous-
classe de Object
Une classe anonyme n’ayant pas de nom il n’est pas possible de définir de constructeur dans son corps
Les arguments éventuellement spécifiés après Jamais d’arguments après NomDinterface

NomDeClasse sont implicitement passés en puisque le constructeur de la super-classe
paramètre du constructeur de cette super-classe (Object) n’a pas d’arguments
24
1
Classes internes
classes anonymes
sans classe interne avec classe interne anonyme

public class EditeurGraphique extends JFrame {
public class ClosingAdapter extends
WindowAdapter {
public void windowClosing(WindowEvent e) public EditeurGraphique() {

{
System.exit(0);
...
} this.addWindowListener(
new WindowAdapter() {
} public void windowClosing(WindowEvent e)
{
public class EditeurGraphique System.exit(0);
extends JFrame implements WindowListener { }
}
public EditeurGraphique() {
...
this.addWindowListener(new ClosingAdapter()); );
this.setVisible(true); this.setVisible(true);
}
}
{ new EditeurGraphique(); public static void main(String[] args)
} { new EditeurGraphique();
}
}
}
24
2
121
10/4/2022
Classes internes
classes anonymes
Comment choisir entre écrire une classe locale ou écrire une classe anonyme
choisir ce qui rend le code plus clair
Classe anonyme
la classe doit avoir un corps petit
une seule instance de la classe est nécessaire
la classe est utilisée juste après qu’elle soit définie
le nom éventuel de la classe ne rend pas le code plus facile à comprendre
Classe locale
la classe doit avoir plusieurs instances
la classe nécessite un constructeur
24
3
Classes internes
classes anonymes
Compilation de classes anonymes
A.java
public class A {
new B()
{ javac A.class
}
new C()
{
}
A$1.class
A$2.class
24
4
122

Chapitre 1 POO

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 1 POO

Transféré par

Droits d'auteur :

Formats disponibles

10/4/2022

POO: Programmation-Orientée Objet

Chapitre I. Introduction et Eléments de Base

A) Programmation procédurale VS programmation OO

C’est quoi la programmation procédurale?

Dans la programmation procédurale le programme est divisé

partie, une ou plusieurs fonctions sont utilisées.

C’est quoi la Programmation Orientée Objet (POO)?

Dans la programmation orientée objet le programme est divisé

B) Principes de base de la POO

Principes de bases (suite)

Principes de bases de la POO

Pour l’utilisateur du type abstrait de

Mais en utilisant un type abstrait

Notion de contrat (Eiffel)

Trois exemples de base

La classe Applet contient ce qu’il faut

Pour exécuter l’applet

Html pour l’applet

Exemple interface graphique

Les types de Base

Types d’opérateurs Listes des opérateurs

Arithmétiques +, -, *, /, %, ++,--, +=, -=,…

Binaire bit à bit <<, >>,…

De comparaison ==, !=, <,>,<=, >=

Les structures de contrôle

Essentiellement les mêmes qu’en C

LES CONSTRUCTEURS EN JAVA

public class Personne {

public Personne(String nom, int age) {

// méthode principale (main)

Il existe deux types de constructeur en Java

public class Personne {

// constructeur par défaut

public void affiche() {

// méthode principale (main)

public void affiche() {

// méthode principale (main)

Les structures de contrôle…

Chapitre II Classes et objets

Précède la déclaration de la classe

IV) Vie et mort des objets,

Création d’une instance: opérateur new

Une variable est (en général) une référence à

Rappel sur les Constructeurs

Appelés par l’opérateur new pour créer un

Statique <-> à la compilation

private static long nextId = 0;

Le main est le point d’accès et peut avoir des arguments:

Forme générale d’une classe

void setState (boolean newstate) { // Ceci est une

Les attributs (== les champs)

Les méthodes statiques

Définies avec le mot clé static

Permettent d’initialiser les objets de la classe

Destruction d’un objet

Destruction d’un objet…

public class Circle {

Le mot clé this représente une référence sur

La référence sur l’objet

Date() {an = 2002;} // peut aussi s’écrire : this.an

Chapitre III Héritage

Chapitre III: Héritage

final class Circle extends Ellipse {