Résumé du cours de Programmation

Java
Carole Frindel et Céline Robardet
TABLE DES
MATIÈRES
1
1. Qu’est-ce qu’un
1 Notions élémentaires programme ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . 1
2. Les
variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1. Les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2. 1. Les Bloc
conversions . . . . . . . . . . . . . . . . . . . . . . . . . .
d’instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . .
. . . . . 4
3. 2. Les Structures
opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Les méthodes
3. Structures 3. Le
1. Lesprogramme
méthodes . . .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. . . . . .
itératives
prédéfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2. Les méthodes 4. Les structures de
propres . . .contrôle
. . . . . .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. . . . . . .
3. Les méthodes 6
3 Les types non primitifs
récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
1.
4. Un Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.
exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. 12 7
. . . . 2. Les
tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.
139
1. Tableaux à 1 dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9
131
2. Tableaux à n dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
131
3. Méthodes à paramètres de type non- 1
primitif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.
4 Glossaire Instanciation des variables de type non-primitif dans une méthode . . . . . . . . . . . . 19 .
14
2. Modification des valeurs d’une variable de type non-primitif dans une méthode . . . . .
Ce support de cours couvre l’intégralité du programme de première année et vous permettra 14
de com- prendre les concepts liés à la programmation en Java. La section 3.4.2 introduit 4. Les
quelquesobjets
concepts. . . de
. . .la. programmation
. . . . . . . . . . .objet, . . . .qui . . .sont. . . vus. . .en . . deuxième
. . . . . . . année . . . . .du . . premier
. . . . .
cycle. . 15
1. L’objet prédéfini String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 NOTIONS ÉLÉMENTAIRES 15
2. Les objets propres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1. QU’EST-CE QU’UN PROGRAMME ? 17
L’objectif de la programmation est de créer des logiciels ou programmes. Ceux-ci sont
constitués d’un en- semble de traitements qui permettent de transformer des données
numériques (les entrées) en d’autres don- nées numériques (les sorties). Les données de sortie
peuvent être affichées sous une forme graphique (avec

1
des fenêtres comme le fond les programmes tels que Word et Excel) ou plus simplement
affichées dans une console٨1 sous forme de texte.
Que se passe-t-il pour l’ordinateur lorsqu’on exécute un programme ? Il va lire le fichier
exécutable du programme comme une suite de 0 et de 1 (codage binaire) et exécuter l’une
après l’autre les instructions ainsi codées. Cette suite de 0 et de 1 est appelée langage machine
et est directement exécutable par le micro- processeur de l’ordinateur. Or il est très difficile pour
un humain de programmer directement en binaire, c’est 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 exécuté
pour réaliser les traitements :
Compilation

Exécution

$ javac [Link] $ java Bonjour

1.2 LES VARIABLES

Les variables constituent l’aspect le plus important de la programmation, puisqu’elles permettent
de stocker dans un emplacement mémoire les données et de les transformer en utilisant des
opérateurs٨. On peut se représenter une variable comme une étiquette associée à une unique
boîte dans laquelle est rangée une valeur d’un certain type (entier ou réel, par exemple) :

Avant de pouvoir utiliser une variable, il est nécessaire de la déclarer٨, c’est-à-dire d’associer la
variable à un emplacement de la mémoire et de spécifier son type. C’est en fonction du type de
la variable que la taille de l’emplacement mémoire (en octet, soit 8 bits) et le codage binaire
de la valeur seront déterminés. La déclaration se fait par une instruction de la forme :
typeVariable nomVariable;

La variable nomVariable est de type typeVariable . Il lui est associé un emplacement mémoire
qui con- tient une valeur qu’il faut initialiser٨. Cela se fait en utilisant l’opérateur d’affectation
“=” :
nomVariable = uneValeur;

L’affectation٨ écrit dans l’emplacement mémoire 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 entière. On peut faire ici le parallèle entre le type
d’une variable et l’unité de mesure d’une grandeur physique qui spécifie la nature de la
grandeur manipulée.
On peut également faire la déclaration et l’initialisation d’une variable en une seule
instruction :

1
Le symbole ٨ indique que le mot est défini dans la section
Glossaire.

Programmation page 2 of
Java 20
 typeVariable nomVariable = uneValeur;

Dans la suite, nous allons détailler les quatre types dits “primitifs”٨, qui sont directement
accessibles en mémoire (contrairement aux types non primitifs que nous verrons dans la section
3), c’est-à-dire que la valeur affectée à la variable est stockée dans l’emplacement mémoire
associée à celle-ci. Pour chacun de ces types, nous verrons également les opérateurs que l’on
peut appliquer sur des variables de ce type pour transformer leur valeur.
1.2.1 LES TYPES PRIMITIFS
On distingue 4 catégories de types primitifs (entier, réel, booléens, caractères). L’intervalle de
valeurs représenta- bles pour chacun des types peut varier en fonction de l’espace mémoire qu’ils
occupent.
LES ENTIERS En Java, tous les types permettant de représenter des entiers sont signés. Ainsi,
sur n bits, on peut coder les entiers de −(2 n − 1 ) à 2n−1 − 1. Les valeurs négatives sont encodées
en complément à 2. Pour un rappel sur cet encodage, nous vous renvoyons au cours de
numération disponible sur la page du CIPC.
Nom
Les différents types Taille
d’entiers Intervalle
sont les suivantsreprésentable
:
byte 1 octet [−128 . . . 127] ou [−27 . . . 27 −
1]
short 2 octets [−32768 . . . 32767] [−215 . . . 215
− 1]
int 4 octets [−231 . . . 231 − 1]
long
On peut appliquer des opérateurs 8 octets [−263 . (+,-,*,/)
arithmétiques . . 263 − à
1]deux variables ou deux expressions de
type entier (la composition étant possible comme en mathématiques). Le résultat de cette
opération est également du type entier (ce qui permet la composition).

Lorsque les deux opérandes sont de type entier, l’opérateur / calcule la division entière et
l’opérateur % calcule le reste de cette division.

Par
exemple2 :
i n t valA = 7;
i n t valB = 2;
i n t valC = // valC contient l a valeur 3
valA / valB; // valD contient l a valeur 1
i n t valD =
valA
LES % valB;
RÉELS La description du codage des réels est décrite dans le cours de numération sur la
page du CIPC. En Java il existe deux types de représentation pour les nombres réels : simple et
double précision (respectivement les types f l o a t et double).

Nom Taille Intervalle représentable

float 4 octets [−3.4 . 1038, · · · , −1.4 . 10−45, 0, 1.4 . 10−45, · · · , 3.4 .
1038]
double 8 octets [−1.8 . 10308, · · · , −4.9 . 10−324, 0, 4.9 . 10−324, · · · ,
1.8 . 10308]
Lorsqu’au moins une des opérandes est de type réel, l’opérateur / calcule la division réelle.

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

Programmation page 3 of
Java 20
LES BOOLÉENS Un type de variable très utile en informatique est le type booléen, qui prend
deux valeurs VRAI ou FAUX.

Nom Taille Intervalle

représentable
boolean 1 octet [true,false]
On peut appliquer des opérateurs logiques (et, ou, non) à des variables ou des expressions
booléennes. Le résultat de cette opération est également du type booléen.

• && désigne l’opérateur et logique

• || désigne l’opérateur ou logique

• ! désigne l’opérateur non logique (qui transforme une valeur true en valeur f a l s e 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 CARACTÈRES Le type caractère peut correspondre à n’importe quel symbole du clavier
(lettre en majus- cule ou minuscule, chiffre, ponctuation et symboles).

Nom Taille Intervalle représentable

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

Pour distinguer la valeur correspondant au caractère a de la variable dénommée a, on utilise

l’apostrophe pour la première.

char caractere = ’ a ’ ; // La variable caractere contient l a valeur a

i n t a = 3; // La variable a contient l a valeur 3

Comme toute donnée numérique, un caractère est encodé sous forme d’une suite de 0 et de 1
que l’on peut interpréter 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 i n t comme expliqué ci-dessous.
1.2.2 LES CONVERSIONS
La conversion (également appelée transtypage) d’un type primitif en un autre se fait de la
manière suiv- ante :
typeVariableA variableA = (typeVariableA) valeurB

Si variableA et valeurB ne sont pas du même type, cette instruction affecte à variableA la
conversion de la valeur de valeurB dans le type typeVariableA :
Entier vers Réel la même valeur codée en
Réel vers Entier réel la partie entière du
Entier vers réel
caractère le caractère dont le code
Caractère vers est l’entier
Entier le code numérique
correspondant au
caractère
Programmation page 4 of
Java 20
 int i ;
double x = 2;
i = ( i n t ) (x * 42. 3); // i vaut 84

1.2.3 LES OPÉRATEURS DE COMPARAISON

Les opérateurs de comparaison permettent de comparer deux variables d’un même type primitif
(entier, flot- tant, booléen et caractère) et renvoient une valeur booléenne :
== comparaison d’égalité
!= différence
< inférieur strict
<= inférieur ou égal (s’écrit de la même manière dont on le
prononce)
> supérieur strict
>= supérieur ou égal (s’écrit de la même manière dont on le
prononce)
Attention, l’opérateur = correspond à l’affectation alors que l’opérateur == correspond à la
comparaison d’égalité, c’est-à-dire au signe = utilisé en mathématiques !!

Les expressions composées doivent être complètement

parenthésées :
double a = 8;
boolean estDansIntervalle = ( (a >= 0) && (a <= 10));
// vaut true s s i a appartient à [0,10]

1.3 LE PROGRAMME
De manière générale, la structure d’un programme simple est toujours la même. Cette structure
de base doit être apprise par cœur, car elle constitue le squelette du programme. Il est conseillé,
lors de la création d’un programme, de commencer par écrire cette structure. En effet, une fois
cette structure créée, le programme est fonctionnel : il peut être compilé٨ et exécuté٨. Bien
entendu à ce stade, le programme ne fait strictement rien puisqu’il n’y a aucune instruction,
seulement des commentaires.

public c l a s s Exemple{ //Exemple est l e nom du programme

// é c r i t dans l e f i c h i e r [Link]
public s t a t i c void main ( S t r i n g [ ] args){
//bloc d’in struction s du
programme
//exécutées l o r s du lancement du
programme
}
Déclare et initialise deux} variables celsius et fahrenheit, fahrenheit étant calculée à partir de celsius,
pour ensuite les afficher à l’écran.

public c l a s s
ConversionCelsiusVersFahrenheit{ public
s t a t i c void main ( S t r i n g [ ] args){
double c e l s i u s = 12.0;
double fahrenheit = ((9.0/5.0) * c e l s i u s ) + 32.0;
[Link] .print(celsius);
[Link] .print(" degrés Celsius convertit en
Fahrenheit vaut " ) ;
[Link] .println(fahrenheit);
}
}L’instruction [Link] .print permet d’afficher la valeur d’une variable de type primitif ou un
texte délimité par des guillemets.

Programmation page 5 of
Java 20
4. LES STRUCTURES DE CONTRÔLE
Le principe d’un programme est de modifier le contenu des variables à l’aide des instructions
élémentaires que nous venons de voir (affectation et opérateurs). Or, nous pouvons vouloir que
ces instructions ne soient réalisées que dans certains cas, ou bien nous pouvons vouloir répéter
l’exécution de ces instructions. Ce sont les structures de contrôle qui permettent de spécifier si
l’exécution d’un traitement est conditionnée ou bien si elle se fait de manière répétée.
1. BLOC D’INSTRUCTIONS
Les accolades {} permettent de délimiter un bloc d’instructions, c’est-à-dire un ensemble
d’instructions qui vont être exécutées les unes à la suite des autres. Un bloc d’instructions peut,
par exemple, être exécuté que lorsqu’une condition est vérifiée ou bien il peut être exécuté
plusieurs fois de suite. Ce sont les structures de contrôle conditionnelles et itératives qui
permettent d’exprimer cela. Les variables déclarées٨ dans un bloc sont accessibles à l’intérieur de
ce bloc uniquement.
Deux variables de même nom peuvent être déclarées dans deux blocs distincts. Ce sont
deux variables différentes associées à deux emplacements mémoires différents. Ainsi, leurs
valeurs sont généralement différentes. Confondre l’une avec l’autre peut être une source
d’erreur de programmation.
1.4.2 STRUCTURES CONDITIONNELLES
Les structures de contrôle conditionnelles permettent de spécifier à quelles conditions un bloc
d’instructions va être exécuté. Cette condition est exprimée par une expression logique.
LA STRUCTURE ALTERNATIVE Le premier type de conditionnelle s’écrit comme suit :

i f (condition) {// équivalent à (condition == true)

// bloc d’ in str u cti on s exécutées s i condition est vraie
} el s e {
// bloc d’ in str u cti on s exécutées s i condition est fausse
}

Cette structure de contrôle exprime une alternative. Or, il est possible de vouloir qu’un bloc soit
exécuté sous une certaine condition et que sinon, aucune instruction ne soit exécutée. Dans ce
cas, la clause el s e et son bloc sont supprimés. Les parenthèses autour de condition , qui est
variable ou une expression à valeur booléenne, sont obligatoires.

Affiche un message si la température est supérieure à 50.

public c l a s s QuelleUnite{
public s t a t i c void main ( S t r i n g [ ] args)
{ i n t temperature = 36;
if(temperature > 50) {
[Link]("La température e st probablement en Fahrenheit");
}
}
}

LA STRUCTURE CHOIX MULTIPLES Le second type de conditionnelle permet de faire plusieurs

tests de valeurs sur le contenu d’une même variable. Sa syntaxe est la suivante :

switch (variabl e)
{ case valeur1 :
Liste
d’in structions //
exécutées s i
(variable ==
valeur1)
break;
case valeur2 :
Liste
Programmation page 6 of
d’in structions //
Java 20
exécutées s i
(variable ==
valeur2)
 break;
...
case valeurN :
L i s t e d’in structions // exécutées s i (variable == valeurN)
break;

defau l t :
L i s t e d’in structions // exécutées sinon
}
Le mot clé defaul t précède la liste d’instructions qui sont exécutées lorsque variable a une
valeur dif- férentes de val eur 1, . . , val eur N . Le mot clé break indique que la liste d’instructions
est terminée.
1.4.3 STRUCTURES ITÉRATIVES
Il existe 3 formes de structure itérative, chacune a un cadre d’utilisation bien spécifique que nous
allons voir.
L’ITÉRATION RÉPÉTÉE n FOIS La première forme itérative est la boucle for . Elle permet de
répéter un bloc d’instructions un nombre de fois fixé. Dans sa syntaxe, il faut déclarer et
initialiser la variable qui sert de compteur de tours de boucle, indiquer la condition sur le
compteur pour laquelle la boucle s’arrête et enfin donner l’instruction qui incrémente٨ ou
décrémente٨ le compteur :

fo r ( i n t compteur = 0 ; compteur < n ; compteur = compteur + 1) {

// bloc instructions répétées n f o i s
}
ou
fo r ( i n t compteur = n ; compteur > 0 ; compteur = compteur - 1) {
// bloc instructions répétées n f o i s
Affiche
} la conversion en Fahrenheit des degrés Celsius de 0 à 39.

public c l a s s
ConversionCelsiusVersFahrenheit{ public
s t a t i c void main ( S t r i n g [ ] args){
f o r ( i n t c e l s i u s = 0 ; c e l s i u s < 40; c e l s i u s
= c e l s i u s + 1) {
double fahrenheit = ((9.0/5.0) * c e l s i u s ) + 32.0;
[Link] .print(celsius);
[Link] .print(" degres Celsius convertit en
Fahrenheit vaut " ) ;
[Link] .println(fahrenheit);
}
}
} La boucle fo r s’utilise lorsque l’on connaît a priori le nombre de répétitions à effectuer.

L’ITÉRATION RÉPÉTÉE TANT QU’UNE CONDITION EST VRAIE La seconde forme d’itérative est
la boucle while. Elle exécute le bloc d’instructions tant que la condition est vraie. Le bloc peut
ne jamais être exécuté. La syntaxe est la suivante :
while (condition) { // équivalent à (condition == true)
// bloc d’ in str u cti on s répétées tant que condition est v r a i e .
// condition doit être modifiée dans ce bloc
}

Cette structure exécute le bloc d’instructions tant que (while en anglais) la condition est réalisée.

Programmation page 7 of
Java 20
 Il est important de toujours s’assurer que la condition deviendra fausse lors d’une itération de la
structure itérative. Dans le cas contraire, l’exécution du programme ne s’arrêtera jamais.

Affiche la conversion en Fahrenheit des degrés Celsius tant que la conversion est inférieur à 100.

public c l a s s
ConversionCelsiusVersFahrenheit{ public
s t a t i c void main ( S t r i n g [ ] args){
i n t c e l s i u s = 0;
double fahrenheit = ((9.0/5.0) * c e l s i u s ) + 32.0;
while(fahrenheit < 100) {
[Link] .print(celsius);
[Link] .print(" degres Celsius convertit en Fahrenheit vaut " ) ;
[Link] .println(fahrenheit);
c e l s i u s = c e l s i u s + 1;
fahrenheit = ((9.0/5.0) * c e l s i u s ) + 32.0;
}
}
}

La boucle while s’utilise lorsque le nombre d’itérations n’est pas connu a priori mais peut
s’exprimer au moyen d’une expression à valeur booléenne qui devient fausse lorsque la
répétition doit s’arrêter.
L’ITÉRATION EXÉCUTÉE AU MOINS UNE FOIS La troisième forme d’itérative est la boucle “do
while”. C’est une variante de la boucle while, où la condition d’arrêt est testée après que les
instructions ont été exé- cutées :
do {
// bloc d’ in str u cti on s exécutées
// condition doit être modifiée dans ce bloc
} while (con dition); // s i condition e st v r a i e ,
// l e bloc e st exécuté à nouveau

Ne pas oublier le ; après la condition d’arrêt. Le bloc d’instructions est exécuté au moins une
fois.

Affiche la conversion en Fahrenheit des degrés Celsius jusqu’à ce que le degré Fahrenheit soit supérieur
ou égale à 100.

public c l a s s
ConversionCelsiusVersFahrenheit{ public
s t a t i c void main ( S t r i n g [ ] args){
double fahrenheit;
i n t c e l s i u s = 0; do {
fahrenheit =
((9.0/5.0) *
celsius) +
32.0;
[Link] .print
(celsius);
[Link] .print(" degres Celsius convertit en Fahrenheit vaut " ) ;
[Link] .println(fahrenheit);
c e l s i u s = c e l s i u s + 1;
} while (fahrenheit < 100);
}
}
Programmation page 8 of
Java 20
2 LES MÉTHODES
Une méthode est un bloc d’instructions pouvant être exécutées par un simple appel٨ de la méthode
dans le bloc du programme principal (méthode main) ou dans une autre méthode. Les méthodes
permettent d’exécuter dans plusieurs parties du programme un même bloc d’instructions. On est
amené à créer une méthode dans deux cas de figure :

• Pour regrouper un ensemble d’instructions qui participent à la réalisation d’une même

tâche. Cela permet de rendre le programme plus lisible et compréhensible par une autre
personne (ou vous-même lors du TP suivant) et de faciliter la mise au point du
programme (correction et tests3). A ce bloc d’instructions est associé un nom, choisi en
rapport avec le traitement réalisé par la méthode.

• Pour regrouper un ensemble d’instructions qui sont répétées à différents endroits du

programme (con- trairement aux formes itératives qui répètent le bloc
d’instructions de manière consécutive).

Le rôle d’une méthode est de traiter des données. Cela signifie qu’en général, la méthode
effectue un traite- ment à partir des données qui entrent, et renvoie un résultat.
2.1 LES MÉTHODES PRÉDÉFINIES
En Java, il existe de nombreuses méthodes prédéfinies. La plus connue est sans doute la
méthode suivante
[Link] qui permet
.println("la d’afficher
chaîne une chaîne de
de caractères à caractères
a f f i c h e r "à) ;l’écran :

D’autres exemples de méthodes que vous pouvez utiliser sont celles de la librairie Math : s q r t ,
c o s , s i n , ab s , e t c . . Lorsqu’on appelle une méthode, on utilise son nom suivi de la liste de ses
paramètres effectifs (séparés par une virgule) entre parenthèses :
nomMethode(parametre_1,... , parametre_n);

Si cette méthode renvoie un résultat, il faut alors affecter ce résultat à une variable de type
compatible pour pouvoir ensuite utiliser ce résultat :

double racine = [Link](5.2);

2.2 LES MÉTHODES PROPRES

DÉCLARATION D’UNE MÉTHODE La définition d’une méthode s’appelle déclaration٨. La
déclaration d’une méthode se fait selon la syntaxe suivante :

s t a t i c TypeRetour nomMethode(Type1 p a r a m 1 , . . . , TypeN paramN) {

//bloc d’instructions
return valeurRetournee;
}

Le fait que l’on doive précéder la déclaration d’une méthode par le mot clé s t a t i c est expliqué
page 15. TypeRetour est le type de valeurRetournee, la valeur renvoyée par la méthode. Si la
méthode ne renvoie aucune valeur, le mot-clé void est utilisé à la place du type de la valeur
retournée.
Pour une raison inconnue des enseignants, il y a souvent confusion entre le fait de retourner
une valeur et le fait de l’afficher.

Les paramètres correspondent aux données d’entrée de la méthode. Au niveau de la

déclaration, les paramètres sont dits “formels” : ce sont des variables qui représentent chaque
donnée d’entrée. On peut faire ici l’analogie avec la variable x utilisée en mathématique
lorsque l’on définit une fonction f (x ). Les paramètres sont facultatifs, mais s’il n’y a pas de
paramètres, les parenthèses doivent rester présentes.
3
Commenter la ligne d’appel de la fonction commente tout le bloc d’instructions de la méthode à cet endroit du
programme.

Programmation page 9 of
Java 20
APPEL D’UNE MÉTHODE C’est au moment de l’appel de la méthode que les paramètres formels
sont initialisés, c’est-à-dire qu’une valeur leur est affectée. Les paramètres “effectifs”٨ de l’appel,
ceux passés en argument de la méthode au moment de l’appel, sont affectés aux paramètres
formels de la méthode (ceux de la définition de la méthode) par position : la valeur du premier
paramètre effectif est affectée au premier paramètre formel, et ainsi de suite. Les paramètres
effectifs peuvent être des valeurs ou des variables.
s t a t i c i n t addition(int x , i n t y) {//x e t y sont l e s paramètres formels
return x + y ;
}
public s t a t i c void main ( S t r i n g [ ] args)
{ i n t a = 7;
i n t somme = addition(a,3);//a e t 3 sont
l e s paramètres e f f e c t i f s de l ’appel
//x prend l a
valeur de a
e t y prend
En Java, le passage des paramètres lse a valeur 3
fait par valeur, c’est-à-dire que la valeur du paramètre
} effectif est affectée au paramètre formel. Ainsi, si la valeur du paramètre formel est
modifiée dans le bloc de la méthode, cette modification est locale à la méthode mais n’est pas
repercutée dans le contexte appelant.
Rien ne vaut un petit exemple
;-)
s t a t i c i n t addition(int en ti er A, i n t entierB)
{ entierA = entierA + 1; //entierA e st
modifié return entierA + entierB;
}
public s t a t i c void main ( S t r i n g [ ] args)
{ i n t a = 7;
i n t b = 3;
i n t somme = addi tion (a, b ); // l a valeur
de a est af fect ée à entierA
// a vaut toujours 7 après l ’ a p p e l de l a
méthode addition
}2.3 LES MÉTHODES RÉCURSIVES
Nous avons précédemment précisé qu’il était possible qu’une méthode appelle dans son bloc une
autre méth- ode. Il est également possible qu’elle s’appelle elle-même. A priori, l’intérêt peut
paraître limité, mais la récursivité permet d’effectuer certains calculs mathématiques, en particulier
avec les suites définies par récur- rence. Par exemple, on peut calculer la factorielle d’un nombre
entier en utilisant la récursivité. Pour cela, on peut procéder de la manière suivante, par exemple
si l’on 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 récurrence : pour calculer 4!, il suffit de calculer 3!, puis 2!,
et ainsi de suite, jusqu’à un cas directement résolu (sans expression récursive, le cas de base).
Nous pouvons alors créer une méthode c al c u l eFa c to r i e l l e ayant comme paramètre un entier
n, et renvoyant l’entier n!. On voit qu’il suffit que la fonction s’appelle elle-même suivant ce
même principe pour calculer facilement la factorielle de n’importe quel nombre entier. Cependant,
arrivé au calcul de 0!, il est nécessaire que la fonction renvoie directement la valeur 1, sans faire
d’appel récursif. En d’autres mots, il ne faut pas que l’appel de cal cu l eFacto r iel l e(0)
provoque l’appel de c al c u l eFac to r i el l e ( - 1) . Il renvoie directement 1, afin de ne pas provoquer
une infinité d’appels :

Programmation page 10 of
Java 20
 public c l a s s Fa c t o r i e l l e {
s t a t i c i n t c a l c u l e Fa c t o r i e l l e ( i n t n)
{ i f ( n > 0) { // cas général
return n * c al c u l eFac to r i e l l e ( n -
1);
}

el s e { //cas de base ou d’arrêt

return 1;
}
}
public s t a t i c void main ( S t r i n g [ ] args)
{ i n t valeur = 4;
[Link] .prin tl n (cal cul eFactoriel l e(val e
ur)); // 5 appels en tout
}
}2.4 UN EXEMPLE
L’exemple suivant présente un programme avec deux méthodes : CelsiusVersFahrenheit convertit
valeurAConvertir , une valeur réelle représentant une température en degré Celsius, en une température en
degré Fahrenheit. La
valeur en Fahrenheit est retournée par la méthode. CelsiusVersKelvin convertit
valeurAConvertir , une valeur réelle représentant une température en degré Celsius, en une
température en degré Kelvin. La température en Kelvin est affichée et aucune valeur n’est
retournée par la méthode.
Observez la différence entre les appels des deux méthodes dans le main : la valeur retournée
par CelsiusVersFahrenhei
est affectée à la variable temperature , puis elle est affichée. La méthode CelsiusVersKelvin est
directe- ment appelée, sans affectation de sa valeur de retour, puisque celle-ci n’en n’a pas
(mot clé void dans la déclaration).
Le programme considère les températures entières, en degré Celsius, de 0 à 39 inclus. Une fois
public
sur deux,c l a s s Conversion {
sa conversion
s t a t i c endouble
degré Fahrenheit est affichée, l’autre fois c’est
CelsiusVersFahrenheit(double sa conversion en degré Kelvin qui
valeurAConvertir)
est affichée. Notez leFahrenheit
{ double changement= de valeur de la
((9.0/5.0) * variable calculeFahrenheit
valeurAConvertir) + 32.0;à chaque tour de
boucle. return Fahrenheit;
}
s t a t i c void CelsiusVersKelvin(double valeurAConvertir)
{ double Kelvin = 273.15 + valeurAConvertir;
[Link](Kelvin);
}
public s t a t i c void main ( S t r i n g [ ] args)
{ boolean calculeFahrenheit = tr u e;
f o r ( i n t c e l s i u s = 0 ; c e l s i u s < 40; c e l s i u s
= c e l s i u s + 1) {
if(calculeFahrenheit == true) {
double temperature = CelsiusVersFahrenheit(celsius);
[Link](temperature);
} el s e {
CelsiusVersKelvin(celsius);
}
calculeFahrenheit = !calculeFahrenheit;
}
}
}

Programmation page 11 of
Java 20
3 LES TYPES NON PRIMITIFS
1. GÉNÉRALITÉS
Nous avons vu (section 1.2) qu’une variable permet de stocker dans un emplacement mémoire
une donnée d’un certain type, et que cette donnée peut être transformée en utilisant des
opérateurs spécifiques de son type. Or, au lieu de manipuler une seule valeur, il est parfois
beaucoup plus commode qu’une variable soit associée à une collection de valeurs. C’est ce que
permettent les types non primitifs, appelés objet en Java.
Supposons que l’on souhaite réaliser un programme permettant d’écrire des courriers de
manière automa- tique aux abonnés d’une bibliothèque. Pour chaque abonné, nous connaissons
son nom, prénom, le nombre de volumes empruntés ainsi que le nombre de jours écoulés
depuis l’emprunt. Nous devons alors manip- uler des centaines d’abonnés, chacun décrit par 4
valeurs, certaines de ces valeurs (nom, prénom) étant également une collection de valeurs
primitives (une séquence de caractères). Ce type de traitement est impossible en n’utilisant
que des types primitifs.
Tout comme des opérateurs spécifiques sont associés à chaque type primitif٨, il peut être
commode de définir des opérateurs ou méthodes permettant d’interroger ou transformer les
valeurs de ces objets.
Nous souhaitons disposer d’une méthode estEnRetard qui renvoie la liste des abonnés 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 nécessaires à la
création d’un tel programme. Avant toute chose, nous allons expliquer les mécanismes
communs à tout objet Java, c’est-à- dire, la façon dont un objet est stocké en mémoire et la
manière dont on l’instancie٨, c’est-à-dire la façon dont on réserve l’emplacement mémoire
nécessaire à l’objet. Nous verrons également comment fonctionnent les opérateurs de
comparaison sur les objets.
STOCKAGE DES OBJETS EN MÉMOIRE Tout comme les variables de type primitif, une variable
de type objet est associé à un emplacement mémoire de taille fixe qui contient une unique
valeur. Dans cet emplacement mémoire est stocké une valeur de type adresse qui indique
l’adresse٨ de l’emplacement mémoire où sont stockées, de manière contiguë, toutes les valeurs de
l’objet. Ainsi, la variable est liée aux données de manière indirecte : elle contient l’adresse à
laquelle on peut trouver les données. La variable qui est manipulée est en fait une référence٨ à
l’emplacement mémoire où se trouve l’ensemble des données.

adresse 0001 0012 maVariable

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

INSTANCIATION ٨ DES OBJETS L’instanciation d’un objet se fait à l’aide du mot clé new qui
“réserve” l’emplace- ment mémoire nécessaire pour stocker toutes les valeurs de l’objet, c’est-à-
dire un ensemble de cases mémoire contiguës, et renvoie l’adresse de la première case mémoire.

//déclaration e t instanciation
TypeObjet maVariable = new TypeObjet;

COMPARAISON DE DEUX OBJETS Lorsque l’on compare deux objets, à l’aide des opérateurs
==, <=, >=, < ou <, ce sont les adresses des objets qui sont comparées. Ainsi, l’opérateur ==
renvoie la valeur true si les deux variables font référence au même emplacement mémoire, donc
au même objet.

Programmation page 12 of
Java 20
 i f(var i ab l eA == variableB){
[Link] .println("Les deux variables font référence au même o b j e t ." ) ;
}

2. LES TABLEAUX
Les tableaux permettent de regrouper un ensemble de valeurs de même type.
1. TABLEAUX À 1 DIMENSION
Un tableau à 1 dimension est une collection linéaire d’éléments de même type. Chaque case d’un
tableau est identifiée par un indice et contient une valeur. Les indices d’un tableau commencent
à 0. Il s’ensuit, qu’un tableau de n éléments aura des indices compris entre 0 et n − 1.

Le type contenu dans les cases du tableau est choisi lors de la déclaration du tableau. En
revanche, la taille du tableau, ne fait pas parti de son type et sera définie lors de l’instanciation du
tableau. La déclaration d’un tableau se fait avec la syntaxe [].

i n t [ ] tabInt ; // Déclaration d’un tableau d’entiers

char[] tabChar ; // Déclaration d’un tableau de caractères

L’instanciation quant à elle précise la taille à réserver. Elle se fait avec le

mot clé new.

i n t [ ] tabInt ; // Déclaration d’un tableau d’entiers

tabInt = new i n t [ 1 0 ] ; // Instanciation d’un tableau de 10 entiers

A noter qu’il est possible, dans le cas de l’initialisation uniquement, de décrire tout le tableau
sous la forme d’une liste de valeurs. Cela initialise automatiquement le tableau avec le nombre
adéquate de cellules et les valeurs sont stockées dans les différentes cases.
i n t [ ] tabCinq = {12,33,44,0,50}; / / I n i t i a l i s a t i o n expresse

Une fois le tableau initialisé, on accède aux éléments du tableau à l’aide de la syntaxe suivante :
i n t i = 0;
i n t valeur1 = t a b C i n q [ i ] ; //Renvoie 12, l’élément d’ in dice 0
i n t valeur2 = tabCinq[4]; //Renvoie 50, l’élément d’ in dice 4

Une fois initialisé, il est possible à tout moment de connaître la taille d’un tableau (son nombre
de cases) à l’aide de la syntaxe suivante :

i n t t a i l l e = [Link]; //Renvoie 5 , l e 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, c’est
simplement un tableau dont chaque case contient un tableau à 1 dimension d’éléments. Par
récurrence, il est donc possible de définir un tableau à n dimensions. Du point de vue de la
notation, chaque dimension correspond à un couple de crochets supplémentaires au niveau du
type et des accès.

char[][] T ; // Déclaration d’un tableau à 2 dimensions de

caractères T = new char[3][5]; // Instanciation d’un tableau contenant
3 tableaux de
// 5 caractères chacun. T a donc 3 l ig n es e t 5 colonnes.
Programmation page 13 of
Java 20
Les multiples crochets sont lus de gauche à droite, ce qui correspond à regarder les tableaux
depuis le plus extérieur vers plus plus intérieur. Ainsi, [Link] renvoie 3, la taille du tableau
extérieur, T[0].length renvoie 5 la taille du tableau contenu dans la première case de T. C’est la
même convension qu’en mathématiques pour les matrices, d’abord les lignes, puis les colonnes.
Pour finir, comme chaque dimension est un tableau, il s’ensuit que chaque dimension est indicée
de 0 à n − 1.

45 154 58 78 31
12 15 45 37 789 i n t [ ] [ ] T = new in t[ 5]
457 21 78 89 365 [ 5] ; i n t i = T[ 0] [ 1] ;//i
vaut 154
87 154 58 78 42 i n t [ ] T1 = T[1];//T1 f a i t
référence
5841 4 45 6 47 //au tableau
[12,15,45,37,789]

Une matrice Sa représentation Le code

informatique a
Java
a
Image provenant de [Link]
Tableau_(structure_de_données)
3. MÉTHODES À PARAMÈTRES DE TYPE NON-PRIMITIF
En Java, le passage des paramètres à une méthode se fait par valeur. Dans le cas des types non-
primitifs, cette valeur est une adresse. Ainsi, une méthode ne pourra pas modifier l’adresse de la
variable, en revanche elle pourra modifier les valeurs stockées à cette adresse.
1. INSTANCIATION DES VARIABLES DE TYPE NON-PRIMITIF DANS UNE MÉTHODE
L’instanciation d’un objet à l’aide du mot clé new réserve l’emplacement mémoire nécessaire au
stockage des valeurs de l’objet et renvoie l’adresse. Ainsi, si cette instruction est effectuée dans
une méthode, il faudra penser à renvoyer cette adresse pour pouvoir manipuler l’objet en dehors
de la méthode.
Prenons l’exemple suivant où l’on souhaite dupliquer un tableau pour pourvoir le modifier tout
en con- servant l’original :
s t a t i c i n t [ ] copierTableau(int[] tableau)
{ i n t [ ] copie = new i n t[tab l eau. l en g th ];
f o r ( i n t i = 0 ; i < tab l eau. l en g th; i = i +
1) {
copie[i] = tableau[i];
}
return copie;
}
3.3.2 MODIFICATION DES VALEURS D’UNE VARIABLE DE TYPE NON-PRIMITIF DANS UNE
MÉTHODE
Lorsqu’on passe un objet en paramètre d’une méthode, c’est l’adresse de celui-ci qui est affectée
au paramètre formel de la méthode. Si la méthode modifie cette valeur (l’adresse), celle-ci ne
sera pas modifiée en de- hors (le contexte appelant) de la méthode. En revanche, lorsqu’on
modifie les valeurs de l’objet, on change directement les valeurs dans les cases mémoires de
l’objet et ce changement est alors définitif.
s t Prenons l’exemple
a t i c void suivant oùt l’on
permute(int[] a b , permute
i n t i , les
i n tvaleurs
j) des indices i et j du tableau :
{ i n t temp = t a b [ i ] ;
tab[i] = tab[j];
t a b [ j ] = temp;
}

i n t [ ] unTableau = { 1 , 2 , 3 , 4 , 5 } ;
permute(unTableau,0,4);
//unTableau contient l e s
valeurs [ 5 , 2 , 3 , 4 , 1 ]

Programmation page 14 of
Java 20
 3.4 LES OBJETS
Les différentes valeurs d’un objet son appelées attributs٨. Pour accéder à la valeur d’un attribut,
on utilise la syntaxe suivante :

//accès à l a valeur de l ’ a t t r i b u t
TypeAttribut monAttribut = [Link];
//affectation d’une valeur à l ’ a t t r i b u t
[Link] = valeurAttribut;

Il peut exister des méthodes spécifiques permettant d’interroger ou de transformer les valeurs des
attributs d’un objet. Pour appeler٨ une méthode sur un objet, on utilise la syntaxe suivante :

TypeRetour valeurRetour = [Link](parametre_1,.., parametre_N);

La méthode nomMethode permet d’accéder ou de modifier les valeurs des attributs de monObjet.

Si une méthode n’accède pas ou ne modifie pas les attributs de l’objet, on dit que cette
méthode est s t a t i c . La déclaration de la méthode est précédée du mot clé s t a t i c . L’appel de
la méthode se fait comme expliqué dans la section 2.

3.4.1 L’OBJET PRÉDÉFINI STRING

Il existe de nombreux objets prédéfinis en Java. Nous allons dans cette section présenter l’un
d’entre eux, incontournable : le type “chaîne de caractères”, appelé String . Cet objet est le
seul qui sera réellement manipulé en première année.
Une chaîne de caractères représente un texte. C’est une collection linéaire de caractères qu’il
n’est pas
possible de modifier une fois que l’objet a été instancié et initialisé. Ces opérations se font
selon la syn- taxe :
//Déclaration, instan ciation e t i n i t i a l i s a t i o n
String ecole = new String("INSA-Lyon");

Noter la présence de guillemets doubles pour distinguer les chaînes de caractères des éléments
du langage de programmation Java (mots du langage, nom de variables, nom de méthodes).

Comme le type String est très utilisé, une particularité de ce type est que l’on accède à l’attribut
principal de l’objet, la chaîne de caractères, comme si c’était un type primitif :

[Link] .println(ecole); // a f f i c h e "INSA-Lyon"

Les objets de type String sont fournis avec un grand nombre de méthodes permettant une
manipulation facile de ces objets. Les quatre principales méthodes permettent d’accéder à
chaque caractère de la chaîne, de connaître le nombre de caractères de la chaîne (sa
longueur), d’extraire une partie de la chaîne et de comparer le contenu de deux chaînes :
• char charAt(int n) : cette méthode prend en paramètre un entier n et renvoie le n + 1
ème carac- tère de la chaîne (le premier caractère est à l’indice 0 et le n + 1 ème à
l’indice n).
String ecole = new String("INSA-Lyon");
char c = [Link](2); //c contient l e caractère ’ S ’

• i n t length() : cette méthode renvoie la longueur de la chaîne de

caractères.

Programmation page 15 of
Java 20
 String ecole = new String("INSA-Lyon");
i n t longueur = e c o l e . l e n g t h ( ) ; // longueur contient 9

Notez les parenthèses de la méthode length , parenthèses absentes lorsque l’on appelle
cette méth- ode sur un tableau.

• String substring(int debut, i n t f i n ) : cette méthode renvoie un objet de type

String qui contient la sous-chaîne de caractères commençant à l’indice debut et se
terminant à l’indice fi n - 1 .

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

String v i l l e = ecol e. sub str in g ( 5, ecol e. l en g th()) ;
//équivaut à ecol e. sub str in g ( 5, 9 ) , v i l l e contient "Lyon"

• equals(String s ) : cette méthode renvoie une variable de type booléen qui vaut vrai si et
seulement si la chaîne de caractères s est la même que la chaîne de caractères de
l’objet sur lequel on appelle la méthode :

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

String ecoleB = new String("INSA-Lyon");
if([Link](ecoleB) == true){
//cette condition est s a t i s f a i t e
i f(ecol eA == ecoleB){
//cette condition n’ e s t pas
satisfaite,
//les deux objets n’ayant pas l a
même adresse
}
Une} opération fréquente consiste à “coller” bout-à-bout deux chaînes de caractères. On
appelle cela la concaténation. L’opérateur associé est + :

String v i l l e = new String("Lyon");

String ecole = new String("INSA");
String monEcole = ecole + " - " +
v i l l e ; // monEcole contient "INSA-
Lyon"
Il peut être nécessaire de pouvoir convertir un type primitif en une chaîne de caractères ou
réciproquement.
La conversion d’un type primitif en une chaîne de caractères se fait à l’aide de l’instruction

[Link](valeurPrimitive);

i n t valeur = 22;
String chaine = [Link] ueOf(val eur); // chaine contient "22"

La conversion d’une chaîne de caractères en un type primitif se fait à l’aide des instructions
suivante :

[Link](chaine); // renvoie une valeur de type i n t

[Link](chaine); // renvoie une valeur de type double
[Link](chaine);// renvoie une valeur de type boolean
[Link](i); // renvoie une valeur de type char

Programmation page 16 of
Java 20
 String chaine = "22" ;
i n t valeur = [Link](chaine); //valeur vaut 22

3.4.2 LES OBJETS

PROPRES
Cette section couvre une partie du programme de deuxième année.

On peut également définir ses propres objets. C’est ce que nous allons apprendre à faire ici,
en illustrant notre propos sur l’exemple du début de section.
LES CLASSES Les classes permettent de définir des types ou des catégories d’objets (on
pourra prendre la métaphore du moule des objets). Elles contiennent la description des objets,
(ex : les abonnés), c’est-à-dire qu’elles définissent les attributs et les méthodes communes aux
objets d’un certain type.
Les objets construits à partir de ces classes sont des instances. Les instances sont des éléments
créés depuis une classe : un abonné particulier. La syntaxe de déclaration d’une classe est :

c l a s s NomType {
// l e corps de l a cl asse vient i c i
// l e s attr ib uts
// l e s méthodes
}

On commence généralement par déclarer les attributs de la classe :

c l a s s Abonne {
//les a t t r i b u t s de l a cl asse Abonne
String nom;
String prenom;
i n t nbLivres;
i n t nbJours;
}

LE CONSTRUCTEUR Toute classe doit contenir au moins une méthode particulière appelé
constructeur. Cette méthode porte le même nom que la classe et est appelée lorsque l’on
instancie un nouvel objet. C’est cette fonction qui généralement initialise les valeurs des
attributs. Cette méthode ne renvoie aucune valeur.

c l a s s Abonne {
//les a t t r i b u t s de l a cl asse Abonne
String nom;
String prenom;
i n t nbLivres;
i n t nbJours;

Abonne() { // premier constructeur

nom = new S t r i n g ( " " ) ;
prenom = new S t r i n g ( " " ) ;
nbLivres = 0;
nbJours = 0;
age = 0;
}
Abonne(String nom, String prenom, i n t
nbLivres, i n t nbJours) {
// deuxième constructeur

Programmation page 17 of
Java 20
 [Link] = new
String(nom); [Link] = new
String(prenom); this.n bLivres =
nbLivres; [Link] = nbJours;
}
}

Il peut exister plusieurs constructeurs qui se distinguent par leurs paramètres formels. Ainsi, en
fonction des paramètres effectifs (nombre de paramètres ou types des paramètres) passés au
constructeur au mo- ment de l’appel, l’un ou l’autre des constructeurs sera appelé. Par
exemple, l’instruction Abonne() dé- clenchera l’exécution du premier constructeur, alors que
l’instruction Abonne("Dupond", "L uc", 4, 0) dé- clenchera l’exécution du second constructeur qui
instancie les attributs aux valeurs correspondant à l’abonné Luc Dupond.

Le mot clé t h i s permet de spécifier que l’attribut que l’on référence est celui de l’objet en
cours de con- struction. En effet, l’expression [Link] = nom; signifie que l’attribut nom de
l’objet en cours de con- struction ([Link]) prend la valeur du paramètre formel nom de type
String du constructeur.
EXEMPLE Regardons maintenant comment on peut construire notre programme qui indique les
abonnés qui ont emprunté un livre depuis plus de 21 jours. Nous venons de voir la classe Abonne
qui contient les attributs d’un abonné. Ajoutons une méthode renseigneUnAbonne qui permet de
spécifier les nouvelles valeurs des attributs :

void renseigneUnAbonne(String nom, String prenom, i n t nbLivres, i n t nbJours)

{ [Link] = new String(nom);
[Link] = new String(prenom);
this.n bLivres = nbLivres;
[Link] = nbJours;
}

La classe EnsembleDesAbonnes va contenir l’ensemble des abonnés de la bibliothèque. Ses

attributs sont alors un tableau d’abonnés (lesAbonnes) et un entier qui indique le nombre
d’abonnés. Son construc- teur alloue l’emplacement mémoire nécessaire au tableau
lesAbonnes et instancie chacun des abonnés :

c l a s s EnsembleDesAbonnes {
//Attributs de l a cl asse EnsembleDesAbonnes
Abonne[] lesAbonnes;
i n t nbAbonnes;
//Constructeur
EnsembleDesAbonnes(int nbAbonnes) {
lesAbonnes = new
Abonne[nbAbonnes];
[Link] = nbAbonnes;
int i ;
for(i = 0; i <
[Link]; i++) {
lesAbonnes[i] =

new Abonne(); //
Les attributs deinstancie chaqueêtre
la classe doivent abonné
initialisés dans le constructeur, et en particulier, les
}
attributs de type non-primitifs doivent être instanciés via le mot clé new qui réserve
}
l’emplacement mémoire de cet attribut.
Enfin, la méthode estEnRetard, qui renvoie la liste des abonnés dont le dernier emprunt a été
effectué il y a plus de 21 jours, compte le nombre d’abonnés en retard, puis crée un nouvel objet
EnsembleDesAbonnes

Programmation page 18 of
Java 20
pouvant contenir tous les abonnés en retard, puis recopie l’adresse des abonnés en retard dans
l’objet re s u l t a t :
EnsembleDesAbonnes estEnRetard()
{ int i ;
i n t nbEnRetard = 0;
for(i = 0; i <
[Link]; i++) {
i f ( (lesAbonnes[i].nbJoursEmprunts > 21)
&&(lesAbonnes[i].nbLivresEmpruntes > 0)) {
nbEnRetard = nbEnRetard + 1;
}
}

EnsembleDesAbonnes re s u l t a t = new Abonnes(nbEnRetard); i n t

j = 0;
f o r ( i = 0 ; i < [Link]; i++) {
i f ( (lesAbonnes[i].nbJoursEmprunts > 21)
&&(lesAbonnes[i].nbLivresEmpruntes > 0)) {
resul tat .l esAbonn es[j] =
[Link][i];
j = j + 1;
}
}
return r e s u l t a t ;
}
Le tableau lesAbonnes de l’objet resultat contient des références vers les abonnés du tableau
lesAbonnes de l’objet en cours de définition.

Enfin, la méthode main de la classe EnsembleDesAbonnes instancie un objet mesAbonnes

comportant 4 abonnés, et appel la méthode estEnRetard sur cet objet qui renvoie un nouvel
objet abonnésEnRetard qui contient un tableau de références vers les abonnés en retard :

public s t a t i c void main ( S t r i n g [ ] args) {

EnsembleDesAbonnes mesAbonnes = new EnsembleDesAbonnes(4);
[Link][0].renseigneUnAbonne("Dupond", " L u c " , 4 , 0 );
[Link][1].renseigneUnAbonne("Martin", "Jeanne",1,30);
[Link][2].renseigneUnAbonne("Vaus", "Paul ",2,22);
[Link][3].renseigneUnAbonne("Bon", "J ean", 0, 27 );
EnsembleDesAbonnes abonnesEnRetard = [Link]();

// abonnesEnRetard contient l e s références à Jeanne Martin e t Paul

Vaus

}
4 GLOSSAIRE
ADRESSE : Indique la localisation d’une information dans la mémoire.
AFFECTATION : L’affectation est l’opération qui attribue une valeur à une variable. En Java cet
opérateur est ’=’. Il se lit “prend la valeur de”.
APPEL DE MÉTHODES : L’appel d’une méthode exécute le bloc d’instructions de la méthode.
L’appel se fait en écrivant le nom de la méthode (en respectant la casse) suivie d’une paire de
parenthèses avec éventuellement une liste de paramètres effectifs٨ séparés par une virgule. Au
moment de l’exécution de l’appel, les valeurs des paramètres effectifs sont affectées aux
paramètres formels٨, selon l’ordre dans lequel ils apparaissent. Si le type renvoyé par la méthode
est différent de void , l’appel de la méthode doit être affecté à une variable

Programmation page 19 of
Java 20
de même type.
ATTRIBUT : Les attributs sont des variables associées à un objet.
CONSOLE : La console est une interface textuelle qui permet de demander à l’ordinateur
d’exécuter des pro- grammes. Elle est souvent considérée à tord comme étant obsolète. Pour
autant il s’agit d’une des interfaces les plus puissantes à utiliser puisque l’on peut directement
programmer dans la console. De plus, il s’agit bien souvent de l’unique façon d’accéder à 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) exécutable par l’ordinateur.
DÉCLARATION : Avant de pouvoir utiliser une variable ou une méthode, il faut la déclarer. La
déclaration d’une variable associe un type à un nom et réserve un emplacement mémoire dans
lequel est stockée la valeur de la variable, si son type est primitif, ou l’adresse du début de la
plage mémoire où est stocké la variable si son type est non primitif. La définition d’une
méthode s’appelle également déclaration. Elle consiste à définir le nom de la méthode, le type
de la valeur retournée, la liste de ses paramètres formels et son bloc d’instructions.
DÉCRÉMENTER : L’opération de décrémentation s’applique à une variable de type entier. Elle
consiste à retirer une valeur entière à la variable, classiquement la valeur 1 ( x = x - 1).
EXÉCUTION : L’exécution est le processus par lequel une machine met œuvre les instructions d’un
programme informatique.
INCRÉMENTER : L’incrémentation est l’opération qui consiste à ajouter une valeur entière fixée à
une variable de type entier. La valeur ajoutée est le plus souvent la valeur 1 ( x = x + 1).
INITIALISATION : Lorsqu’on déclare une variable, un emplacement mémoire est associé à la
variable. Or, celui-ci contient une valeur quelconque. Il est nécessaire d’initialiser la valeur de
la variable, c’est-à-dire de réaliser une première affectation d’une valeur à la variable, afin que
cette dernière contienne une valeur appropriée.
INSTANCE DE CLASSE : On appelle instance d’une classe, un objet avec un comportement
(méthodes) et un état (attributs), tous deux définis par la classe. Il s’agit donc d’un objet
constituant un exemplaire de la classe.
INSTANCIER : Réserver l’espace mémoire nécessaire pour stocker toutes les valeurs de l’objet.
De manière plus générale, fabriquer un exemplaire d’un élément à partir d’un modèle qui lui sert
en quelque sorte de moule.
OPÉRATEUR : Un opérateur est une fonction spéciale dont l’identificateur s’écrit avec des
caractères non autorisés pour les identificateurs ordinaires (les variables). Il s’agit souvent des
équivalents aux opérateurs mathématiques pour la programmation informatique.
PARAMÈTRES EFFECTIFS : Il s’agit de valeurs fournies à une méthode lors de son appel. Ces
valeurs peuvent être des constantes ou des variables.
PARAMÈTRES FORMELS : On parle aussi de paramètre muet. Il s’agit de variables utilisées
dans le bloc d’instructions d’une méthode. Ces paramètres permettent de décrire comment les
données en entrée de la méthode sont transformées par celle-ci.
RÉFÉRENCE : Une référence est une valeur qui permet l’accès en lecture et/ou écriture à une
donnée en mémoire. Une référence n’est pas la donnée elle-même mais seulement une
information de localisation, l’adresse de la valeur dans la mémoire.
TYPES PRIMITIFS : Les types primitifs (entier, flottant, booléen et caractère) permettent de
manipuler di- rectement les données les plus courantes et ont la particularité d’être accessibles
directement en mémoire.
TYPES NON PRIMITIFS : Les types non primitifs permettent d’associer plusieurs valeurs à
une variable. L’emplacement mémoire associé à la variable permet de stocker l’adresse de
l’emplacement mémoire où se trouvent ses valeurs. La variable est ainsi liée à ses valeurs de
manière indirecte.

Programmation page 20 of
Java 20