ENSA de Fès GTR2

Le langage JAVA

Année universitaire 2016-2017 1

Sommaire

• Introduction à Java
• La syntaxe
• Les concepts Objet
• Classes, méthodes, attributs
• Héritage, polymorphisme, encapsulation
• Les interfaces
• Les classes de base
• Les exceptions
• Les entrées-sorties

2
Introduction à Java

3
Introduction à Java

Origine du langage
 Développé par SunSoft pour réaliser le développement de
systèmes embarqués

 Projet « Oak »

 Évolution gérée par JavaSOFT (SunSoft)

 Quelques liens
– http://www.javasoft.com/
– http://www.sunsoft.com/
– http://www.developer.com/directories/pages/dir.java.htm/
(anciennement www.gamelan.com)
– http://www.javaworld.com/
– http://tips.iworld.com/ sélectionnez « Java »
4
Introduction à Java

Java est simple

 Simplicité relative par rapport au C++

 Certains concepts du C++ à l’origine de nombreux

bugs ont été supprimés
– Pointeurs
– Surcharge des opérateurs
– …

 Des études comparatives de développements

montrent une diminution du coût de développement
de 30 à 35 %

5
Introduction à Java

Java est un langage objet

 Java reprend des caractéristiques de différents langages à
objets
– La syntaxe du C++
– La gestion dynamique de la mémoire SmallTalk
– Certains concepts de ADA et Objective C

 Toute ligne de code JAVA se trouve obligatoirement dans une

méthode à l’intérieur d’une classe

 Java est un langage intermédiaire entre les langages statiques

(C++) et les langages interprétés (SmallTalk)

 Nombreuses classes permettant le développement de

systèmes répartis
– Classes d’accès aux ressources d’un serveur Web

6
Introduction à Java

Java est robuste

 Le compilateur Java est très strict

 Contrôle de typage « fort »

 Le compilateur vérifie que les erreurs sont traitées par le

développeur
– Si une erreur retournée par une méthode n’est pas traitée, le
programme ne compilera pas

 La gestion de la mémoire n’est pas à la charge du développeur

– Garbage Collector (« ramasse-miettes)
– Pas de pointeurs

 Un débordement d’index dans un tableau provoque une erreur

– La mémoire n’est pas écrasée
7
Introduction à Java

JAVA est portable

 Un code source Java est compilé pour générer un code
assembleur virtuel : le byte code

 Ce code est conçu pour :

– Etre rapidement interprété
– Etre optimisable au moment de son exécution
– Etre facilement traduit en instructions assembleur lors de son exécution
– Etre compact
• en moyenne, une instruction byte code = 1,8 octet, RISC = 4 octets
– Etre vérifiable

 Le byte code est exécuté par un logiciel : la Machine virtuelle

 La machine virtuelle est dépendante de la plate-forme

8
 Introduction à Java

Java est performant !

Prog.java Prog.java Prog.java

Prog.class Prog.class
Compilateur
MV+
MV
JIT

Code binaire
Code binaire
en mémoire

Système Système Système

d’exploitation d’exploitation d’exploitation
9
Introduction à Java

JAVA est sécurisé

 Le compilateur interdit toute manipulation en mémoire

 Le Verifier contrôle que le byte code chargé dans la machine

virtuelle est conforme

 Le ClassLoader est responsable du chargement des classes

dans le « SandBox ». Il vérifie que la classe chargée n’en
écrase pas une autre en mémoire

 Le SecurityManager contrôle les opérations d’entrée/sortie

locales et sur le réseau (Applet uniquement)

La portabilité de Java permet de déplacer dynamiquement du

code Java sur un réseau

10
 Introduction à Java

JAVA supporte le multi-threading

 La gestion des multi-threads est intégrée dans le

langage et dans la Machine Virtuelle
 Grande simplification
 Java permet de synchroniser les threads

Multi-processus Multi-thread
Mémoire Mémoire

P1 P2 T1 T2
Inter-process Synchronisation
11
Introduction à Java

Le JDK

 Le JDK = Java Development Kit

– Ancienne version : 1.0.2
– Version actuelle : 1.2

 Il contient :
– Un ensemble de classes de base regroupées en packages
• Interface utilisateur, conteneurs, gestion des threads, réseau…
– Des exécutables : machine virtuelle, compilateur…
– Des bibliothèques permettant de coupler du Java et du C

 Peut être téléchargé sur http://www.javasoft.com/

 Il est gratuit

12
Introduction à Java

Les environnements de développement

 Ils offrent des fonctions avancées :

– Éditeur évolué (couleur, autocorrection, présentation…)
– Assistance syntaxique
– Générateur de code
– Débugage
– Environnement d’exécution
– …

 L’offre actuelle
– Jbuilder 4 (Inprise)
– Visual J++ (Microsoft)
– Visual Age (IBM)
– Visual Cafe Pro
– …

13
Introduction à Java

Les classes de base

 AWT : Abstract Window Toolkit

– Classes d’IHM : boutons, listes, gestion générique de la
géométrie, traitement des événements par abonnement,
copier/coller, glisser/déplacer
 Réseau
– Sockets (serveurs, clients), Web (URL), Applet…
 Entrée-sortie
– Fichier, Pipe, accès direct…
 Classes de base
– Conteneurs, date, Chaîne de caractéres
 RMI
– Remote Method Invocation
– Middleware objet 100 % java

14
Introduction à Java

Les classes de base

 JDBC
– Accès aux bases de données relationnelles
 Beans
– Composant Java
 Sécurité
– Cryptage, identification, signature
 Internationalisation
– Format de date/heure
– messages localisés
– caractères UNICODE 2
 JavaIDL
– Support de CORBA

15
Introduction à Java

Hello Word
class Hello {
int k = 5;
public static void main (String argv[])
{
Hello hello = new Hello();
for (int I = 0; I < hello.k; I++)
hello.SayHello();
}
public void SayHello()
{
System.out.println("Hello Java World !!! ");
}
}

Edit Hello.java
Javac Hello.java
Java Hello
16
La syntaxe

17
La syntaxe

Constitution d’un programme

 Un programme Java utilise un ensemble de classes

 Les classes sont regroupées par package
 Une classe regroupe un ensemble d’attributs et de
méthodes

Package

Classe
Attributs

Méthodes

18
La syntaxe

Déclaration d’une classe

 Le nom de la classe est spécifié derrière le mot clé

« class »
 Le corps de la classe est délimité par des accolades
 On définit dans le corps les attributs et les méthodes
qui constituent la classe

class Test {

< corps de la classe >

19
La syntaxe

Définition d’un méthode

 Une méthode est constituée de :
– D’un nom
– D’un type de retour
– De paramètres (éventuellement aucun)
– D’un bloc d’instructions
 Un paramètre est constitué :
– D’un type
– D’un nom
 « void » est le mot-clé signifiant que la méthode ne renvoie
pas de valeur
class Test {
int calculer (int taux, float delta) {
< corps de la méthode >
}
}

20
La syntaxe

Bloc d’instructions

 Un bloc d’instructions est délimité par des accolades

 Il contient un ensemble d’instructions
 Toute instruction est terminée par un point virgule
 Un bloc d’instructions peut contenir d’autres blocs
d’instructions

{
int i = 0;
if (i==0)
System.out.println ("Valeur de i : " + i);
}

21
La syntaxe

Instructions possibles

 Déclaration d’une variable

 Appel de méthode

 Affectation

 Instruction de boucle (while, for…)

 Instruction de test (if, switch)

22
La syntaxe

Corps d’une méthode

 Le corps d’une méthode est un bloc d’instructions

 Le mot clé « return » permet de renvoyer une valeur
à l’appelant de la méthode
 Il doit renvoyer une valeur du même type que le
type de retour de la méthode

class Test {
int calculer (int taux, float delta) {
return taux * delta;
}
}

23
La syntaxe

Déclaration d’une variable

 Une variable possède un type et un nom

 Le type peut être un type de base ou une classe
 L’initialisation d’une variable peut se faire au
moment de la déclaration

{
int compteur;
int indice = 0;

Voiture golf;
Voiture twingo = new Voiture();
}

24
La syntaxe

Portée d’une variable

 La portée d’une variable s’étend jusqu’à la fin du

bloc dans lequel elle est définie

{
{
int compteur;
…
// compteur est accessible
}

// compteur n’est plus accessible

}

25
La syntaxe

Nom de classes, de variables et de méthodes

 Un nom peut être constitué de lettres, de chiffres et du
caractère souligné

 Il ne peut pas commencer par un chiffre

 Le caractère $ est utilisable mais à éviter

 Les mots réservés (if, class, int…) ne peuvent pas être utilisés

 Les développeurs ont défini un consensus de nommage :

– Les mots du langage sont en minuscule
– Les noms de classe commencent par une majuscule
– Les noms de méthodes et de variables comment par une
minuscules
– Chaque mot qui compose le nom commence par une majuscule

26
La syntaxe

Point d’entrée

 Une application possède un point d’entrée fourni par

la méthode « main » (sauf les applets)
 Attention à la casse, Java est sensible aux
majuscules/minuscules

class Test {

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

…
// corps de la méthode main
}

27
La syntaxe

Les différents types de base (1/2)

 Types arithmétiques
byte 8 bits signé (-128 , 127)
short 16 bits signé (-32768 , 32767)
int 32 bits signé (-2147483648 , 2147483647)
long 64 bits signé (-9223372036854775808,
9223372036854775807)
float 32 bits signé (1.4E-45 , 3.4028235E38)
double 64 bits signé (4.9E-324 ,
1.7976931348623157E308)

 Type caractère
char 16 bits non signé UNICODE2
 Type booléen
boolean 1 bit deux valeurs possibles : true ou false
28
La syntaxe

Les différents types de base (2/2)

 Les types de base s’écrivent en minuscules (int,

float..)
 Le type « int » est codé sur 4 octets  portabilité
 Le type « char » est codé sur 2 octets pour
supporter les jeux de caractères Unicode
 Une chaîne de caractères est déclarée avec le mot-
clé « String »
– Ce n’est pas un type de base
– Il se manipule comme un type de base
– Ce n’est pas équivalent à un tableaux de caractères
String s = "Hello World"

29
La syntaxe

L’affectation

 L’opérateur « = » permet d’affecter la valeur de

l’expression qui est à droite à la variable qui est à
gauche

class Test {
int calculer () {
int i = 0;
int j = 6;
i = (j + 5) * 3;
return i + j;
}
}

30
La syntaxe

Les opérateurs arithmétiques

 S’appliquent sur les types entiers ou réels
– +, - , * , / , % (modulo) , += , -= , *= , /=
int x, y, z;
y = 2;
z = 3;

x = y * z ; //x vaut 6
x += 2 ; //x vaut 8
y = x / 4 ; //y vaut 2
y =x % 2 ; //y vaut 0

 Les opérateur = et += peuvent être utilisés sur des

variables de type « String »
 En terme de performance, il est recommandé
d’utiliser la notion raccourcie
31
La syntaxe

Opérateurs unaires

 S’appliquent à un seul opérande de type entier ou

réel
– -, --, +, ++

int x, y;
x = 3;

y = -x ; //y vaut -3
y = ++x ; //y vaut 4, x vaut 4
y = x-- ; //y vaut 4, x vaut 3

 La pré et la post-incrémentation diminuent le

nombre de lignes de byte code générées
32
La syntaxe

Opérateurs de comparaison

 S’appliquent sur des entiers, booléens, réels

==, !=, <=, >, >=
 Ces opérateurs retournent une valeur du type
boolean

{
boolean droitDeVote;
int age;

droitDeVote = (age >= 18) ;

}

33
La syntaxe

Opérateurs logiques
 S’appliquent au type boolean
– ! (not) , && (and) , II (or)
– &, I
 Retournent un type boolean
 & renvoie « true » si les deux expressions renvoient
« true »
 && a le même comportement mais n’évalue pas le
seconde expression si la première est « false »
 | renvoie « true » si l’une des deux expressions
renvoie « true »
 || a le même comportement mais n’évalue pas le
seconde expression si la première est « true »

34
La syntaxe

Les conversions de type (1/2)

 Il y a 4 contextes possibles de conversion (cast) :

– Conversion explicite
– Affectation
– Appel de méthode
– Promotion arithmétique

 Certaines conversions provoquent une perte de

valeur
– Float en int, int en short, short en byte

 Le type boolean ne peut pas être converti en entier

35
 La syntaxe

Les conversions de type (2/2)

double f =3.14 ;
int i,j ;
short s ;

i = (int)f; // float  int (conversion explicite)

float ff = (float)3.14;

i = s; // short  int (affectation)

// appel de la méthode int obj.m(int i)

obj.m(s); // short  int (appel de méthode)

// division d’un entier et d’un flottant : l’entier i est

// converti en flottant, puis la division flottante est calculée
f = i / (double)j; // f vaut 0.3333…

36
La syntaxe

Test conditionnel

class Test {
public static void main (String args[]) {
int compteur = 0;
boolean debut;

if (compteur == 0) {
debut = true;
System.out.println("Début de la partie");
}
else if (compteur ==10)
System.out.println("Fin de la partie");

else
System.out.println("Partie en cours");
}
}

37
La syntaxe

Boucles while

class Test {
public static void main (String args[]) {
int i;

do {
System.out.println("Entrez un nombre < 10");
c= lireUnInt();
} while (c>10);

while (c>0) afficher (c--);

}

public static int lireUnInt() {……}

public static void afficher (char c) {……}

38
La syntaxe

Boucles for

class Test {
public static void main (String args[]) {
int i;

for (i=0 ; i <=5 ; i++) {

System.out.println (i);
……
}

for (j=0 ; j <=5 , j++) {

System.out.println (i);
……
}

// i est accessible
// j n’est pas accessible
}
}

39
La syntaxe

Switch
class Test {
public static void main (String args[]) {

char c = (char)System.in.read();
switch(c) {
case ‘o’ : case ‘O’ :
System.out.println("Oui");
break;
case ‘n’ : case ‘N’ :
System.out.println("Non");
break;
default :
System.out.println("Mauvaise réponse");
break;
}
}
}

 Le « switch » ne s’applique qu’au type entier ou caractère.

40
La syntaxe

Commentaires (1/2)
 L’utilisation de commentaires est fortement
recommandé

 /*ceci est un commentaire

sur plusieurs lignes */

 //ceci est un commentaire sur une ligne

 Javadoc (fourni dans le JDK) génère la

documentation des classes en au format HTML
– /** : début de commentaire Javadoc
– @author : exemple de tag auteur
– */ : fin de commentaire Javadoc
41
La syntaxe

Les tableaux : description

 Nombre fixe d’éléments. Taille fixée à la

construction
 Les éléments sont de même type (type de base ou
classe)
 Les tableaux sont alloués dynamiquement par
« new »
 Un tableau est détruit lorsqu’il n’est plus référencé
 Les tableaux multi-dimensionnels sont des tableaux
de tableaux

42
La syntaxe

Les tableaux : syntaxe

 2 syntaxes pour l’allocation :

int[] monTableau = new int[10];

int monTableau[] = new int[10];

 Une méthode peut renvoyer un tableau

classe Test {

int[] construireTableau (int dimension) {

int tab[] = new int[dimension];
return tab;
}
}

43
La syntaxe

Les tableaux : initialisation

 L’attribut « length » renvoie la dimension du tableau

 L’indice des éléments du tableaux varie de 0 à
« tableau.length –1 »
 Initialisation statique :
int[] monTableau = {1, 2, 3};

 Initialisation dynamique :
int[] param = new int[10];

for (int i = 0; i < param.lenght ; i++)

param[i]= i;

44
Les concepts Objet

45
Les concepts Objet

Les concepts de base

 Les concepts de base de l’objet sont simples et peu
nombreux
– Objet et Classe
– Encapsulation
– Généralisation/Spécialisation
– Polymorphisme
 Ces concepts impactent directement sur la qualité,
les délais et les coûts de développement et de la
maintenance des logiciels
 Il existe de nombreux autres concepts, mais non
fondamentaux
 Les concepts de base sont simples, mais leur
utilisation sur un projet demande de l’expérience
46
Les concepts Objet

Qu’est-ce qu’un objet ?

 C’est une abstraction d’une entité du monde réel

Monde réel Modèle

Simulateur
Abstraction Voiture de circulation

Voiture
Abstraction

Boîte Moteur

Conception
de voiture
47
Les concepts Objet

La généralisation / spécialisation (1/2)

 Généralisation = recherche des similitudes

– Identifier les objets du monde réel connus par le système
– Regrouper les objets en classes
– Généraliser les classes en super classes

 Règle d’or : en cas de doute sur la pertinence d’une

classe, il est préférable de ne pas la définir

 La généralisation est caractérisé par l’expression :

« est un type de »

48
Les concepts Objet

La généralisation / spécialisation (2/2)

Classes
abstraites Moyen de transport

<<extends>>

Classes
concrètes Tracteur Train Voiture

Monde réel

49
Les concepts Objet

Attribut, Opération, Identité ?

 Attribut : valeur portée par un objet

 Opération : service rendu par l’objet

– Synonyme : Méthode, Service

 Identité : un objet doit être identifiable

– Concept équivalent pour les SGBDR : clef primaire

50
Les concepts Objet

Attribut, Opération, Identité (2/2)

 Une classe décrit les Attributs, les Opérations et

l’Identité de ses objets

Voiture Bmw :Voiture

couleur : Couleur=Color.Black Instance de couleur=rouge
vitesseMax : float = 150 vitesseMax=230
demarrer()
arreter() Twingo : Voiture
accelerer(acc : float) Instance de
couleur=jaune
Freiner(acc : float)
vitesseMax=140

51
Les concepts Objet

Accès aux attributs et invocation des

méthodes
 L’accès aux attributs et aux méthodes définis dans
la classe se fait à partir d’un objet
 Un objet est une instance de classe
 Il possède des valeurs propres pour les attributs
définis dans la classe

Voiture clio; // Déclaration d’une variable

clio = new Voiture(); // Création de l’objet

clio.couleur = « rouge »; // Accès à l’attribut

clio.demarrer(); // Appel de la méthode

52
Les concepts Objet

Définition d’une méthode <> invocation d’une

méthode
class Voiture { // Définition de la classe
float vitesse;
float consommation; Définition du paramètre

void accelerer (float delta) {

consommation = consommation + delta / 10;
vitesse = vitesse + delta;
}
}

…………
// Utilisation d’un objet
Voiture clio = new Voiture();
clio.accelerer(20);

Passage du paramètre

53
Les concepts Objet

Les Associations (1/2)

 L’association est le lien qui peut exister entre objets

de différentes classes pour leur permettre de
communiquer

 Deux objets sont associés si :

– Un objet connaît l’identité et la classe d’un (ou de
plusieurs) autre objet

 Il existe un type particulier d’association nommé

Agrégation ou Composition
– Association se lisant « Est formée par l’assemblage de »
ou « Contient »

54
 Les concepts Objet

Les Associations (2/2)

 Lecture du modèle UML :

– Une personne peut posséder entre 0 et n voitures
– Toute voiture possède un propriétaire
– Une voiture est formée de 4 roues et d’une carrosserie

<-possède
Voiture 0..* +propriétaire
Personne

Roue Carroserie
55
Les concepts Objet

L’héritage
 Mécanisme provenant d’une relation de
Généralisation/Spécialisation
 Une sous-classe hérite des attributs, méthodes et
associations de ses super classes
MoyenDeTransport
couleur
vitesse
demarrer()
arreter()

Voiture Moto
typeCarrosserie typeDePot
marcheArriere() faireUneRoueAvant() 56
Les concepts Objet

Qu’est-ce que l’encapsulation ?

 Un mécanisme permettant de masquer les choix

d’implémentation
 Permet de changer l’implémentation sans incidence
sur le reste du système si l’interface n’est pas
modifiée
 Un objet possède une interface publique et une
implémentation privée
 Chaque objet est un mini-serveur  mise en place
de systèmes distribués via CORBA ou DCOM

implémentatio
instruction

interface
instruction
instruction

n
instruction
instruction
instruction

57
 Les concepts Objet

Qu’est-ce que la collaboration ?

 Un objet utilise les services d’autres objets

 Les objets collaborent
 Chaque objet est mini-serveur et client d’autres
objets

Voiture

Demarrer()
Feu
changer (Vert)
Velo

Demarrer()

58
 Les concepts Objet

Qu’est-ce que le polymorphisme ?

 Propriété pour un même message de déclencher

des méthodes différentes
- Débrayer
- Passer la
première
- Accélérer
Voiture - Embrayer

Demarrer()
Feu
changer (Vert)
Velo
- Pédaler
Demarrer()

59
Les concepts Objet

Résumé

 Les concepts fondamentaux :

– Classe, Objet
– Généralisation/Spécialisation (héritage)
– Encapsulation
– Polymorphisme
 Ces concepts ont un impact direct sur :
– La qualité du système
– Le coût de développement et de maintenance
– Le délai du développement et de maintenance
 Si les concepts de base sont simples, leur utilisation
nécessite de l’expérience

60
Classes,méthodes, attributs

61
Classes,méthodes, attributs

Déclarer une classe

 Une classe « public » est visible en dehors du

package
– Par défaut, elle n’est pas visible
– On ne peut pas mettre 2 classes publiques dans un fichier
 erreur de compilation
 Une classe « final » ne peut pas être dérivée (pas
de sous-classes)
– Utile pour des raisons de sécurité et de performances
– De nombreuses classes du JDK sont « final »
 Une classe « abstract » ne peut pas être instanciée
(new)

62
Classes,méthodes, attributs

Déclarer un attribut (1/3)

 Lors de la création d’un objet, les attributs sont

initialisés par défaut :
– À zéro pour les valeurs numériques
– À « null » pour les références
– À « false » pour les booléens
 Les attributs peuvent être initialisés :
– Lors de la déclaration
– Dans le constructeur
 Utiliser des règles de nommage cohérentes :
– Le noms des classes commence par une majuscule
– L’identification d’un attribut ou d’une méthode commence
par une minuscule
63
Classes,méthodes, attributs

Déclarer un attribut (2/3)

 La valeur d’un attribut déclaré comme « static » est

partagée par toutes les instances (objets) de la
classe
 La valeur d’un attribut déclaré comme « final » est
constante

64
Classes,méthodes, attributs

Déclarer un attribut (3/3)

class Date {
int _jour; // initialisé à 0
int _mois = 1; // initialisation explicite
int _an = 2000;
final static int max_mois = 12; //Constante

void print () {
System.out.println(_jour + "/" + _mois + "/" + _an);
}
}

………

Date d = new Date(); // instantiation de l’objet

d.print(); // appel de la méthode print

65
Classes,méthodes, attributs

Le passage de paramètres

 Lors de l’appel d’une méthode prenant en

paramètre des types de bases, les paramètres sont
passés par valeur
– La valeur des variables passées en paramètres est
dupliquée
– Ce sont ces valeurs dupliquées qui sont manipulées dans
la méthode
 Lors de l’appel d’une méthode prenant en
paramètre des objets, les paramètres sont passés
par référence
– Ils peuvent être modifiés dans la méthode

66
Classes,méthodes, attributs

Surcharge (1/3)
 Une méthode surchargée est une méthode qui peut
être appelée avec plusieurs ensembles de listes de
paramètres
– Permet d’écrire plusieurs versions d’une méthode
 Exemple
void print () {…}
void print (int i) {…}
int print (float f) {…}

 Le type du paramètre de retour n’est pas pris en

compte par le mécanisme de résolution de
surcharge
67
Classes,méthodes, attributs

Surcharge (2/3)

 A l’appel, Java détermine quelle est la méthode dont

la liste des paramètres est la plus proche des
paramètres effectivement envoyés par l’appelant

 Si aucune signature de méthode ne correspond au

valeurs envoyées, la machine virtuel Java est
capable de convertir une valeur envoyée dans le
type du paramètre

 Java détermine le coût des conversions possibles et

choisit le coût le moins élevé. Si le coût global de
conversion dépasse 10, Java refuse l’appel
68
 Classes,méthodes, attributs

Surcharge (3/3)

vers Coût des conversions

byte short char int long float double
de
byte 0 1 2 3 4 6 7

Short 10 0 10 1 2 4 5

Char 11 10 0 1 2 4 5

Int 12 11 11 0 1 5 4

Long 12 11 11 10 0 6 5

Float 15 14 13 12 11 0 1

double 16 15 14 13 12 10 0

69
Classes,méthodes, attributs

Constructeurs

 C’est une ou plusieurs méthode(s) permettant

d’initialiser les objets
 Le constructeur est appelé lors de la création de
l’objet
 Le constructeur a le même nom que la classe
 Il n’a pas de valeur de retour (void est un type de
retour)
 Le constructeur peut être surchargé
 Java fournit un constructeur par défaut (sans
paramètres) si aucun constructeur n’est défini
explicitement
70
Classes,méthodes, attributs

Exemple de constructeurs

class Date {
int _jour = 1;
int _mois = 1;
int _an = 2000;

Date() {
_an = 1999;
}

Date (int jour, int mois, int an) {

_jour = jour;
_mois = mois;
_an = an;
}

………

Date d = new Date(10,12,2000); // instantiation de l’objet

71
Classes,méthodes, attributs

Création d’objets

 Allocation de l’espace mémoire pour stocker les

variables d’instances
 Utilisation de l’opérateur « new »
 Appelle du constructeur adéquat
 Retourne une référence sur l’objet créé
class Voiture { // Définition de la classe
String _type;
Voiture (String type) {
_type = type;
}
void demarrer () {………}
}
…………
Voiture clio = new Voiture("ClioRT"); // Création de l’objet
Voiture renault = clio; // Ajout d’une référence sur l’objet
renault.demarrer();
72
Classes,méthodes, attributs

Le Garbage Collector (ramasse-miettes)

 Il prend en charge la gestion de la mémoire

 Il alloue l’espace mémoire lors de la création des
objets
 Il libère la mémoire occupé par un objet dès qu’il n’y
a plus aucune référence qui pointe vers cet objet
 Il est capable de compacter la mémoire pour éviter
la fragmentation
 C’est un « Thread » de la machine virtuel Java

73
Classes,méthodes, attributs

« this »

 « this » = référence sur l’objet courant

 Représente l’instance courante en train de
s’exécuter
class Compte {
void crediter(float montant) {……};
void debit(float montant) {……};
}

class Versement {
void valider() {……}
void effectuer(Compte s, Compte d, float montant) {
s.debiter(montant);
d.crediter(montant);
this.valider();
}
}

74
Classes,méthodes, attributs

Utilisation de « this » dans un constructeur

class Personne {
String _nom ;
String _prenom;
float _taille;

Personne(String nom, String prenom) {

_nom = nom;
_prenom = prenom;
}

Personne(String nom, String prenom, float taille) {

this(nom, prenom);
_taille = taille;
}

75
Classes,méthodes, attributs

« null »

 La valeur « null » peut être assignée à n’importe

quelle référence sur un objet
 Une méthode peut retourner « null »
 L’appel d’une méthode sur une référence d’objet
valant « null » provoque une erreur d’exécution
(NullPointerException)
 On peut tester une référence pour savoir si elle vaut
« null »
Personne moi = new Personne();
……
if (moi != null) {
System.out.println("J’existe toujours ! ");
}

76
Classes,méthodes, attributs

Opérateurs sur les références

 Egalité de deux références : ==

– Compare si 2 références pointent vers le même objet

 Différence de deux références : !=

– Compare si 2 références pointent vers des objets différents

 Type d’instance de la référence : instanceof

– Permet de savoir si l’objet référencé est une instance d’une
classe donnée ou d’une de ses sous-classes
Personne moi = new Personne();
……
if (moi instanceof Personne) {
System.out.println("Je suis bien une personne! ");
}
77
Classes,méthodes, attributs

Méthodes « static »

 Le mot-clé « static » permet de définir une méthode

comme statique

 Une méthode statique ne peut accéder qu’aux

attributs de la classe déclarés comme « static »

 L’appel d’une méthode statique ne se fait pas sur un

objet, mais sur une classe
– Exemple : Math.cos(3.14);

 L’utilisation d’une méthode statique ne nécessite

pas la création d’un objet
78
Classes,méthodes, attributs

Exemple de méthode « static »

class MathUtil {
final static double _PI = 3.14 ;
static double PI() {
return _PI;
}

static double Carre(double x) {

return x * x;
}

static double Demi(double x) {

return x / 2;
}
}
……
double i = MathUtil.Carre(5);
double x = MathUtil.PI();

79
Héritage, polymorphisme,
encapsulation

80
Héritage, polymorphisme, encapsulation

Héritage (1/2)

 Toute classe Java est une sous-classe de la classe

« Object »
 Java ne permet pas l’héritage multiple
 La classe dérivée peut changer l’implémentation
d’une ou plusieurs méthodes héritées : redéfinition
 Il est possible de faire en sorte que l’on ne puisse
pas hériter d’une classe en particulier : utilisation du
mot-clé « final »
 Il est possible de faire en sorte qu’une méthode ne
puisse pas être redéfinie : utilisation du mot-clé
« final »

81
Héritage, polymorphisme, encapsulation

Héritage (2/2)
class Felin {
boolean a_faim = true;
void parler() { }
void appeler() {
System.out.println("minou minou,…");
if (a_faim) parler();
}
}

final class Chat extends Felin {

String race;
void parler() { System.out.println("miaou! "); }
}

final class Lion extends Felin {

void parler() { System.out.println("roar! "); }
void chasser() {……}
}

82
Héritage, polymorphisme, encapsulation

Conversion entre classes

 Si une variable référence un objet d’une classe, elle

peut référencer un objet de n’importe laquelle de
ses sous-classes

class Felin {………}

class Lion extends Felin {………}

Lion lion = new Lion();

Felin felin;

felin = lion; // OK conversion implicite : les lions

// sont des félins

lion = felin // ERREUR : tous les félins ne sont pas

// des lions

83
Héritage, polymorphisme, encapsulation

Conversion ascendante, conversion

descendante
class Felin {………}
class Lion extends Felin {………}
……
Felin felin = new Felin();
Lion lion = new Lion();

felin = lion; // Conversion ascendante

felin.parler(); // « roar ! »
felin.chasser() // Méthode introuvable
lion = felin; // ERREUR : conversion explicite
nécessaire

lion = (Lion)felin; // Conversion descendante explicite

lion.parler(); // « roar ! »
lion.chasser(); // OK

Chat chat = new Chat();

felin = chat; // Conversion ascendante
lion = (Lion)felin // ERREUR java ClassException

84
Héritage, polymorphisme, encapsulation

Polymorphisme (1/2)

 Une méthode polymorphe est une méthode

déclarée dans une super-classe et redéfinie dans
une sous-classe

 Une méthode Java st par défaut polymorphe

 Les méthodes « final » ne peuvent pas être

redéfinies
– Permet à la machine virtuel d’optimiser le byte-code
– Est utilisé pour des raisons de sécurité

85
Héritage, polymorphisme, encapsulation

Polymorphisme (2/2)
class Cirque {
Felin f_list[] = new Felin[3];

Cirque() {
f_list[0] = new Lion();
f_list[1] = new Chat();
f_list[2] = new Tigre();
}

void appeler() {
for (int i = 0; i<3 ; i++) {
Felin f = f_list[i];
f.parler();
}
}
}

86
Héritage, polymorphisme, encapsulation

Super (1/2)

 Le mot-clé « super » permet d’accèder aux

méthodes et aux attributs de la super-classe
 « super » est utilisé dans le constructeur de la
classe dérivée pour appeler celui de la super-classe
– Cela permet de factoriser du code
– « super(…) » doit être la première instruction du
constructeur
class Felin {
int _nbPattes;
Felin(int nbpattes) { _nbPattes = nbPattes; } }

class Chat {
Chat() {
super(4);
race = "goutière"; } }
87
Héritage, polymorphisme, encapsulation

Méthodes et classes abstraites

 Une méthode abstraite est une méthode dont on

donne la signature sans en décrire l’implémentation
– Le mot-clé « abstract » permet d’indiquer qu’une méthode
doit être redéfinie dans une sous-classe
 Une classe abstraite ne peut pas être instanciée
– Le mot-clé « abstract » permet de bloquer l’instanciation
– Une classe possédant une méthode abstraite est abstraite
abstract class Felin {
abstract void parler() {…]
}

class Chat extends Felin {

void parler() { System.out.println("miaou ! "); } }

Felin f = new Felin(); // Ne compile pas

88
Héritage, polymorphisme, encapsulation

Les packages : définition (1/2)

 Un package est une bibliothèque de classes

 On regroupe les classes d’un même domaine dans

un package

 Les packages sont organisés hiérarchiquement

 La notion de package apporte un niveau

d’encapsulation supplémentaire

89
 Héritage, polymorphisme, encapsulation

Les packages : définition (2/2)

 Les classes du JDK sont classées dans des
packages
java

lang util awt net

String.class Date.class event Button.class Socket.class

Thread.class Vector.class List.class URL.class
…

 Java importe automatiquement le package

« java.lang » qui contient des classes comme
« Thread » ou « System »

90
Héritage, polymorphisme, encapsulation

Les packages : utilisation (1/2)

 Il y a 2 manières d’utiliser une classe stockée dans

un package :
– Utilisation du nom complet
java.util.Date dateDuJour = new java.util.Date();
System.out.println(dateDujour);

– Importer une classe ou toutes les classes du package

import java.util.Date;

Date dateDuJour = new Date();

System.out.println(dateDujour);

import java.util.*;

Date dateDuJour = new Date();

System.out.println(dateDujour);

91
Héritage, polymorphisme, encapsulation

Les packages : utilisation (2/2)

 Le mot-clé « package » permet de définir un

nouveau package
 La hiérarchie des packages correspond à la
hiérarchie des répertoires
//fichier Compte.java dans le répertoire Finance
package finance;
public class Compte {
…… }

//Fichier Client.java dans le répertoire de l’application

import finance.*;
public class Client {
Compte c = new Compte();
…… }

92
Héritage, polymorphisme, encapsulation

La variable CLASSPATH

 Le compilateur utilise la variable d’environnement

CLASSPATH pour localiser les classes d’un
package sur le disque
 Cette variable doit référencer tous les répertoires ou
fichiers dans lesquels sont susceptibles de se
trouver des classes Java
 On a le droit de placer les classes dans des
archives (zip, jar, cab)
– Dans ce cas, la variable CLASSPATH doit référencer le
fichier
 La hiérarchie des classes des packages doit être
respectée
93
Héritage, polymorphisme, encapsulation

Classes publiques
 Le mot-clé « public » permet de définir une classe
comme publique

 Seules les classes « public » sont accessibles

depuis l’extérieur du package

 Chaque fichier java doit contenir au maximum une

classe « public »
– Cette classe doit porter le nom du fichier dans lequel elle
est définie (en respectant les majuscules/minuscules)

 Les classes « non public » ne sont utilisables qu’à

l’intérieur du fichier dans lequel elles sont définies
94
Héritage, polymorphisme, encapsulation

Visibilité - Encapsulation

 Permet de distinguer les services offerts (interface)

de l’implémentation
 L’encapsultation des classes Java est définie au
niveau du package
 IL’encapsulation agit au niveau des classes et non
des objets
– Un attribut « private » dans un objet sera accessible depuis
une autre objet de la même classe
 Il y a 4 niveaux de visibilité : public, private,
protected, friendly (valeur par défaut)

95
Héritage, polymorphisme, encapsulation

Règles de visibilité

public

protected

private

friendly
(par défaut)

96
Héritage, polymorphisme, encapsulation

Règles de visibilité

 Pour une bonne encapsulation, il est préférable de

définir les attributs comme « private »
 On définit alors des méthodes «publiques »
(accesseurs) permettant de lire et/ou de modifier les
attributs
– Si un accesseur retourne une référence sur un objet, rien
n’empêche la modification de cet objet à travers cette
référence  cela brise l’encapsulation
class Personne {
private Vector children = new Vector();
public Vector getChildren() { return children; } }
……
Personne moi = new Personnes(); Rupture de
Vector v = moi.getChildren(); l’encapsulation
v.addElement(new Personne("Paul");

97
Héritage, polymorphisme, encapsulation

Encapsulation des constantes

class EtatPorte { // Classe non publique
public final static EtatPorte OUVERTE = newEtatPorte();
public final static EtatPorte FERME = newEtatPorte();

// Empeche la création d’un nouvel objet

private EtatPorte() {}
}

public class Porte { // Classe publique

private EtatPorte etat = EtatPorte.FERMEE;

public void ouvrir() {

etat = EtatPorte.OUVERTE;
}

public estOuverte() {
return (etat == EtatPorte.OUVERTE);
}
}

98
Les interfaces

99
Les interfaces

Définition

 Une interface définit un ou plusieurs services offerts

 Elle est composée d’un ensemble de méthodes
abstraites et de constantes (« static » et « final »)
 Une classe peut implémenter une ou plusieurs
interfaces
– Elle doit fournir une implémentation pour chaque méthode
interface Printable {
void print();

class Point extends Object implements Printable {

private double x, y;
void print() {
System.out.println(x);
System.out.println(y);
}
}
100
Les interfaces

Héritage multiple d’interface

 Une interface peut hériter d’une ou plusieurs autres

interfaces
– Java supporte l’héritage multiple d’interface
 Une classe peut implémenter plusieurs interfaces
interface Printable {
void print();
interface Persistent {
void save();
interface SGBD extends Persistent {
void connect();

class Point implements Printable , SGBD {

private double x, y;
void print() {……};
void save() {……};
void connect() {……};
}

101
Les interfaces

Interfaces et types

 Une interface définit un nouveau type

 Des objets différents peuvent répondre au même
message à condition qu’ils implémentent la même
interface
 L’opérateur « instanceof » peut être utilisé pour
savoir si un objet implémente une interface donnée
Point point = new Point();

if (point instanceof Printable){

point.print();
……
}

102
Les interfaces

Variables d’interfaces

 Les variables déclarées dans une interface sont des

constantes
– Les mots clés « static » et « final » ne sont pas nécessaires
 Les variables des interfaces doivent obligatoirement
être initialisées
interface MyInterface {
int MIN = 0;
int MAX = 100;
…… }

int i = MyInterface.MAX;

103
Les interfaces

Quand utiliser les interfaces ?

 Pour définir des services techniques

 Pour contourner le fait que Java ne supporte pas
l’héritage multiple
 Interface vs Héritage :
– On utilise l’héritage quand un objet est un sous-type d’un
autre
– On utilise une interface pour décrire le fait qu’une classe
implémente un service particulier

Personne Persistent
extends
implements

Client
104
Les interfaces

Conception par contrat (1/4)

 Exemple : on définit les classes

« Client », Banque » et « Compte »

Compte
credit()
Client debit() Banque
balance() ……
…… 0..* 0..*
save()
load()

105
 Les interfaces

Conception par contrat (2/4)

 Le « Client » et la « Banque » ont des points de vue

différents sur un « Compte ». Ils n’utilisent pas les
mêmes méthodes
 On définit des contrats différents

ICompteClient Compte ICompteBanque

credit() implements credit() implements balance()

debit() debit() save()
balance() balance() load()
save() 0..*
0..*
load()

Client Banque

…… ……
106
 Les interfaces

Conception par contrat (3/4)

 La méthode « balance » peut être mise en facteur

ICompte
balance()

ICompteClient ICompteBanque
implements implements
Compte
credit() save()
credit() load()
debit()
debit()
0..* 0..*
balance()
save()
load()
Client Banque

…… ……
107
 Les interfaces

Conception par contrat (4/4)

 Les méthodes « save » et « load » sont des

services techniques transversaux IPersistant
ICompte
save()
balance() load()

ICompteClient implements implements

Compte ICompteBanque
credit()
credit()
debit()
debit()
0..* 0..*
balance()
save()
load()
Client Banque

…… ……
108
Les classes de base

109
Les classes de base

La classe « Object » : définition

 Classe mère de toutes les classes

– Permet d’utiliser les classes conteneurs et le
polymorphisme
 La méthode « toString() » retourne une description
de l’objet
 La méthode « equals(Object) » teste l’égalité
sémantique de deux objets
 Le méthode « getClass() » retourne le descripteur
de classe. Il permet de :
– connaître la classe d’un objet
– connaître le nom de la classe, ses ancêtres
– découvrir la structure des objets (JDK 1.1)
110
Les classes de base

La classe « Object » : exemple

class NamedObject extends Object {
protected String _nom;
public String toString() {
return "Objet : " + _nom + " de la classe " +
getClass().getName();
}

public boolean equals (NamedObject obj) {

return obj._nom.equals(this._nom);
}
}
class Personne extends NamedObject {………}

Personne moi = new Personne("Marcel Dupond");

Personne lui = new Personne("Marcel Dupond");
Objet Marcel Dupond
System.out.println(moi); de la classe Personne
if (moi == lui) {……}
Test des références = false
if (moi.equals(lui)) {……}

Test des valeurs = true

111
Les classes de base

La finalisation d’un objet

 Tout objet qui n’est plus référencé est détruit par le ramasse-
miettes
– Il n’y a pas de “delete” en java
 « finalize() » est appelé avant que le ramasse-miettes ne libère
la mémoire occupée par l’objet
– Permet de libérer des ressources allouées par l’objet
 On peut forcer l’appel au ramasse-miettes en invoquant
– System.gc() : déclencher le ramasse-miettes
– System.runFinalisation() : déclencher la finalisation des objets
 Vous pouvez lancer la machine virtuelle en bloquant le
déclenchement automatique du ramasse-miettes
– Option : java-nosyncgc
– Permet de contrôler le déclenchement du ramasse-miettes

112
Les classes de base

Les classes « Wrapper » : description

 Les types de base Java ne sont pas des objets
– Il est parfois indispensable de les manipuler comme des
objets
 Les classes Wrapper représentent un type de base
– Récupérer les valeurs min et max
– Créer une instance à partir d’un type de base ou d’une
chaîne
– Conversions entre types de base et chaînes
– Conversions entre chaînes et types de base
– Utiliser des types de base dans des conteneurs
 Boolean, Integer, Float, Double, Long, Character
 Attention : ne supporte pas d’opérateurs (+, -, …)
 Elles sont dans le package java.lang
113
Les classes de base

« Wrapper » vs « types de base »

 Avantages des type de bases :

– Plus léger en mémoire
– Supporte un certain nombre d’opérateurs
– Autorise certaines conversions automatiques de types

 Avantages des Wrappers :

– Est passé par référence
– Dispose de méthodes de conversions statiques vers les
autres types
– Peut être géré par les objets container

114
Les classes de base

Exemples

 Convertir une chaîne en entier :

static int convertir(String s) {
try {
return Integer.parseInt(s);
} catch(Exception e) { return 0; }
}

 Convertir un entier en chaîne :

static String convertir(int i) {
Interger j = new Integer(i);
return j.toString();
}

115
Les classes de base

La classe java.lang.String

 Contient une chaîne de caractères

 Classe connue par le compilateur Java
– Une chaîne constante sera convertie en objet de la classe
String
– String msg = “Hello Java World !”
 Un objet de la classe String ne peut pas être modifié
– Ne brise pas l’encapsulation
class Personne {
String nom;

public String getNom() {

return nom;
}
}

116
Les classes de base

String : concaténation
int area = 33;
int prefixe = 1;
int suffixe = 02030405;

// Chaque concaténation crée un nouvel objet

// l’ancien est détruit par le Garbage Collector

String numTel = "(" + area + ")"; // (33)

numTel += prefixe // (33)1
numTel += "-" // (33)1-
numTel += suffixe // (33)1-02030405

// Un seul objet est créé

numtel = "(" + area + ")" + prefixe + "-" + suffixe

// Conversion d’un entier en chaîne

String un = 1 + "";

117
Les classes de base

String : manipulation
 length() : cette méthode permet de connaître le
nombre de caractères d’une chaîne
– Ex : for (int i = 0; i < monTexte.length(); i++) {......}
 indexOf(char c, int i) : retourne la position du
caractère “c” à partir de la position “i”
– if (monTexte.indexof(‘$’, 5) <> -1 ) {......}
 substring(int i, int j) : extrait de la chaîne les
caractères de la position “i” à la position “j”
– String nouveauMot = ancienMot.substring(2,5);
 equals() : retourne un booléan signifiant si les deux
chaînes sont identiques
– Ex : if ( mot1.equals(mot2)) {......}

118
Les classes de base

La classe java.lang.StringBuffer

 C’est une chaîne de caractères modifiable et de

taille variable
 Son utilisation est moins simple que « String »
– pas d’utilisation possible de l’opérateur +
 append(p) : ajoute “p” en fin de la chaîne courante
– “p” peut être de n’importe quel type de base
 length() : retourne la longueur de la chaîne
 setLength() : change la longueur de la chaîne
– Si elle est étendue, les nouveaux caractères sont initialisés
à0

119
Les classes de base

La classe java.util.Vector
 Tableau de références à taille variable
 On ne peut y stocker que des références sur les
objets
– Impossible de stocker directement un type de base dans
une collection de type Vector : utiliser pour cela les classes
wrapper
– Souvent utilisé pour coder une relation 1-n entre deux
classes
 Possibilité de savoir si un objet est présent dans le
tableau et quelle est sa position
 Vous pouvez :
– Insérer ou supprimer des références
– Parcourir le contenu

120
Les classes de base

Vector : insérer, supprimer

Vector vInt = new Vector();

for (int i = 0; i<10 ; i++) {

Integer elt = new Integer(i);
vInt.addElement(elt);
}

// 0123456789

Interger i = new Integer(0);

vInt.addElementAt(i, 5);

// 01234056789

vInt.removeElementAt(0);

// 1234056789

vInt.removeAllElements();

121
Les classes de base

Vector : modifier, rechercher ...

 Object elementAt(int index)
– Retourne l’élément pointé par index
 Void setElementAt(Object obj, int index)
– Place obj à la position index
 Boolean contains(Object elem)
– Retourne true si elem est dans le tableau
 Int indexOf(Object elem)
 Int indexOf(Object elem, int index)
– Retourne la position de l’objet ou -1 si l’objet n’est pas dans le
tableau
– L’objet est recherché par référence
 Int size()
– Retourne la taille courante

122
Les classes de base

L’interface java.util.Enumeration
 Objet permettant de parcourir les éléments d’un conteneur
– Une énumération ne stocke aucune information
– Ne contient qu’une position courante dans le conteneur
– Interface unique pour le parcours de tous les types de conteneurs
– Ne fonctionne que pour un seul parcours
– C’est une interface, pas une classe

 Elements() appliquée sur un Vector retourne une Enumeration

 Deux méthodes :
– Boolean hasMoreElements() : teste s’il reste des éléments
– Object nextElement() : récupère l’élément courant et
passe au suivant

123
Les classes de base

Enumeration : exemple
Vector vInt = new Vector();
for (int i = 0; i<10 ; i++) {
Integer elt = new Integer(i);
vInt.addElement(elt);
}
// 0123456789

// Première façon de parcourir le vector

for (int i = 0; i<vInt.size() ; i++)
System.out.println(vInt.elementAt(i));

// Seconde façon de parcourir le vector

// la plus élégante
for (Enumeration e = vInt.elements(); e.hasMoreElements();)
System.out.println(e.nextElement());

124
 Les classes de base

Quand utiliser une Enumeration ?

 Utilisez une Enumeration pour parcourir une

association 1..*
possède ->
Personne Voiture
proprietaire 0..*

 Permet de ne pas briser l’encapsulation

 Dans l’exemple suivant :
– la classe « Personne » possède une méthode publique
pour parcourir la collection de voitures
– L’ajout ou la suppression d’une voiture dans cette
collection doit se faire en manipulant une instance de la
classe « Voiture »

125
 Les classes de base

Quand utiliser une Enumeration ?

public class Personne {
private Vector _voitures = new Vector();

public Enumeration voitures() { return _voitures.elements(); }

void addVoiture(Voiture v) { _voitures.addElement(v); }
void remVoiture(Voiture v) { _voitures.removeElement(v); }
}
......
package simulateur;
class Voiture {
private Personne _proprio;

public void setProprietaire (Personne p) {

if (_proprio != null) _proprio.remVoiture(this);
_proprio = p;
if (_proprio != null) _proprio.addVoiture(this);
}

public Personne getProprietaire() { return _proprio; }

}

126
Les classes de base

La classe java.util.Hashtable
 Tableau associatif permettant :
– D’indexer un objet par une clé
– De retrouver rapidement un objet à partir d’une clé
 Les clés des références sont des objets
– Chaînes de caractères, numéros d’identification …
– Elles sont recherchées par valeurs (méthodes equals)
– Les clés doivent implémenter la méthode
Object:hashCode()
 Une clé ne peut identifier qu’une seule valeur
– N’accepte pas les doublons
– Pour stocker des relations n-n, il suffit de stocker des
instances de Vector dans une Hashtable
 Très performant pour l’accès aux valeurs
127
Les classes de base

La classe java.util.Hashtable

 Object put(Object key, Object value) : insère un

élément
 Object remove(Object key) : supprime la clé
 Object get(Object key) : retourne la valeur associée
à la clé
 Boolean containsKey(Object key) : teste si la clé
existe
 Keys() : retourne une Enumeration sur les clés
 Elements() : retourne une Enumeration sur les
valeurs

128
Les classes de base

Hashtable : un exemple
Hashtable deptable = new Hashtable();

// Stockage d’objets de type Departement en utilisant

// une clé de type String
deptable.put("Ain", new Departement(1));
deptable.put("Aisne", new Departement(2));
deptable.put("Allier", new Departement(3));

Departement dep = (Departement)deptable.get(("Aisne");

// Parcours de toutes les clés de la hashtable

for (Enumeration noms = deptable.keys();
noms.hasMoreElements();) {
String nom = (String)noms.nextElements();
Departement dep2 = (Departement)deptable.get(nom);
System.out.println(nom + " = " + dep2);
}

129
Les classes de base

Choisir un conteneur

 Le choix d’un conteneur dépend du type d’accès

Tableau Liste Hashtable
(Vector)

Parcourir 10 7 3

Insérer ou 3 10 9
enlever
Rechercher 3 2 10
(5 si trié)

130
Les exceptions

131
Les exceptions

A quoi servent les exceptions ?

 Le mécanisme des exceptions Java permet de

traiter les erreurs d’éxécution
 Il permet aussi de gérer toutes les situations “hors
contrat” définit par le concepteur
 Le travail du concepteur :
– Définir les ensembles d’instructions à risque
– Implémenter les gestionnaire d’exceptions pour chaque cas
 Le travail de la machine virtuelle Java :
– Distinguer un résultat valide d’un code erreur
– Propager jusqu’au gestionnaire de ce cas exceptionnel les
informations qui lui sont nécessaires (code erreur, données
de contexte)
132
Les exceptions

Exemple (1/2)
class Equation {
double _a;
double _b;
double c;

// Constructeur
Equation(double a, double b, double c) {
_a = a;
_b = b;
_c = c; }

// Calcul du delta
public double delta() { return _b*_b – 4*_a*_c; }

// Solution
public double solution() throws PasDeSolution {
double discr = delta();
if (discr<0) throw new PasDeSolution();
return (_b + Math.sqrt(discr))/(2*_a); }
}

133
Les exceptions

Exemple (2/2)
class PasDeSolution extends Exception {

// Retourne la description du problème

String toString() {
return "L’équation n’a pas de solution";
}
}

... ...
// Méthode appelante
……
try {
Equation ed = new Equation(1,0,1); // x2 + 1 = 0
double resultat = eq.solution();
……
} Branchement
catch(PasdeSolution p) { vers le catch
System.out.println(p.toString);
}

134
Les exceptions

Throw et throws

 Le mot-clé “Throw” permet de soulever une

exception
if (discr<0) throw new PasDeSolution();
……

 Le mot-clé “Throws” s’utilise au niveau de la

signature d’une méthode pour préciser que celle-ci
est susceptible de soulever une exception
public double solution() throws PasDeSolution {
……

135
Les exceptions

Try - Catch et Throws

 Lorque que l’on utilise une méthode susceptible de

soulever une exception, il faut spécifier comment on
la gére.
 2 Solutions :
– Traiter le cas dans la méthode : Try - Catch
try {
double resultat = eq.solution();
} catch(PasdeSolution p) {
System.out.println(p.toString); }

– Faire “remonter” l’exception au niveau supérieur : Throws

void calculer() throws PasDeSolution {
……
double resultat = eq.solution();
……
}

136
Les exceptions

Finaly

 Le mot-clé “Finally” permet de déclarer un bloc

d’instruction qui sera exécuté dans tous les cas,
qu’une exception survienne ou non.
try {
// Ouvrir le fichier
// Lire les données
 Erreur ici !
// ……
} catch (IOException i) {
System.out.println("Erreur I/O sur le fichier");
return;
} finally {
// Fermer le ficher  Retour aux instructions
// …… suivant la lecture
}

 Bloc d’instructions toujours traité

137
 Les exceptions

Classification des exceptions

 Le JDK contient des classes d’exceptions dont voici

un extrait :
Object

Throwable

Error Exception

...... ...... RuntimeException SecurityException ......

ArithmeticException NullPointerException PasDeSolution

138
Les exceptions

Bâtir une hiérarchie d’exceptions métier

Exception

ConnectionException

NetworkFailure AuthentificationFailed ServerDownOrBusy

InvalidPassword InvalidLogin

139
Les exceptions

Debugging : les traces

 Une exception dérive de la classe Object. Utilisez la

méthode toString() pour garder des traces
d’exécution
 La méthode PrintStackTrace() permet d’afficher la
pile des appels depuis la méthode qui a déclenché
l’exception
 La classe Throwable prend une String à sa
construction. Cela permet d’enrichir les traces avec
des messages spécifiques, récupérés avec
getMessage()

140
Les entrées-sorties

141
 Les entrées-sorties

Description

 Le modèle d’entrée/sortie de Java offre 2 groupes

de classes :
– Entrées/sorties par octet (Stream)
– Entrées/sorties par caractères UNICODE (Reader/Writer)
 Les classes InputStreamReader et
OutputStreamWriter font le lien entre les 2 modèles

Reader Writer OutputStream InputStream

InputStreamReader OutputStreamWriter

142
Les entrées-sorties

Canal et Filtre (1/2)

 Un Canal représente une source de données

– Un fichier, un pipe, un socket, un tableau …
– Peut être lu et/ou écrit
– Interface de bas niveau : lire/écrire un octet ou un
caractère
 Un Filtre se connecte sur un Canal
– Il permet d’offrir une interface de haut niveau identique à
tous les canaux
– Interface de haut niveau : lire/écrire un entier, un flottant,
une chaîne
– Il est possible de connecter un filtre à un autre

143
 Les entrées-sorties

Canal et Filtre (2/2)

C
a
Fichier n Filtre
a
l

Reader Writer OutputStream InputStream

FilterReader FilterWriter FilterOutputReader FilterInputWriter

144
Les entrées-sorties

Entrées/Sorties par caractères

 Flots de caractères UNICODE-2
– 2 octets par caractère
 Deux classes de base
– Java.io.Reader
– Java.io.Writer
 Modèle symétrique aux canaux par octets
– ReaderFilter
– WriterFilter
 Vous pouvez connecter un canal UNICODE sur un
canal par octets
– OutputStreamWriter et InputStreamReader
– Conversion des caractères UNICODE sur 1 caractère
– Dépend de la plate-forme (ASCII ou EBCDIC)
145
Les entrées-sorties

Sous-classes de la classe Reader

 FileReader : lecture d’un flux de caratères à partir d’un fichier
 PipedReader : lecture d’un flux de caratères à partir d’un
“Pipe” (IPC)
 StringReader : lecture d’un flux de caratères à partir d’un
“String”
 CharArrayReader : lecture d’un flux de caratères à partir d’un
tableau de “char”
 InputStreamReader : lecture d’un flux de caratère à partir d’un
“InputStream”
 BufferedReader : permet de mémoriser les caractères lors de
la lecture pour améliorer les performances
 ...etc

146
Les entrées-sorties

Sous-classes de la classe Writer

 PipedWriter : écriture d’un flux de caratères vers un
“Pipe” (IPC)
 StringWriter : écriture d’un flux de caratères dans
un “String”
 CharArrayWriter : écriture d’un flux de caratères
dans un tableau de “char”
 OutputStreamWriter : écriture d’un flux de caratère
vers un “OutputStream”
 BufferedWriter : permet de mémoriser les
caractères lors de l’écriture pour améliorer les
performances
 ...etc

147
Les entrées-sorties

La classe java.io.PrintWriter

 Permet d’écrire une chaîne de caractères, un entier

(Integer), etc., vers un canal de sortie
 Pour écrire, on utilise les méthodes write ou writein
 Le “flushing” peut être automatique ou non
try{
FileWriter fos = new FileWriter("text.txt");
PrintWriter p = new PrintWriter(fos,true);

String s = "Je suis une chaîne";

p.print(s); // écriture sans retour-chariot

P.println(s); // écriture avec retour-chariot

} catch(IOException e) {}

148
 Les entrées-sorties

La classe java.io.BufferedReader

 Permet de lire des informations depuis un Reader

quelconque (entrée standard, fichier, …)
try{
// Lecture depuis un fichier
BufferedReader in = new BufferedReader(new FileReader(args[0]));
String s = new String();
while((s = in.readLine()) != null)
System.out.println(s);
in.close();

// Lecture depuis le clavier

BufferedReader clav = new BufferedReader(new
InputStreamReader(System.in));
System.out.print("Saisissez une phrase : ");
String s = clav.readLine();
……
} catch(IOException e) {}

149
Les entrées-sorties

La classe java.io.File

 Manipulations du système de fichiers

 Constructeurs :
– Public File(File dir, String name) ;
– Public File(String path) ;
– Public File(String path, String name) ;
 Principales méthodes :
– Boolean isDirectory() – String[] list (FilenameFilter filter)
– Boolean isFile() – Int length()
– String getAbsolutePath() – Boolean delete()
– Boolean renameTo(File dest) – Boolean exists()
– Boolean mkdir(String name) – Boolean canReads()
– String [] list () – Boolean canWrite()
150
Les entrées-sorties

La classe java.io.RandomFile
 La classe RandomAccessFile permet la lecture et l’écriture à
n’importe quelle position dans le fichier
 L’octet est l’unité de mesure des positions et des
déplacements dans le fichier
 Constructeurs (throws IOException) :
– Public RandomAccessFile (File file, String mode)
– Public RandomAccessFile (String name, String mode)
– Mode = “r” (lecture seule) ou “rw” (lecture et écriture)
 Méthodes :
– ReadInt, readFloat, readBoolean : lecture des types de base
(Interface DataInput)
– WriteInt, writeFloat, writeBoolean : écriture des types de base
(Interface DataOutput)
– Seek(long) : décalage en octets

151