Apprentissage du java

Ecole Sup´rieure d’Ing´nieurs de Luminy
e e
Universit´ de la M´diterran´e
e e e

Support de cours pour
l’apprentissage du langage JAVA
ESIL - GBM 2
Claudine Chaouiya
2003/2004

chaouiya@esil.univ-mrs.fr
http ://www.esil.univ-mrs.fr/˜chaouiya

Chapitre 1

Introduction

Java est un langage de programmation orient´ objets adapt´ ` la distribution
e e a
d’aplications sur Internet et qui s’int`gre au Web. Nous verrons avant tout les
e
diff´rentes approches de programmation.
e
Avant d’ćrire un programme, il faut poser le probl`me que ce programme devra
e e
r´soudre. La formulation du probl`me influe sur l’ćriture du programme, on parle
e e e
de paradigmes de programmation. S’il est ` peu pr`s possible d’impl´menter tous les
a e e
paradigmes avec tout langage de programmation, chaque langage est quand mˆme e
plus adapt´ ` un paradigme donn´. Ainsi, C est un langage dit proc´dural, C++ et
ea e e
Java sont orient´s objets.
e

1.1 Programmation proc´durale
e
C’est l’approche que vous connaissez. Le langage C est adapt´ ` la programma-
ea
tion proc´durale. Dans ce style de programmation, l’accent porte sur l’algorithme
e
mis en oeuvre. Chaque ´tape de l’algorithme peut elle mˆme ˆtre dćoupé. C’est
e e e e e
la programmation structuré qui indique qu’il faut isoler et clairement identifier les
e
diff´rentes op´rations. On utilise ainsi des fonctions auxquelles on fournit des ar-
e e
guments et qui retournent des r´sultats. Ces fonctions peuvent ´ventuellement ˆtre
e e e
rangés dans des biblioth`ques, pour que l’on puisse les rútiliser. On retrouve ici les
e e e
notions de modules (voir plus loin), et de compilation s´paré vues l’an dernier.
e e

Exemple du calcul du pgcd
int pgcd(int a, int b){
int r;
if (a<b){r=a;a=b;b=r;}
do {
r=a%b;
a=b;
b=r;
} while (r!=0);
return a;
}
...

1

1.2. PROGRAMMATION MODULAIRE

void fonction1(....) {
....
x=pgcd(1990,y);
....
}

Exemple de la pile
#include <stdio.h>
typedef struct elt {
char info;
struct elt *suiv;
} Maillon, *Pile;

Pile empiler(char c,Pile P) {
Pile q;
q=(Pile)malloc(sizeof(Maillon));
q->info=c;
q->suiv=P;
return(q);
}
char depiler(Pile *P) {
Pile q;
char c;
q=*P;
*P=q->suiv;
c=q->info;
free(q);
return(c);
}
int vide(Pile P){
return (P==NULL);
}
int main() {
char c;
Pile P=NULL;
for (c=’a’;c<’e’;c++) P=empiler(c,P);
while(!vide(P)) {
printf("%c n",depiler(&P));
}
}

1.2 Programmation modulaire
L’encapsulation des donnés est fondamentale d`s que la taille des programmes
e e
est importante. Cela permet de se concentrer sur l’essentiel. Ainsi, l’ensemble des
proc´dures ou fonctions et les donnés qu’elles manipulent sont regroupés dans un
e e e
module. Un programme est alors constitu´ de diff´rents modules, et la communication
e e
entre modules se fait ` travers une interface, les d´tails d’impl´mentation de chaque
a e e
module ´tant cach´s aux autres modules. On a vu ce principe dans le cours de C avec
e e
les fichiers d’entˆtes.
e

Support de cours programmation Java - GBM2 - 2-

1.2. PROGRAMMATION MODULAIRE

Les types abstraits de donnés (TAD) sont bas´s sur deux idés :
e e e
– L’encapsulation : c’est la d´finition d’un type et d’un ensemble d’op´rations
e e
pour le manipuler ` l’int´rieur d’une unit´ syntaxique (un contenant : fichier,
a e e
classe, module, package, etc.)
– La dissimulation de l’information : c’est le masquage des d´tails d’impl´mentation
e e
qui ne concernent pas l’utilisateur de l’abstraction.
L’encapsulation est utilisé pour la compilation s´paré : on regroupe dans un
e e e
fichier les parties d’un programme qui sont s´mantiquement liés. Lors d’une modi-
e e
fication, on n’a pas ` recompiler tout le programme mais seulement le module qui a
a
chang´. Les TAD sont d´finis par :
e e
– La spćification du type tel que vu de l’ext´rieur, elle d´finit comment utiliser
e e e
le type (donnés et op´rations accessibles). Elle dćrit aussi l’interface, ce qui est
e e e
export´. Les programmes utilisant le TAD importent l’interface pour pouvoir
e
utiliser le type.
– La repr´sentation des objets de ce type (structure de donné du type), elle
e e
dćrit comment les objets du TAD sont construits.
e
– L’impl´mentation des op´rations qui manipulent les objets de ce type. Il y a
e e
parfois deux op´rations particuli`res : constructeur et destructeur qui spćifient
e e e
comment crér un objet du type et quoi faire quand on veut le d´truire.
e e
Un bon TAD ne devrait exporter que des op´rations, pas de donnés (champs).
e e
Eventuellement, les donnés sont acc´dés au travers d’op´rations tr`s simples ap-
e e e e e
pelés fonctions d’acc`s (getters et setters) pour donner une valeur ou extraire la
e e
valeur d’une donné.e

Remarque : Les classes du mod`le ` objets sont des TAD.
e a

Exemple de TAD : Type Polynome - Interface
Constructeurs
ZERO → polynome
PLUS(Polynome, entier, reel) → Polynome
Autres gń´rateurs
e e
ADD(Polynome,Polynome) → Polynome
SOUSTR(Polynome,Polynome) → Polynome
MULT(Polynome,reel) → Polynome
PROD(Polynome,Polynome) → Polynome
DERIV(Polynome) → Polynome
Fonctions d’acc`s et d’interrogation
e
NUL(Polynome) → booleen
DEGRE(Polynome) → entier
COEF(Polynome, entier) → reel
VAL(Polynome,reel) → reel


´
1.3. PROGRAMMATION ORIENTEE OBJETS

Dans l’exemple de la pile, on aurait pu impl´menter cette structure avec un
e
tableau, ou encore une liste doublement chaˆ ee... Si, pour un probl`me donn´, on
ın´ e e
a besoin de cette structure de donné, la fa¸on dont elle est mise en oeuvre nous
e c
importe peu. Ce qui compte, c’est son comportement (caract´risations des fonctions
e
empiler, depiler,...). Or, tel que le module pile a ´t´ ćrit, on a le fichier pile.h
eee
suivant pour dćrire l’interface. Notez que rien n’empˆche l’utilisateur du module
e e
pile d’acc´der directement aux donnés (champ info par exemple) :
e e

// interface du module Pile de caracteres (pile.h)
#include <stdio.h>
typedef struct elt {
char info;
struct elt *suiv;
} Maillon, *Pile;
Pile empiler(char c,Pile P);
char depiler(Pile *P);
int vide(Pile P);

Exemple des formes góm´triques
e e
enum type{cercle,triangle,carre}
typedef struct{
float l;
point c;
type f;
} forme;
float surface(forme x) {
switch(x.f) {
case cercle :
return(PI*l*l);
break;
case triangle :
.....
break;
case carre :
.....
break;
}
}

L’ajout ou la suppression d’une nouvelle forme am`nent ` reprendre l’ensemble
e a
des fonctions et ` les adapter. De plus, un cercle a un rayon, un carr´ un cˆt´, un
a e oe
rectangle une longueur et une largeur...

1.3 Programmation orienté objets
e
Dans l’exemple des piles de caract`res, comment faire lorsqu’on veut utiliser des
e
piles d’entiers, et non plus de caract`res ? Il faudrait r´ćrire un module (alors que,
e ee
fondamentalement, une pile a toujours le mˆme comportement, que ce soit une pile
e
d’entiers, de caract`res, ou de n’importe quoi). L’approche orienté objets permet de
e e


1.4. JAVA, QU’EST-CE-QUE C’EST ?

r´soudre ce probl`me. La POO permet ´galement de r´soudre de fa¸on ´l´gante le
e e e e c ee
probl`me pos´ par le petit exemple des formes góm´triques, et ceci grˆce ` la notion
e e e e a a
d’h´ritage que l’on verra au chapitre 4.
e
Les objets sont au coeur de la POO... Un objet a deux caract´ristiques : son
e
´tat courant et son comportement. Dans l’exemple de la pile de caract`res, l’´tat est
e e e
repr´sent´ par le contenu de la pile, le comportement par les fonctions que l’on peut
e e
appliquer ` la pile.
a
L’´tat d’un objet est repr´sent´ par des attributs, son comportement par des
e e e
m´thodes. On ne peut modifier l’´tat d’un objet que par l’utilisation de ses m´thodes ;
e e e
l’encapsulation des donnés permet de cacher les d´tails d’impl´mentation d’un ob-
e e e
jet. Ceci dit, cette vue idále est trop rigide pour des applications informatiques.
e
Ainsi, en POO, on pourra avoir des attributs priv´s (modifiables uniquement via une
e
m´thode approprié) ou publics (accessibles directement par l’ext´rieur).
e e e
En POO, on utilise le concept de classe, qui permet de regrouper des objets de
mˆme nature. Par exemple, une pile de caract`res n’est qu’une pile de caract`res
e e e
parmi d’autres. En POO, on dira que notre pile particuli`re est une instance de la
e
classe des objets connus sous le nom de piles de caract`res. Toutes les piles de ca-
e
ract`res ont des caract´ristiques communes mais peuvent ˆtre dans un ´tat diff´rent.
e e e e e
– Une classe est un moule (on dira prototype) qui permet de d´finir e
les attributs (ou champs) et m´thodes communs ` tous les objets de
e a
cette classe.
– Les types abstraits de donnés dans le mod`le ` objets s’appellent
e e a
des classes.
– Les instances des classes sont des objets (ou instances).
– Les op´rations d’une classe sont ses m´thodes.
e e

attributs surface, couleur...
m´thodes
e afficher, detruire, changerCouleur...

Tab. 1.1 – La classe Forme góm´trique
e e

L’h´ritage Une notion fondamentale en POO est la notion d’h´ritage. Si l’on re-
e e
prend notre exemple des formes góm´triques, une fa¸on de proc´der est de d´finir la
e e c e e
classe FormeGeometrique avec les attributs et comportements communs ` toutes les
a
formes góm´triques. La sous-classe Cercle h´rite alors de la classe FormeGeometrique
e e e
et a ses propres spćificit´s.
e e

1.4 Java, qu’est-ce-que c’est ?
Java est compos´ de 4 ´l´ments :
e ee
– un langage de programmation
– une machine virtuelle (JVM)



£
FormeGeometrique
type (chaine de caracteres)
centre (point)
couleur (de remplissage)
afficher()
¢ ¨ rr ¡
¨¨¨ r
rr
¨ r
¨¨ rr
£
¨
£
¨
% r
j
Carre Rectangle
longueur £ c longueur
¢ ¡ Cercle ¢ largeur ¡
rayon
¢ ¡

Fig. 1.1 – Classe m`re et ses sous-classes
e

– un ensemble de classes standards r´parties dans diff´rentes API (Application
e e
Programming Interface)
– un ensemble d’outils (jdb, javadoc,...).
Le langage Java est connu et est tr`s souvent associ´ aux applets que l’on peut voir
e e
sur certaines pages WEB, gń´ralement de jolies applications graphiques... Il ne faut
e e
pas r´duire Java ` un langage d´di´ aux pages WEB. Il s’agit bien d’un langage `
e a e e a
part enti`re, qui vous permettra de ráliser de vraies applications !
e e
Dans ce qui suit, on reprend les adjectifs associ´s ` Java par leurs concepteurs
e a
(voir http ://java.sun.com/docs/white/langenv/Intro.doc2.html).

1.4.1 Simple et familier
Java est simple et familier car il n’utilise qu’un nombre restreint de concepts
nouveaux. Sa syntaxe est tr`s proche du langage C. Toutes les embˆches sur lesquelles
e u
butte le programmeur en C ou C++ sont ´liminés, par exemple :
e e
– seul existe le concept de classe, plus de struct, union et enum,
– plus de pointeurs et leur manipulation (avec parfois des pointeurs adressant
des emplacements non maˆ es !),
ıtris´
– plus de próccupation de gestion de la m´moire, Java a un “ramasse-miettes”
e e
(garbage collector) qui se charge (presque) de restituer au syst`me les zones
e
m´moires inaccessibles,
e
– plus de pr´processeur :
e
– comme Java est ind´pendant de la plateforme (voir plus loin), il n’est plus
e
nćessaire d’ćrire du code d´pendant de la plateforme,
e e e
– les fichiers d’entˆte .h n’ont plus lieu d’ˆtre, le code produit contient toutes
e e
les informations sur les types de donnés manipul´s.
e e
– ...

1.4.2 Orient´ objets
e
Enfin, Java est orient´ objets, car un programme Java est compl`tement centr´
e e e
sur les objets. Mis ` part les types primitifs et les tableaux, en Java tout est objet,
a



autrement dit, toutes les classes d´rivent de java.lang.Object. L’h´ritage en Java
e e
est simple, mais il existe l’h´ritage multiple pour les interfaces. Les objets se mani-
e
pulent via des r´f´rences. Enfin une librairie standard fournit plus de 500 classes au
ee
programmeur (l’API).

1.4.3 Interpr´t´, portable et ind´pendant des plateformes
e e e
C’est justement pour une question de portabilit´ que les programmes Java ne
e
sont pas compil´s en code machine. Le compilateur gń`re un code appel´ bytecode,
e e e e
code interm´diaire qui est ensuite interpr´t´ par la JVM (cf figure 1.2). De plus il
e ee
n’y a pas de phase d’´dition de liens ; les classes sont chargés dynamiquement en
e e
fonction des besoins, au cours de l’exćution, de mani`re incr´mentale. La taille des
e e e
types primitifs est ind´pendante de la plateforme.
e
La Java Virtual Machine (JVM) est pr´sente sur Unix, Windows, Mac, Netscape,
e
Internet Explorer, ...
4
Fichier Bonjour.java 4

public class Bonjour{ BONJOUR !
public static void main(String[ ] arg){
System.out.println(”BONJOUR !”) ;
}
}
7
7

interpr´teur
e
JVM (Java Virtual Machine)
compilateur

Fichier Bonjour.class

java Bonjour
javac Bonjour.java
~

Bytecode

Fig. 1.2 – Compilation et exćution d’un programme Java
e

1.4.4 Robuste et sˆ r
u
Il s’agit d’un langage fortement typ´, beaucoup d’erreurs sont donc ´liminés `
e e e a
la compilation. Le ramasse-miettes assure une bonne gestion de la m´moire et il n’y
e
a pas d’acc`s direct ` la m´moire. Le mćanisme des levés d’exceptions permet une
e a e e e
bonne gestion des erreurs d’exćution. Le compilateur est contraignant.
e
La sćurit´ est prise en charge par l’interpr´teur avec trois niveaux :
e e e
– Verifier qui v´rifie le code byte
e
– Class Loader qui est responsable du chargement des classes
– Security Manager qui v´rifie les acc`s ressources
e e


´
1.5. ENVIRONNEMENT DE DEVELOPPEMENT

1.4.5 Dynamique et multithread
Un programme Java est constitu´ de plusieurs classes. Lorsqu’un classe incon-
e
nue dans un programme est requise par celui-ci, la JVM la recherche et la charge
dynamiquement.
Un thread (appel´ aussi “processus l´ger”) est une partie de code s’exćutant en
e e e
concurrence avec d’autres threads dans un mˆme processus. Cela permet donc ` un
e a
programme unique d’effectuer plusieurs tˆches “simultan´ment”. La notion de thread
a e
est int´gré au langage et aux API.
e e

1.4.6 Distribu´
e

1.5 Environnement de d´veloppement
e
Le JDK (Java Developer Kit) contient l’ensemble des librairies standards de java
(java.lang, java.util, java.awt, ...), le compilateur (javac), un interpr´teur e
d’applets (appletviewer), un interpr´teur (java), un gń´rateur de documentation
e e e
(javadoc) et quelques autres outils... C’est le minimum pour d´velopper des appli-
e
cations en Java.
Par ailleurs, il existe de nombreux environnement de d´veloppement. On en cite
e
deux ci-dessous (cf. http ://java.developpez.com/outils/edi/) pour plus de d´tails...
e
JBuilder de Bordland est tr`s bien plac´ parmi les environnements professionnels
e e
pour le d´veloppement d’applications Java (http ://www.borland.fr/jbuilder/index.html).
e
Anciennement connu sous le nom de Forte for Java, Sun ONE (Open Net
Environnement) Studio s’appuie sur le noyau de NetBeans, projet initi´ par Sun
e
(http ://developers.sun.com/prodtech/devtools/).
GNU/Emacs est un ´diteur polyvalent. Pour l’´dition du code, il poss`de de nom-
e e e
breux ”modes” : C, C++, HTML, Java, qui vont adapter le fonctionnement d’Emacs.
Il dispose d’un grand nombre de fonctions, couramment utilisés (en programma-
e
tion) : recherche/remplacement (supporte les expressions r´guli`res ), indentation
e e
automatique du code, coloration syntaxique, (Re)d´finition des raccourcis claviers,
e
auto-compl´tion, gestion du multifenˆtrage, etc... ( plus de 1600 fonctions assurés
e e e
). Nous choisirons de travailler avec cet ´diteur et de compiler et exćuter en ligne
e e
de commande.


Chapitre 2

Syntaxe de base

Dans ce chapitre, on introduit la syntaxe de base du langage. Vous verrez qu’elle
est assez proche de celle du langage C, avec quelques ajouts et diff´rences. Ce qui
e
change radicalement, c’est l’approche orienté objets, ce sera l’objet du chapitre
e
suivant.

2.1 Unit´s lexicales
e
Le compilateur Java reconnait cinq types d’unit´s lexicales : les identificateurs,
e
les mots r´serv´s, les litt´raux, les op´rateurs et les s´parateurs.
e e e e e

2.1.1 Jeu de caract`res
e
Java utilise le jeu de caract`res Unicode. Les caract`res sont cod´s sur 16 bits
e e e
(au lieu de 7 pour le code ASCII). Ce code a ´t´ introduit pour tenir compte de tous
ee
(ou presque !) les alphabets.

2.1.2 Commentaires
Java reconnait trois types de commentaires :
– les commentaires sur une ligne : tous les caract`res suivants //... jusqu’` la
e a
fin de la ligne sont ignor´s
e
– les commentaires multilignes : tous les caract`res entre /* ... et...*/ sont
e
ignor´s
e
– les commentaires de documentation : quand ils sont plac´s juste avant une
e
dćlaration, les caract`res entre /** ...et...*/ sont inclus dans une docu-
e e
mentation gń´ré automatiquement par l’utilitaire javadoc.
e ee

2.1.3 Identificateurs
Les identificateurs ne peuvent commencer que par une lettre, un soulign´ (’ ’) ou
e
un dollar (’$’). Les caract`res suivants peuvent ˆtre des lettres ou des chiffres ou tout
e e
caract`re du jeu Unicode de code sup´rieur ` H00C0.
e e a

9

´
2.1. UNITES LEXICALES

Exemples : x Bidule Bidule $Bidule

Note : on convient de r´server des noms commen¸ant par une majuscule aux classes,
e c
les noms compos´s sont sous la forme “NomCompos´” ou bien “nomCompos´”, et de
e e e
fa¸on gń´rale, on conseille de nommer les variables et m´thodes de fa¸on parlante.
c e e e c

2.1.4 Mots r´serv´s
e e
Les identificateurs du tableau suivant sont des mots cl´s du langage et sont ` ce
e a
titre des mots r´serv´s que vous ne pouvez en aucun cas utiliser comme identifica-
e e
teurs.

abstract double int super
boolean else interface switch
break extends long synchronized
byte final native this
case finally new throw
catch float package throws
char for private transient
class goto * protected try
const * if public void
continue implements return volatile
default import short static
do instanceof while

* indique un mot cl´ qui n’est pas utilis´ dans les versions actuelles
e e

Il y a encore trois mots r´serv´s du langage qui ne sont pas des mots cl´s mais
e e e
des litt´raux :true false et null.
e

2.1.5 Types primitifs simples
Toute variable ou expression a un type qui permet de d´finir l’ensemble des valeurs
e
et des actions l´gales. Java a un petit nombre de types pr´d´finis appel´s aussi types
e e e e
primitifs, le mćanisme des classes et interfaces permet ensuite de d´finir d’autres
e e
types.
Java a deux sortes de types : les types simples, atomiques (entiers, réls, booléns
e e
et caract`res) et les types composites (tableaux, classes et interfaces).
e


´
2.1. UNITES LEXICALES

Caract`res
e
Le type caract`re est char. Il est repr´sent´ sur 16 bits (jeu de caract`res Uni-
e e e e
code).

Booléns
e
Le type boolén est boolean. Les deux seules valeurs qu’il peut prendre sont true
e
et false. Il s’agit du type retourn´ par les op´rateurs relationnels (cf.2.3.4).
e e

Entiers
Ils sont tr`s similaires ` ceux de C, sinon qu’ils sont ind´pendants de la plate-
e a e
forme. Les 4 types d’entiers sont :
– byte =⇒ entier sur 8 bits (compl´ment ` 2)
e a
– short =⇒ entier sur 16 bits (compl´ment ` 2)
e a
– int =⇒ entier sur 32 bits (compl´ment ` 2)
e a
– long =⇒ entier sur 64 bits (compl´ment ` 2)
e a

Réls
e
Il n’y a que deux types de réls en Java :
e
– float=⇒ repr´sent´ sur 32 bits
e e
– double=⇒ repr´sent´ sur 64 bits
e e

2.1.6 Constantes litt´rales
e
Constantes boolénnes
e
On l’a vu, les seules possibles sont true et false

Constantes caract`res
e
Elles sont constitués d’un caract`re ou une s´quence d’ćhappement entre des
e e e e
guillemets simples :
’a’, ’b’,...
’’’, ’’, ’’
’n’ nouvelle ligne
’t’ tabulation

Constantes enti`res
e
Elles peuvent s’ćrire
e
– en notation dćimale : 123, -123
e
– en notation octale avec un z´ro en premi`re position : 0123
e e


2.2. LES VARIABLES

– en notation hexadćimale, avec les caract`res 0x ou 0X au d´but : 0xDead,
e e e
0XbaBA
Le type d’une constante est toujours int, pour prćiser qu’une constante est de
e
type long, la faire suivre de l ou L (par exemple, 1L, 0x7FFL,...).

Constantes rélles
e
Elles se pr´sentent sous la forme d’une partie enti`re suivie d’un point (.), suivi
e e
d’une partie dćimale, d’un exposant et un suffixe de type. L’exposant est un E ou e
e
suivi d’un entier.
3.1415, 3.1E12, .1E-4
2.0d (ou 2.0D) est un rél double
e
2.0f (ou 2.0F) est un rél float
e

Constantes chaˆ
ınes de caract`res
e
Une chaˆ de caract`res est une suite de caract`res d´limité par des guillemets.
ıne e e e e
Attention, en Java les chaˆ ınes de caract`res sont des objets et forment ` ce titre
e a
un type ` part enti`re, il ne s’agit pas d’un tableau de caract`res. On verra la classe
a e e
String plus loin (6)

2.2 Les variables
Toute variable doit avoir ´t´ dćlaré. La dćlaration d’une variable consiste `
ee e e e a
lui donner un nom et un type, ´ventuellement une valeur initiale et un qualificatif.
e
La dćlaration alloue la place m´moire nćessaire au stockage, la taille d´pendant du
e e e e
type. Java distingue diff´rentes natures de variables (pas nćessairement incompa-
e e
tibles) :
– les variables d’instances,
– les variables de classe,
– les param`tres de m´thodes,
e e
– les param`tres de constructeurs,
e
– les variables de type exception,
– les variables locales.
Le qualificatif final permet d’interdire la modification ult´rieure d’une variable.
e
La dćlaration des variables locales se fait dans le bloc o` elles sont utilisés, elles
e u e
sont alors visibles ` partir de leur dćlaration jusqu’` la fin du bloc.
a e a

...
for(int i=0;i10;i++) {
...
// i est visible dans ce bloc
}
...


´
2.3. EXPRESSIONS ET OPERATEURS

Il n’y a pas vraiment de notion de variable globale en Java. Toute dćlaration de
e
variable se trouve nćessairement dans la dćlaration d’un classe. Seules les variables
e e
qualifiés de static (dites de classe) et public peuvent ressembler aux variables
e
globales de C et C++.

2.3 Expressions et op´rateurs
e
Les expressions en Java ressemblent beaucoup ` celles que l’on ćrit en C. Elles
a e
sont composés de constantes, variables et op´rateurs, assembl´s “correctement”.
e e e
L’essentiel d’un programme consiste ` ´valuer des expressions pour produire ce
ae
qu’on appelle des effets de bord, ou pour calculer des valeurs. Une expression avec
effet de bord est une expression qui, lorsqu’elle est ´valué, produit un changement
e e
de l’´tat du syst`me. Par exemple, l’affectation est une expression qui a pour effet
e e
de bord la modification du contenu de l’op´rande gauche.
e
Le r´sultat de l’´valuation d’une expression est soit une valeur, soit une variable
e e
(une lvalue, (pour left ou location value) une adresse, membre gauche d’une affecta-
tion, ` opposer ` une rvalue qui est une valeur), soit void. Ce dernier cas apparaˆ
a a ıt
lors de l’invocation d’une m´thode qui ne retourne rien.
e

2.3.1 Priorit´ des op´rateurs et ordre d’´valuation
e e e
Les op´rateurs, de la priorit´ la plus forte ` la plus faible sont donn´s dans le
e e a e
tableau 2.3. Introduire des parenth`ses rend souvent l’expression plus lisible, et dans
e
tous les cas l`ve les ambiguit´s. L’ordre d’´valuation est important. A part dans le
e e e
cas des op´rateurs || et ? : les op´randes de chaque op´ration sont compl`tement
e e e e
´valués avant d’effectuer l’op´ration. Java garantit ´galement que les op´randes sont
e e e e e
´valués de gauche ` droite (dans l’expression x + y, x est ´valu´ avant y). Ceci est
e e a e e
important lorsqu’on a des expressions avec effets de bord. Les op´rateurs de Java
e
sont d´taill´s plus loin (2.3.4).
e e

2.3.2 Type d’une expression
Toute expression a un type, connu d`s la compilation. Ce type est d´termin´ par
e e e
celui des op´randes et par la s´mantique des op´rateurs. Si le type d’une expres-
e e e
sion n’est pas appropri´, cela conduit ` une erreur de compilation. Par exemple, si
e a
l’expression dans une structure de test if n’est pas de type boolean, le compila-
teur produit une erreur. Dans d’autres cas, plutˆt que de demander au programmeur
o
d’indiquer une conversion de type explicite, Java produit une conversion implicite
du type de l’expression en un type qui convient au contexte. Il existe ainsi plusieurs
sortes de conversions implicites.
Les conversions d’un type primitif ` un type primitif plus large pour lesquelles
a
on ne perd pas d’information :
– byte → short,int,long,float, ou double
– short → int, long, float, ou double


´
2.3. EXPRESSIONS ET OPERATEURS

– char → int, long, float, ou double
– int → long, float, ou double
– long → float ou double
– float → double
Les conversions d’un type primitif ` un type primitif plus restreint pour lesquelles
a
on perd de l’information, ou de la prćision :
e
– byte → char
– short → byte ou char
– char → byte ou short
– int → byte, short, ou char
– long → byte, short, char, int
– float → byte, short, char, int,ou long
– double → byte, short, char, int,long, float
Pour les conversions sur les r´f´rences, nous verrons cela plus loin...
ee

2.3.3 Erreur d’´valuation d’une expression
e
L’´valuation d’une expression peut conduire ` une erreur, dans ce cas Java lance
e a
une exception qui prćise la nature de l’erreur (voir chapitre 7).
e

OutOfMemoryError espace m´moire requis insuffisant
e
ArrayNegativeSizeException une dimension de tableau est n´gative
e
NullPointerException valeur de r´f´rence ` null
ee a
IndexOutOfBoundsException valeur d’indice de tabelau hors des bornes
ClassCastException opátion de cast interdite
r
ArithmeticException division par z´ro
e
ArrayStoreException affectation ` un ´l´ment de tableau d’une r´f´rence
a ee ee
de type incompatible
des exceptions gń´rés par l’invocation d’une m´thode
e ee e
des exceptions gń´rés par les constructeurs
e ee
bien d’autres !...

Tab. 2.1 – Exemples de levés d’exceptions
e

2.3.4 Op´rateurs
e
Le tableau 2.2 pr´sente tous les op´rateurs du langage, avec leur ordre d’´valuation
e e e
et leur s´mantique. Il manque dans ce tableau les op´rateurs :
e e
– les op´rateurs d’affectation (+=, -=, *=, ...) dont l’´valuation est faite de droite
e e
a
` gauche,
– les op´rateurs de manipulation de bits :
e
(ET bit ` bit), | (OU bit ` bit), ∧ (OU exclusif bit ` bit) et ∼ (compl´mentation
a a a e
bit ` bit),
a


ˆ
2.4. STRUCTURES DE CONTROLE

de dćalage des bits ;
e
– l’op´rateur ternaire conditionnel (si-alors-sinon) : cond ?expr1 :expr2
e

Op´rateur(s)
e Ordre Type Description
= D/G variable affectation
* / % G/D arithm´tique
e multiplication, division, reste
+ - G/D arithm´tique
e addition, soustration
+ - G/D arithm´tique
e plus, moins unaires
++ - - G/D arithm´tique
e pr´ et post incr´ment, dćr´ment1
e e e e
≤ ≥ G/D arithm´tique
e comparaison arithm´tique
e
== != G/D objet, type primitif comparaison ´gal et diff´rent
e e
+ G/D chaˆınes de caract`res
e concatńation
e
! D/G boolén
e non boolén
e
∧ | G/D boolén
e ET, OU exclusif, OU
(les 2 op´randes sont ´valués)
e e e
|| G/D booléns
e ET, OU conditionnels (l’op´rande
e
de droite n’est pas nćessairement ´valué)
e e e

Tab. 2.2 – Op´rateurs de Java
e

2.4 Structures de contrˆle
o
2.4.1 Instructions et blocs d’instructions
Un programme Java est constitu´ de dćlarations de classes dans lesquelles fi-
e e
gurent des m´thodes. Ces derni`res sont construites ` l’aide d’instructions combinés
e e a e
entre elles par des structures de contrˆle.
o
Une instruction est une expression suivie d’un point virgule. Les instructions
composés ou blocs d’instructions sont des suites d’instructions simples ou composés
e e
d´limités par des accolades { et }. L’accolade fermante n’est pas suivie de point
e e
virgule.

Exemple :
{ int i;
i=4;
System.out.println(coucou ! );
System.out.println(i vaut +i);
}
1
la valeur d’une expression de post-incr´ment est la valeur de l’op´rande et a pour effet de bord
e e
le stockage de la valeur de l’op´rande incr´menté de 1, la valeur d’une expression de pr´-incr´ment
e e e e e
est la valeur de l’op´rande incr´menté de 1 et a pour effet de bord le stockage de cette valeur.
e e e
C’est similaire pour le dćr´ment.
e e


ˆ

op´rateurs postfixes
e [] . (params) expr++ expr–
op´rateurs unaires
e ++expr –expr +expr -expr ∼ !
crátion ou cast
e new (type)expr
op´rateurs multiplicatifs
e * / %
op´rateurs additifs
e + -
op´rateurs de shift
e
op´rateurs relationnels
e = = instanceof
op´rateurs d’´galit´
e e e == !=
ET bit ` bit
a
OU exclusif bit ` bit
a ∧
OU inclusif bit ` bit
a |
ET logique
OU logique ||
op´rateur conditionnel
e ?:
affectations = += -= *= /= %= = ∧=
|= = = =

Tab. 2.3 – Op´rateurs dans l’ordre dćroissant de priorit´
e e e

L’objet de cette section est de passer bri`vement en revue toutes les structures
e
de contrˆle (vous les connaissez d´j`).
o ea

2.4.2 Instruction conditionnelle : if
Elle permet d’exćution des instructions de mani`re s´lective, en fonction du
e e e
r´sultat d’un test.
e

if (expression) instruction1
if (expression) instruction1 else instruction2

2.4.3 Etude de cas : switch
Elle permet de choisir un bloc d’instruction selon la valeur d’une expression
enti`re :
e

switch (expression) {
case cste1 :
instruction1
case cste2 :
instruction2
...
case csteN :
instructionN
default :


ˆ

instructionDefaut
}

Attention, si la valeur de expression vaut csteI, instructionI sera exćuté
e e
ainsi que toutes les suivantes (instructionI+1...instructionDefaut) sauf si une
instruction break a ´t´ rencontré. L’exemple suivant illustre le fonctionnement de
ee e
cette structure de contrˆle :
o

Exemple :

char c;
...
switch (c) {
case ’1’:
case ’2’:
case ’3’: // notez l’absence d’intruction
case ’5’:
case ’7’:
System.out.println(c+est un nombre premiern);
break; // notez l’instruction break
case ’6’:
System.out.println(c+est un multiple de 3n);
// notez l’absecnce de break
case ’4’:
case ’8’:
break;
case ’9’:
break;
default :
System.out.println(c+n’est pas un chiffre non nuln);
}
...

2.4.4 It´rations : while, do...while et for
e
La structure de contrˆle while ´value une condition et exćute l’instruction tant
o e e
que cette condition reste vraie.

while (condition)
instruction

Exemple :


ˆ

int i=10;
while (i=0) {
System.out.println(i);
i=i-1;
}

L’instruction do...while est une variante de la prć´dente. Une it´ration est
e e e
toujours exćuté. Il faut la traduire en fran¸ais par Faire... tant que. Attention de
e e c
ne pas confondre avec la structure r´p´ter...jusqu’` ce que !
e e a

do
instruction
while (condition)

Exemple :

int i=-1;
do {
System.out.println(i);
i=i-1;
} while (i=0);

Enfin, l’instruction for qui comporte une initialisation, une condition d’arrˆt, et
e
une ou des instructions de fin de boucle :

for (instruction1;condition_de_poursuite;instruction2) instruction3

est ´quivalente ` :
e a

instruction1;
while (condition_de_poursuite) {
instruction3
instruction2
}

La virgule (,) est utilisé pour combiner plusieurs initialisations et plusieurs ins-
e
tructions de fin de boucle.

2.4.5 Etiquettes, break, continue et return
Toute instruction peut ˆtre ´tiqueté.
e e e

label : instruction

L’instruction break d´j` vue avec le switch est utilisé aussi dans les structures
ea e
de boucle et permet la sortie imm´diate de la boucle, sans tenir compte des conditions
e
d’arrˆt de cette derni`re. Une variante permet d’associer une ´tiquette ` l’instruction
e e e a
break.


2.5. STRUCTURE D’UN PROGRAMME AUTONOME JAVA

label : instruction1
while(...){
...
break label;
...
}

Ceci dit, l’usage des ´tiquettes et du break est fortement dćonseill´, ce n’est
e e e
pas ´l´gant, cela nuit ` la lisibilit´ du programme, c’est contraire aux principes de la
ee a e
programmation structuré ! La plupart du temps, on peut s’en passer.
e
L’instruction continue apparaˆ dans les structures de boucles. Elle produit
ıt
l’abandon de l’it´ration courante et, si la condition d’arrˆt n’est pas satisfaite, le
e e
d´marrage de l’it´ration suivante.
e e
L’instruction return quant ` elle est indispensable ! Elle provoque l’abandon de
a
la fonction en cours et le retour ` la fonction appelante. Quand elle est suivie d’une
a
expression, le r´sultat de cette expression est la valeur que la fonction appelé renvoie
e e
a
` la fonction appelante. Mais attention, il est dćonseill´ de placer une instruction
e e
return dans le corps d’une boucle, cela signifie que vous n’avez probablement pas
bien ćrit la condition de sortie de la boucle !
e

2.5 Structure d’un programme autonome Java
Un programme Java est constitu´ d’une ou plusieurs classes. Parmi ces classes, il
e
doit y en avoir au moins une qui contienne la m´thode statique et publique main qui
e
est le point d’entré de l’exćution du programme. Voici un exemple (l’in´vitable !) :
e e e

Exemple :
// Fichier Bonjour.java
public class Bonjour {
public static void main(String[] arg) {
System.out.println(Bonjour !n);
}
}
On a d´fini une classe Bonjour qui ne poss`de qu’une seule m´thode. La m´thode
e e e e
main doit ˆtre dćlaré static et public pour pouvoir ˆtre invoqué par l’in-
e e e e e
terpr´teur Java. L’argument arg est un tableau de chaˆ
e ınes de caract`res qui corres-
e
pond aux arguments de la ligne de commande lors du lancement du programme.
Avant tout, il faut compiler ce programme avec la commande javac :
javac Bonjour.java
La compilation traduit le code source en byte code. Le compilateur produit autant
de fichiers que de classes pr´sentes dans le fichier source. Les fichiers compil´s ont
e e
l’extension .class.


2.5. STRUCTURE D’UN PROGRAMME AUTONOME JAVA

Enfin, pour exćuter le programme, il faut utiliser l’interpr´teur de code Java et
e e
lui fournir le nom de la classe public que l’on veut utiliser comme point d’entré :
e

java Bonjour


Chapitre 3

Classes et Objets

En C on utilise des structures pour cr´r des TAD (Types Abstraits de Donnés),
e e
ou structures de donnés complexes. Dans les langages orient´s objets, on utilise le
e e
concept de classes. Elle permettent de d´finir de nouveaux types de donnés qui se
e e
comportent comme des types pr´d´finis et dont les d´tails d’impl´mentation sont
e e e e
cach´s aux utilisateurs de ces classes. Seule l’interface fournie par le concepteur peut
e
ˆtre utilisé.
e e
Un objet est une instance d’une classe (qui peut ˆtre vue comme un moule). Les
e
objets communiquent entre eux par des messages qui sont ´valu´s par des m´thodes.
e e e
Ces messages ´valu´s par des m´thodes de l’objet, induisent des modification de son
e e e
´tat ou de son comportement. Les objets vivent en famille, et peuvent donc h´riter
e e
des caract´ristiques de leurs ancˆtres, en affinant (spćialisant) ces caract´ristiques.
e e e e
Un objet est caract´riq´ par :
e e
– un ensemble d’attributs, typ´s et nomm´s repr´sentant des propri´t´s statiques.
e e e ee
L’ensemble des valeurs des attributs consitue l’´tat de l’objet,
e
– un ensemble de m´thodes, d´finissant son comportement et ses ráctions `
e e e a
des stimulations externes. Ces m´thodes impl´mentent les algorithmes que l’on
e e
peut invoquer sur ces objets,
En Java, on ne peut acc´der ` un objet que par une r´f´rence vers celui-ci. Une
e a ee
r´f´rence est une sorte de pointeur vers la structure de donnés, avec la diff´rence qu’il
ee e e
est interdit de manipuler les r´f´rences comme les pointeurs en C ou C++. On ne peut
ee
pas connaˆ la valeur d’une r´f´rence, ni effectuer d’op´rations arithm´tiques. La
ıtre ee e e
seule manipulation possible consiste ` changer la valeur de la r´f´rence pour qu’elle
a ee
“fasse r´f´rence” ` un autre objet.
ee a
Une classe est un moule d’objets, elle en dćrit la partie privé (structure de
e e
donnés interne ou attributs et corps des m´thodes), et la partie publique (nom
e e
et param`tres des m´thodes). C’est un gń´rateur d’objets, on peut ainsi crér un
e e e e e
ensemble d’objets rentrant dans ce moule.

3.1 Dćlaration des classes
e
Basiquement, une classe d´finit :
e

21

´
3.1. DECLARATION DES CLASSES

– les structures de donnés associés aux objet de la classe, les variables d´signant
e e e
ces donnés sont appelés champs ou attributs,
e e
– les services ou comportements associ´s aux objets de la classe qui sont les
e
m´thodes, d´finies dans la classe.
e e

3.1.1 Champs ou attributs
Java poss`de trois mots cl´s pour l’encapsulation des donnés (les droits d’acc`s) :
e e e e
public, private et protected. Nous les reverrons plus en d´tail, mais retenez ici que
e
les donnés et m´thodes dćlarés public sont accessibles par toutes les classes. In-
e e e e
versement, les donnés et m´thodes dćlarés private ne sont accessibles que par les
e e e e
m´thodes de cette classe. Enfin, le mot cl´ protected institue une notion de “famil-
e e
le”. Supposons que nous voulions dćlarer une structure de donnés Date constitué
e e e
de trois entiers codant le jour, le mois et l’anné :
e
class Date{
private int mois;
private int jour;
private int annee;
...
}
Les donnés mois, jour et anné ont ´t´ dćlarés privés. Elles ne seront acces-
e e ee e e e
sibles que par des m´thodes d´finies de la classe Date dans la section qui suit.
e e

3.1.2 M´thodes
e
Elles sont d´finies par un identificateur, des param`tres formels, un type de retour,
e e
un corps et ´ventuellement un qualificatif (comme pour les champs) public, private
e
ou protected.

class Date{
private int mois;
private int jour;
private int annee;
...
public void affecter(int m, int j, int a) {
mois=m; jour=j; annee=a;
}
public int quelJour(){return jour;}
public int quelMois(){return mois;}
public int quelleAnnee(){return annee;}
public void imprimer(){
System.out.println(jour+/+mois+/+annee);
}
}


´

La m´thode affecter fait partie de la classe Date, il lui est donc permis d’acc´der
e e
a
` ses champs priv´s. Et cette m´thode, puisqu’elle est dćlaré public, permet de
e e e e
modifier les champs d’un objet de la classe Date. Les m´thodes publiques d’une classe
e
constituent ce que l’on appelle son interface publique.
Contrairement au langage C++ la d´finition effective des m´thodes de la classe
e e
doit se faire dans la d´finition de la classe.
e
Une m´thode est un message envoy´ ` un objet. Ainsi, pour afficher la date
e e a
contenue dans l’objet d, on lui envoie le message imprimer :

d.imprimer();

De telles m´thodes sont appelés m´thodes d’instances, elles sont ´voqués via un ob-
e e e e e
jet. Nous verrons plus loin qu’il existe des m´thodes de classes. La m´thode imprimer
e e
n’est utilisable que parce qu’elle fait partie des m´thodes publiques. Par contre, il ne
e
sera pas possible d’acc´der aux champs d.jour, d.mois et d.annee car ce sont des
e
donnés privés.
e e

3.1.3 Crátion d’objets
e
Une fois la classe dćlaré, pour pouvoir utiliser un objet de cette classe, il faut
e e
d´finir une instance de cette classe. La dćlaration suivante ne fait que d´finir une
e e e
r´f´rence vers un objet ´ventuel de la classe Date :
ee e

Date d;

La variable d repr´sente une r´f´rence vers un objet de type Date qui doit ˆtre
e ee e
instanci´ (cr´´) explicitement avec le mot cl´ new et le constructeur (cf. section3.1.4)
e ee e
de la classe Date :

Date d; //dćlaration de la r´f´rence d
e e e
d = new Date(); // instanciation de l’objet r´f´renc´ par d
e e e

3.1.4 Constructeurs
On a dit que pour d´finir un objet d’une classe, il fallait faire appel ` son construc-
e a
teur. En l’absence de constructeur(s) explicite(s), un constructeur implicite, sans
argument, est invoqu´ par d´faut.
e e
Lorsque l’on veut d´finir un objet, il est souvent utile de pouvoir initialiser cet
e
objet. Dans notre exemple de la classe Date, il est possible d’utiliser la m´thodee
affecter pour donner une valeur aux champs d.jour, d.mois et d.annee.

Date aujourdhui=new Date();
aujourdhui.affecter(8,25,1961);

Mais ce n’est pas tr`s agráble. Le constructeur est une m´thode spćifique qui est
e e e e
automatiquement appelé lors de la crátion d’un objet. Elle a la particularit´ de
e e e
porter le mˆme nom que la classe, d’ˆtre publique et n’a pas de valeur de retour.
e e


´

class Date {
...
public Date(int j, int m, int a) {
jour=j; mois=m; annee=a;}
...
}
Maintenant, pour crér un objet de type Date il faudra fournir imp´rativement
e e
le jour, le mois et l’anné. On peut contourner ce probl`me en fournissant plusieurs
e e
constructeurs :
class Date {
...
jour=j; mois=m; annee=a;}
public Date(int j, int m) {
jour=j; mois=m; annee=2000;}
public Date(int j) {
jour=j; mois=1; annee=2000;}
public Date() {
jour=1; mois=1; annee=2000;}
...
}

3.1.5 Destructeurs
En gń´ral, en Java, on n’a pas ` se soucier de la restitution de l’espace m´moire
e e a e
occup´ par un objet qui n’est plus r´f´renc´. On a d´j` ´voqu´ le “ramasse-miettes”
e ee e eae e
(garbage collector) qui est un syst`me de rćup´ration de m´moire automatique. Par
e e e e
d´faut, ce syst`me tourne en arri`re-plan pendant l’exćution de vos programmes. Il
e e e e
rep`re les objets qui ne sont plus r´f´renc´s, et lib`re l’espace en m´moire allou´ `
e ee e e e ea
ceux-ci. Vous pouvez d´sactiver le ramasse-miettes (option -noasyngc sur la ligne
e
de commande de lancement de la JVM).
Selon les applications, un objet peut bloquer d’autres types de ressources que la
m´moire (descripteur de fichiers, socket, ...), il est alors bon d’utiliser un destruc-
e
teur pour lib´rer ces ressources. De plus, vous pouvez ne pas vouloir attendre que
e
le ramasse-miettes lib`re des ressources critiques. Il existe une m´thode spćifique
e e e
finalize qui est un destructeur et red´finit la m´thode protected void finalize
e e
de la classe Object. Une classe peut donc impl´menter une m´thode finalize qui
e e
est dćlaré de la fa¸on suivante :
e e c
protected void finalize() throws Throwable {
super.finalize();
...
}
Ce code s’ćlaircira plus tard, avec les notions d’h´ritage et d’exceptions.
e e


´
3.2. DEFINITIONS DE CHAMPS

3.2 D´finitions de champs
e
3.2.1 Champs de classe
Si l’on d´finit trois objets de type Date, chacun aura ´videmment son propre jeu
e e
de valeurs pour les champs jour, mois, annee. De tels champs sont appel´s variables
e
(ou attributs) d’instances. Il est des cas o` il est souhaitable d’avoir une donné
u e
commune ` tous les objets d’une mˆme classe. Un champ d’une classe est dit static
a e
(ou de classe) ; il n’y a qu’un seul exemplaire de ce champ pour tous les objets de
cette classe. Ce champ existe mˆme s’il n’y a aucune instance de la classe.
e

Exemple :

class Date{
private int mois;
private int jour;
private int annee;
public static int nbDate=0;

public Date(int j, int m, int a){
nbDate++;
}
public int quelJour(){return jour;}
public int quelMois(){return mois;}
public int quelleAnnee(){return annee;}
}
}

class Programme{
public static void main(String[] arg){
Date aujourdhui=new Date(25,9,2000);
Date noel=new Date(25,12,2000);
aujourdhui.imprimer();
noel.imprimer();
System.out.println(noel.nbDate);
System.out.println(Date.nbDate);
}
}

Voici le r´sultat obtenu :
e

chaouiya@pccc:~/coursJava/Notes_cours$ javac Programme.java
chaouiya@pccc:~/coursJava/Notes_cours$ java Programme


´
3.2. DEFINITIONS DE CHAMPS

25/9/2000

25/12/2000

2
2

Initialisation des champs de classe
Les champs static sont initialis´s une fois lors du chargement de la classe qui
e
les contient. Une erreur de compilation se produit lorsque :
– un champ de classe est initialis´ relativement ` un champ de classe d´fini plus
e a e
loin
class X{
static int x = y+1; // erreur, y est declare apres x
static int y =0;
static int z=z+1; // erreur
}
– un champ de classe est initialis´ relativement ` un champ d’instance
e a
class X{
public int x=120;
static int y=x+10; // erreur, x variable d’instance
}

Initialisation des champs d’instance
Les champs d’instance sont initialis´s lors de l’instanciation (` la crátion) des
e a e
objets de la classe. Contrairement aux champs de classe, chaque instanciation pro-
voque l’intialisation des champs de l’objet cr´´. Une erreur de compilation se produit
ee
si un champ d’instance est initialis´ par r´f´rence ` un champ d’instance d´fini plus
e ee a e
loin. On peut utiliser les valeurs des champs de classe pour initialiser des champs
d’instance.

3.2.2 Mot cl´ this
e
Il d´signe l’objet sur lequel la m´thode est invoqué. On peut par exemple r´ćrire
e e e ee
la m´thode affecter comme suit :
e

public void affecter(int m, int j, int a) {
this.mois=m; this.jour=j; this.annee=a;
}

Dans l’exemple qui suit, l’int´rˆt du mot cl´ this est certainement mieux illustr´.
ee e e
On cré une liste chaˆ ee de tous les objets de type Date qui ont ´t´ instanci´s :
e ın´ ee e

class Date{


´ ´
3.3. DEFINITION DE METHODES

private int mois;
private int jour;
private int annee;
private Date suivant;
public static Date listeDates=null;
jour=j; mois=m; annee=a;
suivant=listeDates;
listeDates=this;
}
}
}
class Test {
for (Date d=Date.listeDates; d!=null; d=d.suivant) d.imprimer();
}
}

3.2.3 Champs final
Un champ peut ˆtre dćlar´ final pour indiquer qu’il ne peut pas ˆtre modif´, et
e e e e e
gardera donc une valeur constante. Leur initialisation doit se faire de la mˆme fa¸on
e c
que pour les champs de classe.

3.3 D´finition de m´thodes
e e
3.3.1 Le passage des param`tres
e
Tous les param`tres sont pass´s par valeur. Les seuls types possibles de param`tres
e e e
sont les types primitifs et les r´f´rences. Autrement dit :
ee
– les types primitifs sont pass´s par valeur. Une m´thode ne peut donc jamais
e e
modifier la valeur d’une variable de type primitif,
– les r´f´rences ´galement sont passés par valeur (valeur de la r´f´rence vers
ee e e ee
l’objet). Si la m´thode modifie un champ de l’objet r´f´renc´, c’est l’objet qui
e ee e
est modifi´, et le code appelant voit donc l’objet r´f´renc´ modifi´.
e ee e e

3.3.2 Signature et polymorphisme
Contrairement ` ce que vous connaissez en C, un mˆme identificateur peut ˆtre
a e e
utilis´ pour d´signer deux m´thodes ` condition que leur signature soit diff´rente.
e e e a e


´ ´

On appelle signature d’une m´thode, la donné de son nom, du nombre de ses pa-
e e
ram`tres formels et de leurs types.
e

int methode1(int i){...} // erreur, type retour de la methode ne
float methode1(int i){...} // fait pas partie de sa signature
int methode2(int i){...}
float methode2(float f){...} //OK
int methode3(int i) {...}
int methode3(int i, int j) {...} //OK

3.3.3 Variables locales
Les variables locales sont alloués lors de l’invocation de la m´thode et sont
e e
d´truites ` la fin de celle-ci. Ces variables ne sont visibles qu’` l’int´rieur de la
e a a e
m´thode ou du bloc d’instructions o` elles sont dćlarés.
e u e e

3.3.4 M´thodes de classe
e
Les m´thodes vues juqu’` pr´sent s’appliquent toujours ` une r´f´rence sur un ob-
e a e a ee
jet. Les m´thodes qualifiés de static sont celles qui n’ont pas besoin d’une instance
e e
pour ˆtre invoqués.
e e
Comme toute m´thode, une m´thode de classe est membre d’une classe. Elle est
e e
invoqué en lui associant, non pas un objet mais la classe ` laquelle elle appartient.
e a
Par exemple, la m´thode sqrt qui calcule la racine carré appartient ` la classe Math.
e e a
Pour l’invoquer on ćrit : Math.sqrt(x) ;
e
Une m´thode static, puisqu’elle ne s’applique pas sur un objet, ne peut acc´der
e e
aux variables d’instances. De mˆme, le mot cl´ this n’a pas de sens dans une m´thode
e e e
static.

class Date{
private int mois;
private int jour;
private int annee;
private Date suivant;
public static Date listeDates=null;
suivant=listeDates;
listeDates=this;
}
...
}
public static void listerDate(){


´ ´

for (Date d=Date.listeDates; d!=null; d=d.suivant)
d.imprimer();*
}
}
class Test {
Date.listerDate();
}
}


Chapitre 4

H´ritage
e

4.1 Introduction
La notion d’h´ritage est fondamentale en POO. Elle permet de spćialiser des
e e
classes. Reprenons l’exemple de la classe Date, et supposons que nous devions main-
tenant d´finir une classe DateAnniversaire, qui associe ` une date donné le nom
e a e
et le prńom d’une personne né ` cette date. Une premi`re solution consisterait `
e e a e a
d´finir compl`tement la nouvelle classe :
e e

class DateAnniversaire{
private int mois;
private int jour;
private int annee;
private String nom;
private String prenom;
public DateAnniversaire(int j,int m,int a,String n,String p) {
nom=n; prenom=p;
}
public affecter(int m,int j,int a,String n,String p) {
nom=n; prenom=p;
}
...
System.out.println(prenom+ +nom+ est ne le +jour+/+mois+/+annee);
}
}

Cette approche va ` l’encontre de l’esprit de la POO. Dans la mesure o` l’on a
a u
d´j` ćrit une classe Date, il s’agit de la rútiliser, en la spćialisant. C’est l’idé de
eae e e e
l’h´ritage. Une DateAnniversaire est une Date avec des fonctionnalit´s suppl´mentaires.
e e e
L’h´ritage est une caract´ristique des langages orient´s objets. Une classe obte-
e e e
nue par h´ritage poss`de la totalit´ des champs et m´thodes de la classe de base
e e e e
(dont elle h´rite). Une classe B peut donc se d´finir par rapport ` une classe A dont
e e a
elle h´rite. On dit que la classe B est une sous classe de la classe de base A. Une
e

30

4.1. INTRODUCTION

sous classe doit ´videmment compl´ter (enrichir) la classe de base, on parle aussi de
e e
spćialisation. Elle d´finit donc des champs et comportements suppl´mentaires, et
e e e
peut, ´ventuellement, modifier une ou des m´thodes de la classe de base.
e e
Notre exemple de classe DateAnniversaire poss`de beaucoup de caract´ristiques
e e
de la classe Date (´videmment, c’est une date !). Elle comporte deux champs suppl´-
e e
mentaires, et les m´thodes (constructeur, m´thodes d’acc`s et de modification) doivent
e e e
ˆtre compl´tés et/ou adaptés en fonction de l’ajout de ces nouveaux champs. On
e ee e
d´finira la classe DateAnniversaire comme une sous classe de la classe Date. Cela
e
se fait en Java grˆce au mot cl´ extends.
a e
Voici l’exemple complet de la classe DateAnniversaire. Nous y reviendrons par
la suite :
class Date {
protected int mois;
protected int jour;
protected int annee;
}
public void affecter(int j, int m, int a) {
}

}

class DateAnniversaire extends Date{
private String nom;
private String prenom;
super(j,m,a);
nom=n; prenom=p;
}
public void affecter(int j,int m,int a,String n,String p) {
super.affecter(j,m,a);
nom=n; prenom=p;
}
System.out.println(prenom+ +nom+ est ne(e) le +super.jour+/+
super.mois+/+super.annee);
}
}

class TestDate{
DateAnniversaire d=new DateAnniversaire(0,0,0,,);
d.affecter(10,3,1920,Boris,Vian);
d.imprimer();
}
}


4.2. RETOUR SUR LES QUALIFICATIFS DE CLASSES ET CHAMPS

4.2 Retour sur les qualificatifs de classes et champs
Il existe trois qualificatifs (on dit aussi modifieurs) pour les classes :
– public : une seule classe ou interface peut ˆtre dćlaré public par fichier
e e e
source .java, et par convention, le fichier porte le nom de la classe dćlaré
e e
public. Une telle classe est accessible depuis l’ext´rieur (nous reverrons ces
e
notions avec les paquetages).
– final : une classe dćlaré final ne peut ˆtre d´rivé (et ne peut donc jamais
e e e e e
suivre la clause extends).
– abstract : une classe dćlaré abstract ne peut jamais ˆtre instancié. Nous
e e e e
verrons l’int´rˆt de telles classes un peu plus loin. Disons simplement pour le
ee
moment que leur int´rˆt est de fournir une esp`ce de mod`le pour les classes
ee e e
d´rivés.
e e

Pour les champs, voici les qualificatifs possibles :
– public : pour signifier que le champ est accessible partout o` est accessible la
u
classe dans laquelle il est dćlar´,
e e
– protected : pour signifier que le champ est accessible par les classes du mˆme
e
paquetage et les classes d´rivés de la classe o` il est dćlar´,
e e u e e
– package : pour signifier que le champ est accessible par les classes du mˆme e
paquetage (c’est le qualificatif par d´faut),
e
– private : pour signifier que le champ n’est accessible qu’` l’int´rieur de la
a e
classe o` il est dćlar´,
u e e
– static : pour signifier qu’il s’agit d’un champ de classe, un seul exemplaire est
cr´´,
ee
– final : pour signifier qu’il s’agit d’une constante,
– transient : que nous verrons plus tard... lorsque nous aborderons les notions
de persistance,
– volatile : que nous verrons plus tard... lorsque nous aborderons les notions
de processus (threads).

Maintenant, vous devez mieux comprendre les qualificatifs donn´s aux champs
e
de la classe Date.

4.3 Constructeur de la sous-classe
4.3.1 Invocation du constructeur
Lors de la d´finition d’une classe d´rivé, il faut s’assurer que, lors de l’instancia-
e e e
tion des objets de cette nouvelle classe, les champs propres ` cette classe mais aussi
a
les champs de la classe de base seront bien initialis´s. Souvent, les champs de la classe
e
de base sont priv´s et la classe d´rivé ne peut donc se charger de leur initialisation.
e e e


´
4.4. REDEFINITION ET SURCHARGE

Ainsi le constructeur de la classe d´rivé devra faire appel ` celui de la classe de base
e e a
pour l’initialisation de ces champs. Dans notre exemple de dates, on dira que pour
crér une DateAnniversaire, il faut d’abord crér une Date.
e e
Voici quelques points essentiels :
– Le constructeur est appel´ au moment de la crátion de l’objet (instanciation).
e e
Il initialise cet objet en fonction des param`tres fournis.
e
– Si la classe ne comporte pas de constructeur, Java en cré un de fa¸on implicite,
e c
sans param`tre. Mais attention, si la classe a au moins un constructeur avec
e
param`tre(s) et aucun sans param`tre, elle n’a alors plus de constructeur par
e e
d´faut.
e
– Si, la premi`re instruction du constructeur n’est pas un appel explicite d’un
e
constructeur de la classe de base (utilisation de super(...), voir plus loin), le
constructeur par d´faut de la classe de base est appel´.
e e
– Si la classe de base n’a pas de constructeur par d´faut (ou de constructeur sans
e
param`tre), on a une erreur de compilation (j’ai repris l’exemple des dates, et
e
enlev´ l’appel explicite au constructeur de la classe Date dans celui de la classe
e
DateAnniversaire) :
Date2.java:20: No constructor matching Date2() found in class Date2
^
1 error

4.3.2 Enchaˆ
ınement des constructeurs
Rappelons que la classe Object est la m`re de toutes les classes : toute classe
e
est d´rivé directement ou non de la classe Object. Pour tout objet instanci´, le
e e e
constructeur de sa classe est invoqu´, lequel,` son tour, invoque le constructeur de sa
e a
classe de base et ainsi de suite. Cette cascade d’appels s’arrˆte ´videmment lorsqu’on
e e
atteint le constructeur de la classe Object.

4.4 Red´finition et surcharge
e
4.4.1 Red´finition des champs
e
Les champs dćlar´s dans la classe d´rivé sont toujours des champs suppl´-
e e e e e
mentaires. Si l’on d´finit un champ ayant le mˆme nom qu’un champ de la classe
e e
de base, il existera alors deux champs de mˆme nom. Le nom de champ d´signera
e e
celui dćlar´ dans la classe d´rivé. Pour avoir acc`s ` celui de la classe de base, il
e e e e e a
faudra changer le type de la r´f´rence pointant sur l’objet, ou utiliser super. Voici
ee
un exemple :
class A {
public int i;
...
}
class B extends A {
public int i;


´
4.4. REDEFINITION ET SURCHARGE

...
public void uneMethode(){
i=0; // champ defini dans la classe B
this.i=0; // champ defini dans B
super.i=1; // champ defini dans A
((A) this).i=1; // champ defini dans A
...
}
}
class C extends B {
public int i;
...
public void uneMethode(){
i=0; // champ defini dans la classe C
this.i=0; // champ defini dans C
super.i=1; // champ defini dans B
((B) this).i=1; // champ defini dans B
((A) this).i=1; // champ defini dans A
...
}
}

Mais attention l’instruction suivante est incorrecte ! super.super.i=1 ;
De plus, souvenez-vous que comme l’utilisation du mot-cl´ this, le mot-cl´ super
e e
ne peut pas ˆtre utilis´ dans les m´thodes qualifiés de static.
e e e e

4.4.2 Red´finition des m´thodes
e e
On n’est bien sˆr pas tenu de dćlarer de nouveaux champs dans une classe
u e
d´rivé, il se peut que seuls les comportements (m´thodes) changent avec de nouvelles
e e e
m´thodes ou des m´thodes red´finies.
e e e
La red´finition d’une m´thode consiste ` fournir une impl´mentation diff´rente
e e a e e
de la m´thode de mˆme signature fournie par la classe m`re.
e e e
Exemple :

class Fruit{
public String nom;
public Fruit(String n) {
nom=n;
}
public void imprimer() {
System.out.println(je suis un(e) +nom);
}
public String getNom(){
return nom;
}
}
class Pomme extends Fruit{
public Pomme(){


Apprentissage du java

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Apprentissage du java

Ähnlich wie Apprentissage du java (20)

Mehr von KheirEddine Tolba

Mehr von KheirEddine Tolba (7)

Apprentissage du java