Rsum du cours de Programmation Java

Carole Frindel et Cline Robardet

TABLE DES MATIRES

1 Notions lmentaires 1
1.1 Quest-ce quun programme ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Les conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 Les oprateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Les structures de contrle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4.1 Bloc dinstructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4.2 Structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4.3 Structures itratives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Les mthodes 9
2.1 Les mthodes prdfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Les mthodes propres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Les mthodes rcursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 Un exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3 Les types non primitifs 12

3.1 Gnralits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2.1 Tableaux 1 dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2.2 Tableaux n dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3 Mthodes paramtres de type non-primitif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3.1 Instanciation des variables de type non-primitif dans une mthode . . . . . . . . . . . . . 14
3.3.2 Modification des valeurs dune variable de type non-primitif dans une mthode . . . . . 14
3.4 Les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.4.1 Lobjet prdfini String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.4.2 Les objets propres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4 Glossaire 19

Ce support de cours couvre lintgralit du programme de premire anne et vous permettra de com-
prendre les concepts lis la programmation en Java. La section 3.4.2 introduit quelques concepts de la
programmation objet, qui sont vus en deuxime anne du premier cycle.

1 NOTIONS LMENTAIRES
1.1 QUEST-CE QU UN PROGRAMME ?
Lobjectif de la programmation est de crer des logiciels ou programmes. Ceux-ci sont constitus dun en-
semble de traitements qui permettent de transformer des donnes numriques (les entres) en dautres don-
nes numriques (les sorties). Les donnes de sortie peuvent tre affiches sous une forme graphique (avec

1
des fentres comme le fond les programmes tels que Word et Excel) ou plus simplement affiches dans une
console?1 sous forme de texte.
Que se passe-t-il pour lordinateur lorsquon excute un programme ? Il va lire le fichier excutable du
programme comme une suite de 0 et de 1 (codage binaire) et excuter lune aprs lautre les instructions
ainsi codes. Cette suite de 0 et de 1 est appele langage machine et est directement excutable par le micro-
processeur de lordinateur. Or il est trs difficile pour un humain de programmer directement en binaire,
cest pourquoi on utilise un langage de programmation crit en langage textuel dans un fichier source (fichier
.java). Le fichier source est ensuite compil? en langage binaire (fichier .class) puis excut pour raliser les
traitements :
Compilation Excution

$ javac Bonjour.java $ java Bonjour

1.2 LES VARIABLES

Les variables constituent laspect le plus important de la programmation, puisquelles permettent de stocker
dans un emplacement mmoire les donnes et de les transformer en utilisant des oprateurs? . On peut se
reprsenter une variable comme une tiquette associe une unique bote dans laquelle est range une valeur
dun certain type (entier ou rel, par exemple) :

Avant de pouvoir utiliser une variable, il est ncessaire de la dclarer? , cest--dire dassocier la variable un
emplacement de la mmoire et de spcifier son type. Cest en fonction du type de la variable que la taille
de lemplacement mmoire (en octet, soit 8 bits) et le codage binaire de la valeur seront dtermins. La
dclaration se fait par une instruction de la forme :
typeVariable nomVariable;

La variable nomVariable est de type typeVariable. Il lui est associ un emplacement mmoire qui con-
tient une valeur quil faut initialiser? . Cela se fait en utilisant loprateur daffectation = :
nomVariable = uneValeur;

Laffectation? crit dans lemplacement mmoire associ nomVariable la valeur uneValeur. On dit alors
que nomVariable prend la valeur uneValeur.

uneValeur doit tre compatible avec le type de nomVariable. Par exemple si typeVariable est un
entier, uneValeur doit tre une valeur entire. On peut faire ici le parallle entre le type dune variable
et lunit de mesure dune grandeur physique qui spcifie la nature de la grandeur manipule.

On peut galement faire la dclaration et linitialisation dune variable en une seule instruction :

1
Le symbole ? indique que le mot est dfini dans la section Glossaire.

Programmation Java page 2 of 20

 typeVariable nomVariable = uneValeur;

Dans la suite, nous allons dtailler les quatre types dits primitifs? , qui sont directement accessibles en
mmoire (contrairement aux types non primitifs que nous verrons dans la section 3), cest--dire que la valeur
affecte la variable est stocke dans lemplacement mmoire associe celle-ci. Pour chacun de ces types,
nous verrons galement les oprateurs que lon peut appliquer sur des variables de ce type pour transformer
leur valeur.
1.2.1 LES TYPES PRIMITIFS
On distingue 4 catgories de types primitifs (entier, rel, boolens, caractres). Lintervalle de valeurs reprsenta-
bles pour chacun des types peut varier en fonction de lespace mmoire quils occupent.
LES ENTIERS En Java, tous les types permettant de reprsenter des entiers sont signs. Ainsi, sur n bits, on
peut coder les entiers de (2n1 ) 2n1 1. Les valeurs ngatives sont encodes en complment 2. Pour
un rappel sur cet encodage, nous vous renvoyons au cours de numration disponible sur la page du CIPC.
Les diffrents types dentiers sont les suivants :

Nom Taille Intervalle reprsentable

byte 1 octet [128 . . . 127] ou [27 . . . 27 1]
short 2 octets [32768 . . . 32767] [215 . . . 215 1]
int 4 octets [231 . . . 231 1]
long 8 octets [263 . . . 263 1]

On peut appliquer des oprateurs arithmtiques (+,-,*,/) deux variables ou deux expressions de type entier
(la composition tant possible comme en mathmatiques). Le rsultat de cette opration est galement du
type entier (ce qui permet la composition).

Lorsque les deux oprandes sont de type entier, loprateur / calcule la division entire et loprateur %
calcule le reste de cette division.

Par exemple2 :

int valA = 7;
int valB = 2;
int valC = valA / valB; // valC contient la valeur 3
int valD = valA % valB; // valD contient la valeur 1

LES RELS La description du codage des rels est dcrite dans le cours de numration sur la page du CIPC. En
Java il existe deux types de reprsentation pour les nombres rels : simple et double prcision (respectivement
les types float et double).

Nom Taille Intervalle reprsentable

float 4 octets [3.4 . 1038 , , 1.4 . 1045 , 0, 1.4 . 1045 , , 3.4 . 1038 ]
double 8 octets [1.8 . 10308 , , 4.9 . 10324 , 0, 4.9 . 10324 , , 1.8 . 10308 ]

Lorsquau moins une des oprandes est de type rel, loprateur / calcule la division relle.

double reelA = 7;
double reelB = 2;
double division = reelA / reelB; //La variable division contient la valeur 3.5
2
// indique que la suite de la ligne est un commentaire.

Programmation Java page 3 of 20

LES BOOLENS Un type de variable trs utile en informatique est le type boolen, qui prend deux valeurs
VRAI ou FAUX.

Nom Taille Intervalle reprsentable

boolean 1 octet [true,false]

On peut appliquer des oprateurs logiques (et, ou, non) des variables ou des expressions boolennes. Le
rsultat de cette opration est galement du type boolen.

&& dsigne loprateur et logique

|| dsigne loprateur ou logique

! dsigne loprateur non logique (qui transforme une valeur true en valeur false et inversement)

a b a et b a b a ou b
Faux Faux Faux Faux Faux Faux
Faux Vrai Faux Faux Vrai Vrai
Vrai Faux Faux Vrai Faux Vrai
Vrai Vrai Vrai Vrai Vrai Vrai

boolean boolA = TRUE;

boolean boolB = FALSE;
boolean nonA = !boolA; // nonA vaut FALSE
boolean AetB = boolA && boolB; // AetB vaut FALSE

LES CARACTRES Le type caractre peut correspondre nimporte quel symbole du clavier (lettre en majus-
cule ou minuscule, chiffre, ponctuation et symboles).

Nom Taille Intervalle reprsentable

char 2 octets [a...z,A...Z,0...9,:,;.?!...]

Pour distinguer la valeur correspondant au caractre a de la variable dnomme a, on utilise lapostrophe

pour la premire.

char caractere = a; // La variable caractere contient la valeur a

int a = 3; // La variable a contient la valeur 3

Comme toute donne numrique, un caractre est encod sous forme dune suite de 0 et de 1 que lon peut
interprter comme un entier non sign. Dans certains contextes, il est utile de manipuler directement ce code.
On convertit alors la variable de type char en une variable de type int comme expliqu ci-dessous.
1.2.2 LES CONVERSIONS
La conversion (galement appele transtypage) dun type primitif en un autre se fait de la manire suiv-
ante :
typeVariableA variableA = (typeVariableA) valeurB

Si variableA et valeurB ne sont pas du mme type, cette instruction affecte variableA la conversion
de la valeur de valeurB dans le type typeVariableA :

Entier vers Rel la mme valeur code en rel

Rel vers Entier la partie entire du rel
Entier vers caractre le caractre dont le code est lentier
Caractre vers Entier le code numrique correspondant au caractre

Programmation Java page 4 of 20

 int i;
double x = 2;
i = (int) (x * 42.3); // i vaut 84

1.2.3 LES OPRATEURS DE COMPARAISON

Les oprateurs de comparaison permettent de comparer deux variables dun mme type primitif (entier, flot-
tant, boolen et caractre) et renvoient une valeur boolenne :
== comparaison dgalit
!= diffrence
< infrieur strict
<= infrieur ou gal (scrit de la mme manire dont on le prononce)
> suprieur strict
>= suprieur ou gal (scrit de la mme manire dont on le prononce)

Attention, loprateur = correspond laffectation alors que loprateur == correspond la comparaison

dgalit, cest--dire au signe = utilis en mathmatiques !!

Les expressions composes doivent tre compltement parenthses :

double a = 8;
boolean estDansIntervalle = ((a >= 0) && (a <= 10));
// vaut true ssi a appartient [0,10]

1.3 LE PROGRAMME
De manire gnrale, la structure dun programme simple est toujours la mme. Cette structure de base doit
tre apprise par cur, car elle constitue le squelette du programme. Il est conseill, lors de la cration dun
programme, de commencer par crire cette structure. En effet, une fois cette structure cre, le programme
est fonctionnel : il peut tre compil? et excut? . Bien entendu ce stade, le programme ne fait strictement
rien puisquil ny a aucune instruction, seulement des commentaires.

public class Exemple{ //Exemple est le nom du programme

// crit dans le fichier Exemple.java
public static void main (String[] args){
//bloc dinstructions du programme
//excutes lors du lancement du programme
}
}

Dclare et initialise deux variables celsius et fahrenheit, fahrenheit tant calcule partir de celsius,
pour ensuite les afficher lcran.

public class ConversionCelsiusVersFahrenheit{

public static void main (String[] args){
double celsius = 12.0;
double fahrenheit = ((9.0/5.0) * celsius) + 32.0;
System.out.print(celsius);
System.out.print(" degrs Celsius convertit en Fahrenheit vaut ");
System.out.println(fahrenheit);
}
}

Linstruction System.out.print permet dafficher la valeur dune variable de type primitif ou un texte
dlimit par des guillemets.

Programmation Java page 5 of 20

1.4 LES STRUCTURES DE CONTRLE
Le principe dun programme est de modifier le contenu des variables laide des instructions lmentaires
que nous venons de voir (affectation et oprateurs). Or, nous pouvons vouloir que ces instructions ne soient
ralises que dans certains cas, ou bien nous pouvons vouloir rpter lexcution de ces instructions. Ce sont
les structures de contrle qui permettent de spcifier si lexcution dun traitement est conditionne ou bien
si elle se fait de manire rpte.
1.4.1 BLOC DINSTRUCTIONS
Les accolades {} permettent de dlimiter un bloc dinstructions, cest--dire un ensemble dinstructions qui
vont tre excutes les unes la suite des autres. Un bloc dinstructions peut, par exemple, tre excut que
lorsquune condition est vrifie ou bien il peut tre excut plusieurs fois de suite. Ce sont les structures de
contrle conditionnelles et itratives qui permettent dexprimer cela. Les variables dclares? dans un bloc
sont accessibles lintrieur de ce bloc uniquement.

Deux variables de mme nom peuvent tre dclares dans deux blocs distincts. Ce sont deux variables
diffrentes associes deux emplacements mmoires diffrents. Ainsi, leurs valeurs sont gnralement
diffrentes. Confondre lune avec lautre peut tre une source derreur de programmation.

1.4.2 STRUCTURES CONDITIONNELLES

Les structures de contrle conditionnelles permettent de spcifier quelles conditions un bloc dinstructions
va tre excut. Cette condition est exprime par une expression logique.
LA STRUCTURE ALTERNATIVE Le premier type de conditionnelle scrit comme suit :

if (condition) {// quivalent (condition == true)

// bloc dinstructions excutes si condition est vraie
} else {
// bloc dinstructions excutes si condition est fausse
}

Cette structure de contrle exprime une alternative. Or, il est possible de vouloir quun bloc soit excut sous
une certaine condition et que sinon, aucune instruction ne soit excute. Dans ce cas, la clause else et son
bloc sont supprims. Les parenthses autour de condition, qui est variable ou une expression valeur
boolenne, sont obligatoires.

Affiche un message si la temprature est suprieure 50.

public class QuelleUnite{

public static void main (String[] args){
int temperature = 36;
if(temperature > 50) {
System.out.println("La temprature est probablement en Fahrenheit");
}
}
}

LA STRUCTURE CHOIX MULTIPLES Le second type de conditionnelle permet de faire plusieurs tests de valeurs
sur le contenu dune mme variable. Sa syntaxe est la suivante :

switch (variable) {
case valeur1 :
Liste dinstructions // excutes si (variable == valeur1)
break;
case valeur2 :
Liste dinstructions // excutes si (variable == valeur2)

Programmation Java page 6 of 20

 break;
...
case valeurN :
Liste dinstructions // excutes si (variable == valeurN)
break;

default:
Liste dinstructions // excutes sinon
}
Le mot cl default prcde la liste dinstructions qui sont excutes lorsque variable a une valeur dif-
frentes de valeur1,..,valeurN. Le mot cl break indique que la liste dinstructions est termine.
1.4.3 STRUCTURES ITRATIVES
Il existe 3 formes de structure itrative, chacune a un cadre dutilisation bien spcifique que nous allons voir.
LITRATION RPTE n FOIS La premire forme itrative est la boucle for. Elle permet de rpter un bloc
dinstructions un nombre de fois fix. Dans sa syntaxe, il faut dclarer et initialiser la variable qui sert de
compteur de tours de boucle, indiquer la condition sur le compteur pour laquelle la boucle sarrte et enfin
donner linstruction qui incrmente? ou dcrmente? le compteur :

for (int compteur = 0 ; compteur < n ; compteur = compteur + 1) {

// bloc instructions rptes n fois
}
ou
for (int compteur = n ; compteur > 0 ; compteur = compteur - 1) {
// bloc instructions rptes n fois
}

Affiche la conversion en Fahrenheit des degrs Celsius de 0 39.

public class ConversionCelsiusVersFahrenheit{

public static void main (String[] args){
for(int celsius = 0; celsius < 40; celsius = celsius + 1) {
double fahrenheit = ((9.0/5.0) * celsius) + 32.0;
System.out.print(celsius);
System.out.print(" degres Celsius convertit en Fahrenheit vaut ");
System.out.println(fahrenheit);
}
}
}

La boucle for sutilise lorsque lon connat a priori le nombre de rptitions effectuer.

LITRATION RPTE TANT QUUNE CONDITION EST VRAIE La seconde forme ditrative est la boucle while.
Elle excute le bloc dinstructions tant que la condition est vraie. Le bloc peut ne jamais tre excut. La
syntaxe est la suivante :

while (condition) { // quivalent (condition == true)

// bloc dinstructions rptes tant que condition est vraie.
// condition doit tre modifie dans ce bloc
}

Cette structure excute le bloc dinstructions tant que (while en anglais) la condition est ralise.

Programmation Java page 7 of 20

 Il est important de toujours sassurer que la condition deviendra fausse lors dune itration de la structure
itrative. Dans le cas contraire, lexcution du programme ne sarrtera jamais.

Affiche la conversion en Fahrenheit des degrs Celsius tant que la conversion est infrieur 100.

public class ConversionCelsiusVersFahrenheit{

public static void main (String[] args){
int celsius = 0;
double fahrenheit = ((9.0/5.0) * celsius) + 32.0;
while(fahrenheit < 100) {
System.out.print(celsius);
System.out.print(" degres Celsius convertit en Fahrenheit vaut ");
System.out.println(fahrenheit);
celsius = celsius + 1;
fahrenheit = ((9.0/5.0) * celsius) + 32.0;
}
}
}

La boucle while sutilise lorsque le nombre ditrations nest pas connu a priori mais peut sexprimer au
moyen dune expression valeur boolenne qui devient fausse lorsque la rptition doit sarrter.

LITRATION EXCUTE AU MOINS UNE FOIS La troisime forme ditrative est la boucle do while. Cest
une variante de la boucle while, o la condition darrt est teste aprs que les instructions ont t ex-
cutes :
do {
// bloc dinstructions excutes
// condition doit tre modifie dans ce bloc
} while (condition); // si condition est vraie,
// le bloc est excut nouveau

Ne pas oublier le ; aprs la condition darrt. Le bloc dinstructions est excut au moins une fois.

Affiche la conversion en Fahrenheit des degrs Celsius jusqu ce que le degr Fahrenheit soit suprieur
ou gale 100.

public class ConversionCelsiusVersFahrenheit{

public static void main (String[] args){
double fahrenheit;
int celsius = 0;
do {
fahrenheit = ((9.0/5.0) * celsius) + 32.0;
System.out.print(celsius);
System.out.print(" degres Celsius convertit en Fahrenheit vaut ");
System.out.println(fahrenheit);
celsius = celsius + 1;
} while (fahrenheit < 100);
}
}

Programmation Java page 8 of 20

2 LES MTHODES
Une mthode est un bloc dinstructions pouvant tre excutes par un simple appel? de la mthode dans le bloc
du programme principal (mthode main) ou dans une autre mthode. Les mthodes permettent dexcuter
dans plusieurs parties du programme un mme bloc dinstructions. On est amen crer une mthode dans
deux cas de figure :

Pour regrouper un ensemble dinstructions qui participent la ralisation dune mme tche. Cela
permet de rendre le programme plus lisible et comprhensible par une autre personne (ou vous-mme
lors du TP suivant) et de faciliter la mise au point du programme (correction et tests3 ). A ce bloc
dinstructions est associ un nom, choisi en rapport avec le traitement ralis par la mthode.

Pour regrouper un ensemble dinstructions qui sont rptes diffrents endroits du programme (con-
trairement aux formes itratives qui rptent le bloc dinstructions de manire conscutive).

Le rle dune mthode est de traiter des donnes. Cela signifie quen gnral, la mthode effectue un traite-
ment partir des donnes qui entrent, et renvoie un rsultat.
2.1 LES MTHODES PRDFINIES
En Java, il existe de nombreuses mthodes prdfinies. La plus connue est sans doute la mthode suivante
qui permet dafficher une chane de caractres lcran :

System.out.println("la chane de caractres afficher");

Dautres exemples de mthodes que vous pouvez utiliser sont celles de la librairie Math : sqrt, cos, sin,
abs, etc.. Lorsquon appelle une mthode, on utilise son nom suivi de la liste de ses paramtres effectifs
(spars par une virgule) entre parenthses :

nomMethode(parametre_1,... , parametre_n);

Si cette mthode renvoie un rsultat, il faut alors affecter ce rsultat une variable de type compatible pour
pouvoir ensuite utiliser ce rsultat :

double racine = Math.sqrt(5.2);

2.2 LES MTHODES PROPRES

DCLARATION DUNE MTHODE La dfinition dune mthode sappelle dclaration? . La dclaration dune
mthode se fait selon la syntaxe suivante :

static TypeRetour nomMethode(Type1 param1,..., TypeN paramN) {

//bloc dinstructions
return valeurRetournee;
}

Le fait que lon doive prcder la dclaration dune mthode par le mot cl static est expliqu page 15.
TypeRetour est le type de valeurRetournee, la valeur renvoye par la mthode. Si la mthode ne renvoie
aucune valeur, le mot-cl void est utilis la place du type de la valeur retourne.

Pour une raison inconnue des enseignants, il y a souvent confusion entre le fait de retourner une valeur et
le fait de lafficher.

Les paramtres correspondent aux donnes dentre de la mthode. Au niveau de la dclaration, les
paramtres sont dits formels : ce sont des variables qui reprsentent chaque donne dentre. On peut
faire ici lanalogie avec la variable x utilise en mathmatique lorsque lon dfinit une fonction f (x). Les
paramtres sont facultatifs, mais sil ny a pas de paramtres, les parenthses doivent rester prsentes.
3
Commenter la ligne dappel de la fonction commente tout le bloc dinstructions de la mthode cet endroit du programme.

Programmation Java page 9 of 20

APPEL DUNE MTHODE Cest au moment de lappel de la mthode que les paramtres formels sont initialiss,
cest--dire quune valeur leur est affecte. Les paramtres effectifs? de lappel, ceux passs en argument de
la mthode au moment de lappel, sont affects aux paramtres formels de la mthode (ceux de la dfinition
de la mthode) par position : la valeur du premier paramtre effectif est affecte au premier paramtre formel,
et ainsi de suite. Les paramtres effectifs peuvent tre des valeurs ou des variables.

static int addition(int x, int y) {//x et y sont les paramtres formels

return x + y;
}
public static void main (String[] args) {
int a = 7;
int somme = addition(a,3);//a et 3 sont les paramtres effectifs de lappel
//x prend la valeur de a et y prend la valeur 3
}

En Java, le passage des paramtres se fait par valeur, cest--dire que la valeur du paramtre effectif est
affecte au paramtre formel. Ainsi, si la valeur du paramtre formel est modifie dans le bloc de la
mthode, cette modification est locale la mthode mais nest pas repercute dans le contexte appelant.

Rien ne vaut un petit exemple ;-)

static int addition(int entierA, int entierB) {

entierA = entierA + 1; //entierA est modifi
return entierA + entierB;
}
public static void main (String[] args) {
int a = 7;
int b = 3;
int somme = addition(a,b); // la valeur de a est affecte entierA
// a vaut toujours 7 aprs lappel de la mthode addition
}

2.3 LES MTHODES RCURSIVES

Nous avons prcdemment prcis quil tait possible quune mthode appelle dans son bloc une autre mth-
ode. Il est galement possible quelle sappelle elle-mme. A priori, lintrt peut paratre limit, mais la
rcursivit permet deffectuer certains calculs mathmatiques, en particulier avec les suites dfinies par rcur-
rence. Par exemple, on peut calculer la factorielle dun nombre entier en utilisant la rcursivit. Pour cela,
on peut procder de la manire suivante, par exemple si lon souhaite calculer la factorielle de 4 :
4! = 4 3!
3! = 3 2!
2! = 2 1!
1! = 0!
0! = 1
Dans ce calcul, on constate une rcurrence : pour calculer 4!, il suffit de calculer 3!, puis 2!, et ainsi de
suite, jusqu un cas directement rsolu (sans expression rcursive, le cas de base). Nous pouvons alors
crer une mthode calculeFactorielle ayant comme paramtre un entier n, et renvoyant lentier n!.
On voit quil suffit que la fonction sappelle elle-mme suivant ce mme principe pour calculer facilement la
factorielle de nimporte quel nombre entier. Cependant, arriv au calcul de 0!, il est ncessaire que la fonction
renvoie directement la valeur 1, sans faire dappel rcursif. En dautres mots, il ne faut pas que lappel de
calculeFactorielle(0) provoque lappel de calculeFactorielle(-1). Il renvoie directement 1, afin
de ne pas provoquer une infinit dappels :

Programmation Java page 10 of 20

 public class Factorielle {
static int calculeFactorielle(int n) {
if(n > 0) { // cas gnral
return n * calculeFactorielle (n-1);
}

else { //cas de base ou darrt

return 1;
}
}
public static void main (String[] args) {
int valeur = 4;
System.out.println(calculeFactorielle(valeur)); // 5 appels en tout
}
}

2.4 UN EXEMPLE
Lexemple suivant prsente un programme avec deux mthodes : CelsiusVersFahrenheit convertit valeurAConvertir,
une valeur relle reprsentant une temprature en degr Celsius, en une temprature en degr Fahrenheit. La
valeur en Fahrenheit est retourne par la mthode. CelsiusVersKelvin convertit valeurAConvertir,
une valeur relle reprsentant une temprature en degr Celsius, en une temprature en degr Kelvin. La
temprature en Kelvin est affiche et aucune valeur nest retourne par la mthode.
Observez la diffrence entre les appels des deux mthodes dans le main : la valeur retourne par CelsiusVersFahrenheit
est affecte la variable temperature, puis elle est affiche. La mthode CelsiusVersKelvin est directe-
ment appele, sans affectation de sa valeur de retour, puisque celle-ci nen na pas (mot cl void dans la
dclaration).
Le programme considre les tempratures entires, en degr Celsius, de 0 39 inclus. Une fois sur deux,
sa conversion en degr Fahrenheit est affiche, lautre fois cest sa conversion en degr Kelvin qui est affiche.
Notez le changement de valeur de la variable calculeFahrenheit chaque tour de boucle.

public class Conversion {

static double CelsiusVersFahrenheit(double valeurAConvertir) {
double Fahrenheit = ((9.0/5.0) * valeurAConvertir) + 32.0;
return Fahrenheit;
}
static void CelsiusVersKelvin(double valeurAConvertir) {
double Kelvin = 273.15 + valeurAConvertir;
System.out.println(Kelvin);
}
public static void main (String[] args) {
boolean calculeFahrenheit = true;
for(int celsius = 0; celsius < 40; celsius = celsius + 1) {
if(calculeFahrenheit == true) {
double temperature = CelsiusVersFahrenheit(celsius);
System.out.println(temperature);
} else {
CelsiusVersKelvin(celsius);
}
calculeFahrenheit = !calculeFahrenheit;
}
}
}

Programmation Java page 11 of 20

3 LES TYPES NON PRIMITIFS
3.1 GNRALITS
Nous avons vu (section 1.2) quune variable permet de stocker dans un emplacement mmoire une donne
dun certain type, et que cette donne peut tre transforme en utilisant des oprateurs spcifiques de son
type. Or, au lieu de manipuler une seule valeur, il est parfois beaucoup plus commode quune variable soit
associe une collection de valeurs. Cest ce que permettent les types non primitifs, appels objet en Java.

Supposons que lon souhaite raliser un programme permettant dcrire des courriers de manire automa-
tique aux abonns dune bibliothque. Pour chaque abonn, nous connaissons son nom, prnom, le nombre
de volumes emprunts ainsi que le nombre de jours couls depuis lemprunt. Nous devons alors manip-
uler des centaines dabonns, chacun dcrit par 4 valeurs, certaines de ces valeurs (nom, prnom) tant
galement une collection de valeurs primitives (une squence de caractres). Ce type de traitement est
impossible en nutilisant que des types primitifs.

Tout comme des oprateurs spcifiques sont associs chaque type primitif? , il peut tre commode de dfinir
des oprateurs ou mthodes permettant dinterroger ou transformer les valeurs de ces objets.

Nous souhaitons disposer dune mthode estEnRetard qui renvoie la liste des abonns dont le dernier
emprunt a t effectu il y a plus de 21 jours.

Dans cette section nous allons introduire les concepts relatifs aux objets ncessaires la cration dun tel
programme. Avant toute chose, nous allons expliquer les mcanismes communs tout objet Java, cest--
dire, la faon dont un objet est stock en mmoire et la manire dont on linstancie? , cest--dire la faon dont
on rserve lemplacement mmoire ncessaire lobjet. Nous verrons galement comment fonctionnent les
oprateurs de comparaison sur les objets.
STOCKAGE DES OBJETS EN MMOIRE Tout comme les variables de type primitif, une variable de type objet
est associ un emplacement mmoire de taille fixe qui contient une unique valeur. Dans cet emplacement
mmoire est stock une valeur de type adresse qui indique ladresse? de lemplacement mmoire o sont
stockes, de manire contigu, toutes les valeurs de lobjet. Ainsi, la variable est lie aux donnes de manire
indirecte : elle contient ladresse laquelle on peut trouver les donnes. La variable qui est manipule est en
fait une rfrence? lemplacement mmoire o se trouve lensemble des donnes.
maVariable

adresse 0001 0012

...
adresse 0012 valeur1
adresse 0013 valeur2
adresse 0014 valeur3
adresse 0015
...

INSTANCIATION? DES OBJETS Linstanciation dun objet se fait laide du mot cl new qui rserve lemplace-
ment mmoire ncessaire pour stocker toutes les valeurs de lobjet, cest--dire un ensemble de cases mmoire
contigus, et renvoie ladresse de la premire case mmoire.

//dclaration et instanciation
TypeObjet maVariable = new TypeObjet;

COMPARAISON DE DEUX OBJETS Lorsque lon compare deux objets, laide des oprateurs ==, <=, >=, <
ou <, ce sont les adresses des objets qui sont compares. Ainsi, loprateur == renvoie la valeur true si les
deux variables font rfrence au mme emplacement mmoire, donc au mme objet.

Programmation Java page 12 of 20

 if(variableA == variableB){
System.out.println("Les deux variables font rfrence au mme objet.");
}

3.2 LES TABLEAUX

Les tableaux permettent de regrouper un ensemble de valeurs de mme type.
3.2.1 TABLEAUX 1 DIMENSION
Un tableau 1 dimension est une collection linaire dlments de mme type. Chaque case dun tableau est
identifie par un indice et contient une valeur. Les indices dun tableau commencent 0. Il sensuit, quun
tableau de n lments aura des indices compris entre 0 et n 1.

Le type contenu dans les cases du tableau est choisi lors de la dclaration du tableau. En revanche, la taille
du tableau, ne fait pas parti de son type et sera dfinie lors de linstanciation du tableau. La dclaration dun
tableau se fait avec la syntaxe [].

int[] tabInt ; // Dclaration dun tableau dentiers

char[] tabChar ; // Dclaration dun tableau de caractres

Linstanciation quant elle prcise la taille rserver. Elle se fait avec le mot cl new.

int[] tabInt ; // Dclaration dun tableau dentiers

tabInt = new int[10]; // Instanciation dun tableau de 10 entiers

A noter quil est possible, dans le cas de linitialisation uniquement, de dcrire tout le tableau sous la forme
dune liste de valeurs. Cela initialise automatiquement le tableau avec le nombre adquate de cellules et les
valeurs sont stockes dans les diffrentes cases.
int[] tabCinq = {12,33,44,0,50}; //Initialisation expresse

Une fois le tableau initialis, on accde aux lments du tableau laide de la syntaxe suivante :
int i = 0;
int valeur1 = tabCinq[i]; //Renvoie 12, llment dindice 0
int valeur2 = tabCinq[4]; //Renvoie 50, llment dindice 4

Une fois initialis, il est possible tout moment de connatre la taille dun tableau (son nombre de cases)
laide de la syntaxe suivante :

int taille = tabCinq.length; //Renvoie 5, le nombre de cases du tableau tabCinq

3.2.2 TABLEAUX N DIMENSIONS

Un tableau 2 dimensions est un cas particulier de tableaux 1 dimension. En effet, cest simplement un
tableau dont chaque case contient un tableau 1 dimension dlments. Par rcurrence, il est donc possible
de dfinir un tableau n dimensions. Du point de vue de la notation, chaque dimension correspond un
couple de crochets supplmentaires au niveau du type et des accs.

char[][] T ; // Dclaration dun tableau 2 dimensions de caractres

T = new char[3][5]; // Instanciation dun tableau contenant 3 tableaux de
// 5 caractres chacun. T a donc 3 lignes et 5 colonnes.

Programmation Java page 13 of 20

Les multiples crochets sont lus de gauche droite, ce qui correspond regarder les tableaux depuis le plus
extrieur vers plus plus intrieur. Ainsi, T.length renvoie 3, la taille du tableau extrieur, T[0].length renvoie
5 la taille du tableau contenu dans la premire case de T. Cest la mme convension quen mathmatiques
pour les matrices, dabord les lignes, puis les colonnes. Pour finir, comme chaque dimension est un tableau,
il sensuit que chaque dimension est indice de 0 n 1.

45 154 58 78 31
12 15 45 37 789 int[][] T = new int[5][5];
int i = T[0][1];//i vaut 154
457 21 78 89 365 int[] T1 = T[1];//T1 fait rfrence
87 154 58 78 42 //au tableau [12,15,45,37,789]
5841 4 45 6 47

Une matrice Sa reprsentation informatique a Le code Java

a
Image provenant de http://fr.wikipedia.org/wiki/Tableau_(structure_de_donnes)

3.3 MTHODES PARAMTRES DE TYPE NON - PRIMITIF

En Java, le passage des paramtres une mthode se fait par valeur. Dans le cas des types non-primitifs, cette
valeur est une adresse. Ainsi, une mthode ne pourra pas modifier ladresse de la variable, en revanche elle
pourra modifier les valeurs stockes cette adresse.
3.3.1 INSTANCIATION DES VARIABLES DE TYPE NON-PRIMITIF DANS UNE MTHODE
Linstanciation dun objet laide du mot cl new rserve lemplacement mmoire ncessaire au stockage des
valeurs de lobjet et renvoie ladresse. Ainsi, si cette instruction est effectue dans une mthode, il faudra
penser renvoyer cette adresse pour pouvoir manipuler lobjet en dehors de la mthode.
Prenons lexemple suivant o lon souhaite dupliquer un tableau pour pourvoir le modifier tout en con-
servant loriginal :

static int[] copierTableau(int[] tableau) {

int[] copie = new int[tableau.length];
for(int i = 0; i < tableau.length; i = i + 1) {
copie[i] = tableau[i];
}
return copie;
}

3.3.2 MODIFICATION DES VALEURS DUNE VARIABLE DE TYPE NON-PRIMITIF DANS UNE MTHODE
Lorsquon passe un objet en paramtre dune mthode, cest ladresse de celui-ci qui est affecte au paramtre
formel de la mthode. Si la mthode modifie cette valeur (ladresse), celle-ci ne sera pas modifie en de-
hors (le contexte appelant) de la mthode. En revanche, lorsquon modifie les valeurs de lobjet, on change
directement les valeurs dans les cases mmoires de lobjet et ce changement est alors dfinitif.
Prenons lexemple suivant o lon permute les valeurs des indices i et j du tableau :

static void permute(int[] tab, int i, int j) {

int temp = tab[i];
tab[i] = tab[j];
tab[j] = temp;
}

int[] unTableau = {1,2,3,4,5};

permute(unTableau,0,4);
//unTableau contient les valeurs [5,2,3,4,1]

Programmation Java page 14 of 20

3.4 LES OBJETS
Les diffrentes valeurs dun objet son appeles attributs? . Pour accder la valeur dun attribut, on utilise la
syntaxe suivante :

//accs la valeur de lattribut

TypeAttribut monAttribut = monObjet.nomAttribut;
//affectation dune valeur lattribut
monObjet.nomAttribut = valeurAttribut;

Il peut exister des mthodes spcifiques permettant dinterroger ou de transformer les valeurs des attributs
dun objet. Pour appeler? une mthode sur un objet, on utilise la syntaxe suivante :

TypeRetour valeurRetour = monObjet.nomMethode(parametre_1,.., parametre_N);

La mthode nomMethode permet daccder ou de modifier les valeurs des attributs de monObjet.

Si une mthode naccde pas ou ne modifie pas les attributs de lobjet, on dit que cette mthode est static.
La dclaration de la mthode est prcde du mot cl static. Lappel de la mthode se fait comme expliqu
dans la section 2.

3.4.1 LOBJET PRDFINI STRING

Il existe de nombreux objets prdfinis en Java. Nous allons dans cette section prsenter lun dentre eux,
incontournable : le type chane de caractres, appel String. Cet objet est le seul qui sera rellement
manipul en premire anne.
Une chane de caractres reprsente un texte. Cest une collection linaire de caractres quil nest pas
possible de modifier une fois que lobjet a t instanci et initialis. Ces oprations se font selon la syn-
taxe :
//Dclaration, instanciation et initialisation
String ecole = new String("INSA-Lyon");

Noter la prsence de guillemets doubles pour distinguer les chanes de caractres des lments du langage
de programmation Java (mots du langage, nom de variables, nom de mthodes).

Comme le type String est trs utilis, une particularit de ce type est que lon accde lattribut principal
de lobjet, la chane de caractres, comme si ctait un type primitif :

System.out.println(ecole); // affiche "INSA-Lyon"

Les objets de type String sont fournis avec un grand nombre de mthodes permettant une manipulation
facile de ces objets. Les quatre principales mthodes permettent daccder chaque caractre de la chane,
de connatre le nombre de caractres de la chane (sa longueur), dextraire une partie de la chane et de
comparer le contenu de deux chanes :

char charAt(int n) : cette mthode prend en paramtre un entier n et renvoie le n + 1 me carac-

tre de la chane (le premier caractre est lindice 0 et le n + 1 me lindice n).

String ecole = new String("INSA-Lyon");

char c = ecole.charAt(2); //c contient le caractre S

int length() : cette mthode renvoie la longueur de la chane de caractres.

Programmation Java page 15 of 20

 String ecole = new String("INSA-Lyon");
int longueur = ecole.length(); // longueur contient 9

Notez les parenthses de la mthode length, parenthses absentes lorsque lon appelle cette mth-
ode sur un tableau.

String substring(int debut, int fin) : cette mthode renvoie un objet de type String qui
contient la sous-chane de caractres commenant lindice debut et se terminant lindice fin-1.

String ecole = new String("INSA-Lyon");

String ville = ecole.substring(5, ecole.length());
//quivaut ecole.substring(5, 9), ville contient "Lyon"

equals(String s) : cette mthode renvoie une variable de type boolen qui vaut vrai si et seulement
si la chane de caractres s est la mme que la chane de caractres de lobjet sur lequel on appelle la
mthode :

String ecoleA = new String("INSA-Lyon");

String ecoleB = new String("INSA-Lyon");
if(ecoleA.equals(ecoleB) == true){
//cette condition est satisfaite
if(ecoleA == ecoleB){
//cette condition nest pas satisfaite,
//les deux objets nayant pas la mme adresse
}
}

Une opration frquente consiste coller bout--bout deux chanes de caractres. On appelle cela la
concatnation. Loprateur associ est + :

String ville = new String("Lyon");

String ecole = new String("INSA");
String monEcole = ecole + "-" + ville; // monEcole contient "INSA-Lyon"

Il peut tre ncessaire de pouvoir convertir un type primitif en une chane de caractres ou rciproquement.
La conversion dun type primitif en une chane de caractres se fait laide de linstruction

String.valueOf(valeurPrimitive);

int valeur = 22;

String chaine = String.valueOf(valeur); // chaine contient "22"

La conversion dune chane de caractres en un type primitif se fait laide des instructions suivante :

Integer.parseInt(chaine); // renvoie une valeur de type int

Double.parseDouble(chaine); // renvoie une valeur de type double
Boolean.parseBoolean(chaine);// renvoie une valeur de type boolean
chaine.charAt(i); // renvoie une valeur de type char

Programmation Java page 16 of 20

 String chaine = "22" ;
int valeur = Integer.parseInt(chaine); //valeur vaut 22

3.4.2 LES OBJETS PROPRES

Cette section couvre une partie du programme de deuxime anne.

On peut galement dfinir ses propres objets. Cest ce que nous allons apprendre faire ici, en illustrant
notre propos sur lexemple du dbut de section.
LES CLASSES Les classes permettent de dfinir des types ou des catgories dobjets (on pourra prendre la
mtaphore du moule des objets). Elles contiennent la description des objets, (ex : les abonns), cest--dire
quelles dfinissent les attributs et les mthodes communes aux objets dun certain type.
Les objets construits partir de ces classes sont des instances. Les instances sont des lments crs depuis
une classe : un abonn particulier. La syntaxe de dclaration dune classe est :

class NomType {
// le corps de la classe vient ici
// les attributs
// les mthodes
}

On commence gnralement par dclarer les attributs de la classe :

class Abonne {
//les attributs de la classe Abonne
String nom;
String prenom;
int nbLivres;
int nbJours;
}

LE CONSTRUCTEUR Toute classe doit contenir au moins une mthode particulire appel constructeur. Cette
mthode porte le mme nom que la classe et est appele lorsque lon instancie un nouvel objet. Cest
cette fonction qui gnralement initialise les valeurs des attributs. Cette mthode ne renvoie aucune valeur.

class Abonne {
//les attributs de la classe Abonne
String nom;
String prenom;
int nbLivres;
int nbJours;

Abonne() { // premier constructeur

nom = new String("");
prenom = new String("");
nbLivres = 0;
nbJours = 0;
age = 0;
}
Abonne(String nom, String prenom, int nbLivres, int nbJours) {
// deuxime constructeur

Programmation Java page 17 of 20

 this.nom = new String(nom);
this.prenom = new String(prenom);
this.nbLivres = nbLivres;
this.nbJours = nbJours;
}
}

Il peut exister plusieurs constructeurs qui se distinguent par leurs paramtres formels. Ainsi, en fonction
des paramtres effectifs (nombre de paramtres ou types des paramtres) passs au constructeur au mo-
ment de lappel, lun ou lautre des constructeurs sera appel. Par exemple, linstruction Abonne() d-
clenchera lexcution du premier constructeur, alors que linstruction Abonne("Dupond", "Luc",4,0) d-
clenchera lexcution du second constructeur qui instancie les attributs aux valeurs correspondant labonn
Luc Dupond.

Le mot cl this permet de spcifier que lattribut que lon rfrence est celui de lobjet en cours de con-
struction. En effet, lexpression this.nom = nom; signifie que lattribut nom de lobjet en cours de con-
struction (this.nom) prend la valeur du paramtre formel nom de type String du constructeur.

EXEMPLE Regardons maintenant comment on peut construire notre programme qui indique les abonns qui
ont emprunt un livre depuis plus de 21 jours. Nous venons de voir la classe Abonne qui contient les attributs
dun abonn. Ajoutons une mthode renseigneUnAbonne qui permet de spcifier les nouvelles valeurs des
attributs :

void renseigneUnAbonne(String nom, String prenom, int nbLivres, int nbJours) {

this.nom = new String(nom);
this.prenom = new String(prenom);
this.nbLivres = nbLivres;
this.nbJours = nbJours;
}

La classe EnsembleDesAbonnes va contenir lensemble des abonns de la bibliothque. Ses attributs sont
alors un tableau dabonns (lesAbonnes) et un entier qui indique le nombre dabonns. Son construc-
teur alloue lemplacement mmoire ncessaire au tableau lesAbonnes et instancie chacun des abonns :

class EnsembleDesAbonnes {
//Attributs de la classe EnsembleDesAbonnes
Abonne[] lesAbonnes;
int nbAbonnes;
//Constructeur
EnsembleDesAbonnes(int nbAbonnes) {
lesAbonnes = new Abonne[nbAbonnes];
this.nbAbonnes = nbAbonnes;
int i;
for(i = 0; i < this.nbAbonnes; i++) {
lesAbonnes[i] = new Abonne(); // instancie chaque abonn
}
}

Les attributs de la classe doivent tre initialiss dans le constructeur, et en particulier, les attributs de type
non-primitifs doivent tre instancis via le mot cl new qui rserve lemplacement mmoire de cet attribut.

Enfin, la mthode estEnRetard, qui renvoie la liste des abonns dont le dernier emprunt a t effectu il
y a plus de 21 jours, compte le nombre dabonns en retard, puis cre un nouvel objet EnsembleDesAbonnes

Programmation Java page 18 of 20

pouvant contenir tous les abonns en retard, puis recopie ladresse des abonns en retard dans lobjet resultat :

EnsembleDesAbonnes estEnRetard() {
int i;
int nbEnRetard = 0;
for(i = 0; i < lesAbonnes.length; i++) {
if( (lesAbonnes[i].nbJoursEmprunts > 21)
&&(lesAbonnes[i].nbLivresEmpruntes > 0)) {
nbEnRetard = nbEnRetard + 1;
}
}

EnsembleDesAbonnes resultat = new Abonnes(nbEnRetard);

int j = 0;
for(i = 0; i < lesAbonnes.length; i++) {
if( (lesAbonnes[i].nbJoursEmprunts > 21)
&&(lesAbonnes[i].nbLivresEmpruntes > 0)) {
resultat.lesAbonnes[j] = this.lesAbonnes[i];
j = j + 1;
}
}
return resultat;
}

Le tableau lesAbonnes de lobjet resultat contient des rfrences vers les abonns du tableau lesAbonnes
de lobjet en cours de dfinition.

Enfin, la mthode main de la classe EnsembleDesAbonnes instancie un objet mesAbonnes comportant 4

abonns, et appel la mthode estEnRetard sur cet objet qui renvoie un nouvel objet abonnsEnRetard
qui contient un tableau de rfrences vers les abonns en retard :

public static void main (String[] args) {

EnsembleDesAbonnes mesAbonnes = new EnsembleDesAbonnes(4);
mesAbonnes.lesAbonnes[0].renseigneUnAbonne("Dupond", "Luc",4,0);
mesAbonnes.lesAbonnes[1].renseigneUnAbonne("Martin", "Jeanne",1,30);
mesAbonnes.lesAbonnes[2].renseigneUnAbonne("Vaus", "Paul",2,22);
mesAbonnes.lesAbonnes[3].renseigneUnAbonne("Bon", "Jean",0,27);
EnsembleDesAbonnes abonnesEnRetard = mesAbonnes.estEnRetard();

// abonnesEnRetard contient les rfrences Jeanne Martin et Paul Vaus

4 GLOSSAIRE
ADRESSE : Indique la localisation dune information dans la mmoire.
AFFECTATION : Laffectation est lopration qui attribue une valeur une variable. En Java cet oprateur est
=. Il se lit prend la valeur de.
APPEL DE MTHODES : Lappel dune mthode excute le bloc dinstructions de la mthode. Lappel se fait en
crivant le nom de la mthode (en respectant la casse) suivie dune paire de parenthses avec ventuellement
une liste de paramtres effectifs? spars par une virgule. Au moment de lexcution de lappel, les valeurs
des paramtres effectifs sont affectes aux paramtres formels? , selon lordre dans lequel ils apparaissent. Si
le type renvoy par la mthode est diffrent de void, lappel de la mthode doit tre affect une variable

Programmation Java page 19 of 20

de mme type.
ATTRIBUT : Les attributs sont des variables associes un objet.
CONSOLE : La console est une interface textuelle qui permet de demander lordinateur dexcuter des pro-
grammes. Elle est souvent considre tord comme tant obsolte. Pour autant il sagit dune des interfaces
les plus puissantes utiliser puisque lon peut directement programmer dans la console. De plus, il sagit bien
souvent de lunique faon daccder des machines distance.
COMPILATION : La compilation permet de transformer un code source crit dans un langage de program-
mation en langage machine (ou langage binaire) excutable par lordinateur.
DCLARATION : Avant de pouvoir utiliser une variable ou une mthode, il faut la dclarer. La dclaration
dune variable associe un type un nom et rserve un emplacement mmoire dans lequel est stocke la valeur
de la variable, si son type est primitif, ou ladresse du dbut de la plage mmoire o est stock la variable
si son type est non primitif. La dfinition dune mthode sappelle galement dclaration. Elle consiste
dfinir le nom de la mthode, le type de la valeur retourne, la liste de ses paramtres formels et son bloc
dinstructions.
DCRMENTER : Lopration de dcrmentation sapplique une variable de type entier. Elle consiste
retirer une valeur entire la variable, classiquement la valeur 1 (x = x - 1).
EXCUTION : Lexcution est le processus par lequel une machine met uvre les instructions dun programme
informatique.
INCRMENTER : Lincrmentation est lopration qui consiste ajouter une valeur entire fixe une variable
de type entier. La valeur ajoute est le plus souvent la valeur 1 (x = x + 1).
INITIALISATION : Lorsquon dclare une variable, un emplacement mmoire est associ la variable. Or,
celui-ci contient une valeur quelconque. Il est ncessaire dinitialiser la valeur de la variable, cest--dire
de raliser une premire affectation dune valeur la variable, afin que cette dernire contienne une valeur
approprie.
INSTANCE DE CLASSE : On appelle instance dune classe, un objet avec un comportement (mthodes) et un
tat (attributs), tous deux dfinis par la classe. Il sagit donc dun objet constituant un exemplaire de la classe.
INSTANCIER : Rserver lespace mmoire ncessaire pour stocker toutes les valeurs de lobjet. De manire
plus gnrale, fabriquer un exemplaire dun lment partir dun modle qui lui sert en quelque sorte de
moule.
OPRATEUR : Un oprateur est une fonction spciale dont lidentificateur scrit avec des caractres non
autoriss pour les identificateurs ordinaires (les variables). Il sagit souvent des quivalents aux oprateurs
mathmatiques pour la programmation informatique.
PARAMTRES EFFECTIFS : Il sagit de valeurs fournies une mthode lors de son appel. Ces valeurs peuvent
tre des constantes ou des variables.
PARAMTRES FORMELS : On parle aussi de paramtre muet. Il sagit de variables utilises dans le bloc
dinstructions dune mthode. Ces paramtres permettent de dcrire comment les donnes en entre de la
mthode sont transformes par celle-ci.
RFRENCE : Une rfrence est une valeur qui permet laccs en lecture et/ou criture une donne en
mmoire. Une rfrence nest pas la donne elle-mme mais seulement une information de localisation,
ladresse de la valeur dans la mmoire.
TYPES PRIMITIFS : Les types primitifs (entier, flottant, boolen et caractre) permettent de manipuler di-
rectement les donnes les plus courantes et ont la particularit dtre accessibles directement en mmoire.
TYPES NON PRIMITIFS : Les types non primitifs permettent dassocier plusieurs valeurs une variable.
Lemplacement mmoire associ la variable permet de stocker ladresse de lemplacement mmoire o se
trouvent ses valeurs. La variable est ainsi lie ses valeurs de manire indirecte.

Programmation Java page 20 of 20