1. 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
2. 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’´crire un programme, il faut poser le probl`me que ce programme devra
e e
r´soudre. La formulation du probl`me influe sur l’´criture 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´coup´e. C’est
e e e e e
la programmation structur´e 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´es dans des biblioth`ques, pour que l’on puisse les r´utiliser. On retrouve ici les
e e e
notions de modules (voir plus loin), et de compilation s´par´e 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
3. 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´es 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´es qu’elles manipulent sont regroup´es 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-
4. 1.2. PROGRAMMATION MODULAIRE
Les types abstraits de donn´es (TAD) sont bas´s sur deux id´es :
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´e pour la compilation s´par´e : on regroupe dans un
e e e
fichier les parties d’un programme qui sont s´mantiquement li´es. 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´cification du type tel que vu de l’ext´rieur, elle d´finit comment utiliser
e e e
le type (donn´es et op´rations accessibles). Elle d´crit 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´e du type), elle
e e
d´crit 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´cifient
e e e
comment cr´er 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´es (champs).
e e
Eventuellement, les donn´es sont acc´d´es au travers d’op´rations tr`s simples ap-
e e e e e
pel´es fonctions d’acc`s (getters et setters) pour donner une valeur ou extraire la
e e
valeur d’une donn´e.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´n´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
Support de cours programmation Java - GBM2 - 3-
5. ´
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´e, 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´ ´crit, on a le fichier pile.h
eee
suivant pour d´crire l’interface. Notez que rien n’empˆche l’utilisateur du module
e e
pile d’acc´der directement aux donn´es (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´om´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´e 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´´crire 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´e objets permet de
e e
Support de cours programmation Java - GBM2 - 4-
6. 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´om´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´es permet de cacher les d´tails d’impl´mentation d’un ob-
e e e
jet. Ceci dit, cette vue id´ale 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´e) 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´es 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´om´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´om´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´om´triques. La sous-classe Cercle h´rite alors de la classe FormeGeometrique
e e e
et a ses propres sp´cificit´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)
Support de cours programmation Java - GBM2 - 5-
7. 1.4. JAVA, QU’EST-CE-QUE C’EST ?
£
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´n´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´aliser 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´es, 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´occupation 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´cessaire d’´crire 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´es 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
Support de cours programmation Java - GBM2 - 6-
8. 1.4. JAVA, QU’EST-CE-QUE C’EST ?
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´n`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´es dynamiquement en
e e
fonction des besoins, au cours de l’ex´cution, 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´cution 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´es `
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´canisme des lev´es d’exceptions permet une
e a e e e
bonne gestion des erreurs d’ex´cution. Le compilateur est contraignant.
e
La s´curit´ 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
Support de cours programmation Java - GBM2 - 7-
9. ´
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´cutant 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´e 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´n´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´es (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´es
e e e
). Nous choisirons de travailler avec cet ´diteur et de compiler et ex´cuter en ligne
e e
de commande.
Support de cours programmation Java - GBM2 - 8-
10. 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´e 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´claration, les caract`res entre /** ...et...*/ sont inclus dans une docu-
e e
mentation g´n´r´e 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
11. ´
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´n´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´canisme 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´els, bool´ens
e e
et caract`res) et les types composites (tableaux, classes et interfaces).
e
Support de cours programmation Java - GBM2 - 10-
12. ´
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´ens
e
Le type bool´en 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´els
e
Il n’y a que deux types de r´els 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´ennes
e
On l’a vu, les seules possibles sont true et false
Constantes caract`res
e
Elles sont constitu´es d’un caract`re ou une s´quence d’´chappement entre des
e e e e
guillemets simples :
’a’, ’b’,...
’’’, ’’, ’’
’n’ nouvelle ligne
’t’ tabulation
Constantes enti`res
e
Elles peuvent s’´crire
e
– en notation d´cimale : 123, -123
e
– en notation octale avec un z´ro en premi`re position : 0123
e e
Support de cours programmation Java - GBM2 - 11-
13. 2.2. LES VARIABLES
– en notation hexad´cimale, 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´ciser qu’une constante est de
e
type long, la faire suivre de l ou L (par exemple, 1L, 0x7FFL,...).
Constantes r´elles
e
Elles se pr´sentent sous la forme d’une partie enti`re suivie d’un point (.), suivi
e e
d’une partie d´cimale, 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´el double
e
2.0f (ou 2.0F) est un r´el float
e
Constantes chaˆ
ınes de caract`res
e
Une chaˆ de caract`res est une suite de caract`res d´limit´e 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´clar´e. La d´claration 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´claration alloue la place m´moire n´cessaire au stockage, la taille d´pendant du
e e e e
type. Java distingue diff´rentes natures de variables (pas n´cessairement 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´claration des variables locales se fait dans le bloc o` elles sont utilis´es, elles
e u e
sont alors visibles ` partir de leur d´claration jusqu’` la fin du bloc.
a e a
...
for(int i=0;i10;i++) {
...
// i est visible dans ce bloc
}
...
Support de cours programmation Java - GBM2 - 12-
14. ´
2.3. EXPRESSIONS ET OPERATEURS
Il n’y a pas vraiment de notion de variable globale en Java. Toute d´claration de
e
variable se trouve n´cessairement dans la d´claration d’un classe. Seules les variables
e e
qualifi´es 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 ´crit en C. Elles
a e
sont compos´es 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´e, 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´es avant d’effectuer l’op´ration. Java garantit ´galement que les op´randes sont
e e e e e
´valu´es 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
Support de cours programmation Java - GBM2 - 13-
15. ´
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´cision :
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´cise 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´ation 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´n´r´es par l’invocation d’une m´thode
e ee e
des exceptions g´n´r´es par les constructeurs
e ee
bien d’autres !...
Tab. 2.1 – Exemples de lev´es 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
Support de cours programmation Java - GBM2 - 14-
16. ˆ
2.4. STRUCTURES DE CONTROLE
de d´calage 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´cr´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´nation
e
! D/G bool´en
e non bool´en
e
∧ | G/D bool´en
e ET, OU exclusif, OU
(les 2 op´randes sont ´valu´es)
e e e
|| G/D bool´ens
e ET, OU conditionnels (l’op´rande
e
de droite n’est pas n´cessairement ´valu´e)
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´clarations de classes dans lesquelles fi-
e e
gurent des m´thodes. Ces derni`res sont construites ` l’aide d’instructions combin´es
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´es ou blocs d’instructions sont des suites d’instructions simples ou compos´es
e e
d´limit´es 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´e 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´e de 1 et a pour effet de bord le stockage de cette valeur.
e e e
C’est similaire pour le d´cr´ment.
e e
Support de cours programmation Java - GBM2 - 15-
17. ˆ
2.4. STRUCTURES DE CONTROLE
op´rateurs postfixes
e [] . (params) expr++ expr–
op´rateurs unaires
e ++expr –expr +expr -expr ∼ !
cr´ation 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´croissant 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´cution 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 :
Support de cours programmation Java - GBM2 - 16-
18. ˆ
2.4. STRUCTURES DE CONTROLE
instructionDefaut
}
Attention, si la valeur de expression vaut csteI, instructionI sera ex´cut´e
e e
ainsi que toutes les suivantes (instructionI+1...instructionDefaut) sauf si une
instruction break a ´t´ rencontr´e. 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’:
System.out.println(c+est un multiple de 2n);
break;
case ’9’:
System.out.println(c+est un multiple de 3n);
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´cute l’instruction tant
o e e
que cette condition reste vraie.
while (condition)
instruction
Exemple :
Support de cours programmation Java - GBM2 - 17-
19. ˆ
2.4. STRUCTURES DE CONTROLE
int i=10;
while (i=0) {
System.out.println(i);
i=i-1;
}
L’instruction do...while est une variante de la pr´c´dente. Une it´ration est
e e e
toujours ex´cut´e. 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´e 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 e
label : instruction
L’instruction break d´j` vue avec le switch est utilis´e 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.
Support de cours programmation Java - GBM2 - 18-
20. 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´conseill´, 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´e ! 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´e renvoie
e e
a
` la fonction appelante. Mais attention, il est d´conseill´ de placer une instruction
e e
return dans le corps d’une boucle, cela signifie que vous n’avez probablement pas
bien ´crit 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´e de l’ex´cution 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´clar´e static et public pour pouvoir ˆtre invoqu´e 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.
Support de cours programmation Java - GBM2 - 19-
21. 2.5. STRUCTURE D’UN PROGRAMME AUTONOME JAVA
Enfin, pour ex´cuter 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 :
e
java Bonjour
Support de cours programmation Java - GBM2 - 20-
22. Chapitre 3
Classes et Objets
En C on utilise des structures pour cr´r des TAD (Types Abstraits de Donn´es),
e e
ou structures de donn´es 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´es 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 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´cialisant) 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´actions `
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´es, 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´crit la partie priv´e (structure de
e e
donn´es 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´n´rateur d’objets, on peut ainsi cr´er un
e e e e e
ensemble d’objets rentrant dans ce moule.
3.1 D´claration des classes
e
Basiquement, une classe d´finit :
e
21
23. ´
3.1. DECLARATION DES CLASSES
– les structures de donn´es associ´es aux objet de la classe, les variables d´signant
e e e
ces donn´es sont appel´es 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´es (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´es et m´thodes d´clar´es public sont accessibles par toutes les classes. In-
e e e e
versement, les donn´es et m´thodes d´clar´es 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´clarer une structure de donn´es Date constitu´e
e e e
de trois entiers codant le jour, le mois et l’ann´e :
e
class Date{
private int mois;
private int jour;
private int annee;
...
}
Les donn´es mois, jour et ann´e ont ´t´ d´clar´es priv´es. 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);
}
}
Support de cours programmation Java - GBM2 - 22-
24. ´
3.1. DECLARATION DES CLASSES
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´clar´e 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´es m´thodes d’instances, elles sont ´voqu´es 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´es priv´es.
e e
3.1.3 Cr´ation d’objets
e
Une fois la classe d´clar´e, pour pouvoir utiliser un objet de cette classe, il faut
e e
d´finir une instance de cette classe. La d´claration 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´claration 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´able. Le constructeur est une m´thode sp´cifique qui est
e e e e
automatiquement appel´e lors de la cr´ation 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
Support de cours programmation Java - GBM2 - 23-
25. ´
3.1. DECLARATION DES CLASSES
class Date {
...
public Date(int j, int m, int a) {
jour=j; mois=m; annee=a;}
...
}
Maintenant, pour cr´er un objet de type Date il faudra fournir imp´rativement
e e
le jour, le mois et l’ann´e. On peut contourner ce probl`me en fournissant plusieurs
e e
constructeurs :
class Date {
...
public Date(int j, int m, int a) {
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´n´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´cup´ration de m´moire automatique. Par
e e e e
d´faut, ce syst`me tourne en arri`re-plan pendant l’ex´cution 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´cifique
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´clar´e de la fa¸on suivante :
e e c
protected void finalize() throws Throwable {
super.finalize();
...
}
Ce code s’´claircira plus tard, avec les notions d’h´ritage et d’exceptions.
e e
Support de cours programmation Java - GBM2 - 24-
26. ´
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´e
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){
mois=m; jour=j; annee=a;
nbDate++;
}
public int quelJour(){return jour;}
public int quelMois(){return mois;}
public int quelleAnnee(){return annee;}
public void imprimer(){
System.out.println(jour+/+mois+/+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
Support de cours programmation Java - GBM2 - 25-
27. ´
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´ation) 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´e. On peut par exemple r´´crire
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´e une liste chaˆ ee de tous les objets de type Date qui ont ´t´ instanci´s :
e ın´ ee e
class Date{
Support de cours programmation Java - GBM2 - 26-
28. ´ ´
3.3. DEFINITION DE METHODES
private int mois;
private int jour;
private int annee;
private Date suivant;
public static Date listeDates=null;
public Date(int j, int m, int a){
jour=j; mois=m; annee=a;
suivant=listeDates;
listeDates=this;
}
public void imprimer(){
System.out.println(jour+/+mois+/+annee);
}
}
class Test {
public static void main(String[] arg){
Date noel=new Date(25,12,2000);
Date aujourdhui=new Date(25,9,2000);
for (Date d=Date.listeDates; d!=null; d=d.suivant) d.imprimer();
}
}
3.2.3 Champs final
Un champ peut ˆtre d´clar´ 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´es 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
Support de cours programmation Java - GBM2 - 27-
29. ´ ´
3.3. DEFINITION DE METHODES
On appelle signature d’une m´thode, la donn´e 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´es 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´clar´es.
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´es de static sont celles qui n’ont pas besoin d’une instance
e e
pour ˆtre invoqu´es.
e e
Comme toute m´thode, une m´thode de classe est membre d’une classe. Elle est
e e
invoqu´e 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´e appartient ` la classe Math.
e e a
Pour l’invoquer on ´crit : 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;
public Date(int j, int m, int a){
jour=j; mois=m; annee=a;
suivant=listeDates;
listeDates=this;
}
...
public void imprimer(){
System.out.println(jour+/+mois+/+annee);
}
public static void listerDate(){
Support de cours programmation Java - GBM2 - 28-
30. ´ ´
3.3. DEFINITION DE METHODES
for (Date d=Date.listeDates; d!=null; d=d.suivant)
d.imprimer();*
}
}
class Test {
public static void main(String[] arg){
Date noel=new Date(25,12,2000);
Date aujourdhui=new Date(25,9,2000);
Date.listerDate();
}
}
Support de cours programmation Java - GBM2 - 29-
31. Chapitre 4
H´ritage
e
4.1 Introduction
La notion d’h´ritage est fondamentale en POO. Elle permet de sp´cialiser 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´e le nom
e a e
et le pr´nom d’une personne n´e ` 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) {
jour=j; mois=m; annee=a;
nom=n; prenom=p;
}
public affecter(int m,int j,int a,String n,String p) {
jour=j; mois=m; annee=a;
nom=n; prenom=p;
}
...
public void imprimer(){
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` ´crit une classe Date, il s’agit de la r´utiliser, en la sp´cialisant. C’est l’id´e 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
32. 4.1. INTRODUCTION
sous classe doit ´videmment compl´ter (enrichir) la classe de base, on parle aussi de
e e
sp´cialisation. 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´es et/ou adapt´es 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 Date(int j, int m, int a) {
jour=j; mois=m; annee=a;
}
public void affecter(int j, int m, int a) {
mois=m; jour=j; annee=a;
}
}
class DateAnniversaire extends Date{
private String nom;
private String prenom;
public DateAnniversaire(int j,int m,int a,String n,String p) {
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;
}
public void imprimer(){
System.out.println(prenom+ +nom+ est ne(e) le +super.jour+/+
super.mois+/+super.annee);
}
}
class TestDate{
public static void main(String[] arg){
DateAnniversaire d=new DateAnniversaire(0,0,0,,);
d.affecter(10,3,1920,Boris,Vian);
d.imprimer();
}
}
Support de cours programmation Java - GBM2 - 31-
33. 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´clar´e public par fichier
e e e
source .java, et par convention, le fichier porte le nom de la classe d´clar´e
e e
public. Une telle classe est accessible depuis l’ext´rieur (nous reverrons ces
e
notions avec les paquetages).
– final : une classe d´clar´e final ne peut ˆtre d´riv´e (et ne peut donc jamais
e e e e e
suivre la clause extends).
– abstract : une classe d´clar´e abstract ne peut jamais ˆtre instanci´e. 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´es.
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´clar´,
e e
– protected : pour signifier que le champ est accessible par les classes du mˆme
e
paquetage et les classes d´riv´es de la classe o` il est d´clar´,
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´clar´,
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´e, 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´e ne peut donc se charger de leur initialisation.
e e e
Support de cours programmation Java - GBM2 - 32-
34. ´
4.4. REDEFINITION ET SURCHARGE
Ainsi le constructeur de la classe d´riv´e 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´er une DateAnniversaire, il faut d’abord cr´er une Date.
e e
Voici quelques points essentiels :
– Le constructeur est appel´ au moment de la cr´ation 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´e 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
public DateAnniversaire(int j,int m,int a,String n,String p) {
^
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´e 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´clar´s dans la classe d´riv´e 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´clar´ dans la classe d´riv´e. 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;
Support de cours programmation Java - GBM2 - 33-
35. ´
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´es 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´clarer de nouveaux champs dans une classe
u e
d´riv´e, 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(){
Support de cours programmation Java - GBM2 - 34-