Programmation Orientée

Objet (JAVA)
Pr. IALA Imad
Imad.iala01@[Link]
 Objectif du cours
Les objectifs du cours sont d’apprendre les bases de la programmation en utilisant le langage Java
comme support. Ces bases sont pratiquement communes avec la majorité des langages de
programmation.
Les notions étudiées seront les suivantes :
 variable, type, expression
 l’instruction conditionnelle (if)
 les boucles (for, while,…)
 les tableaux
 les sous-programmes (méthode, fonction, procédure)
 en conclusion du cours, une ouverture vers la programmation objet avec l’utilisation
d’objets de deux classes prédéfinies: String et ArrayList.
Le but du cours est de vous donner non seulement des connaissances, mais également une
compétence: celle de réaliser concrètement de petits programmes java utilisant les constructions
énumérées ci-dessus et de les exécuter sur un ordinateur.
 Programme source et programme cible

Chaque programme a deux formes différentes : une forme qui est le

programme tel qu’il est écrit par le programmeur et l’autre est le programme
tel qu’il est exécuté par l’ordinateur.
Ces deux formes sont différentes : le programme que l’on écrit a une forme
textuelle. On peut le lire : il contient des mots-clés et des noms qui ont un
sens. Mais l’ordinateur ne sait pas exécuter directement ce texte.
Le programme qui s’exécute a une forme binaire : la fameuse suite de 0 et de
1 qui est copiée dans la mémoire de l’ordinateur.
 Traduction : compilation et interprétation
Pour passer d’une forme à l’autre, il faut une traduction qui est exécutée automatiquement par un
programme. Il existe deux sortes de traduction : la traduction réalisée une fois pour toute par un
programme appelé un compilateur ou la traduction réalisée à chaque exécution par un logiciel
appelé interpréteur.
Le langage Java que nous utilisons mixe les deux procédés avec utilisation d’un compilateur puis
d’un interpréteur.
Le langage des programmes écrits par les programmeurs s’appelle le langage source de
l’ordinateur. C’est le langage Java qui est unique pour tous les ordinateurs du monde. Le langage
des programmes exécutés s’appelle le langage cible et il est différent pour chaque type de
processeur, d’architecture et de système d’exploitation employé.
Dans le cas de Java, il y a un troisième langage qui est celui des programmes compilés par le
compilateur java. On l’appelle langage intermédiaire, langage de la machine virtuelle Java. Il est
unique pour tous les ordinateurs mais les machines ne savent pas l’exécuter directement. C’est
pour cela qu’il y a besoin d’un interpréteur qui interprète le code intermédiaire : la machine
virtuelle.
 Etapes pour la création d’un programme
La création de programmes nécessite l’utilisation de différents outils qui peuvent soit être des
outils séparés, soit des outils regroupés dans un unique logiciel appelé environnement de
développement intégré (IDE en anglais).
Il y a au minimum trois outils : un éditeur de texte, un compilateur et un interpréteur.
Le compilateur prend en entrée le fichier texte contenant le programme source. Si le programme
source est correct, le compilateur crée un ou plusieurs fichiers binaires contenant le programme
en langage intermédiaire. Ces fichiers ont l’extension .class.
L’interpréteur prend en entrée un fichier contenant du code intermédiaire et exécute le code
correspondant. Pour ce faire, il traduit une ligne de code, puis l’exécute immédiatement avant de
passer à la suivante.
Pour ce cours, nous vous conseillons d’utiliser un environnement intégré professionnel : NetBeans
IDE 8.2.
 Premier programme
• Le programme suivant a pour but de calculer et afficher la conversion en dirhams d’une
somme en euros saisie au clavier.
 Structure générale d’un programme Java
Ce programme a un squelette identique à tout autre programme Java. Le voici :

Tout programme Java est composé au minimum d’une classe (mot-clé class) dite principale, qui
elle même, contient une méthode de nom main. Les notions de classe et de méthode seront
abordées plus tard.
public, class, static, void : sont des mots réservés c’est-à-dire qu’ils ont un sens particuliers pour
Java. On ne peut donc pas les utiliser comme nom pour des classes, des variables, etc...
La classe principale : celle qui contient la méthode main. Elle est déclarée par public class
Nom_classe. C’est vous qui choisissez le nom de la classe. Le code qui définit une classe est
délimité par les caractères { et }.
 Structure générale d’un programme Java

Nom du programme : Le nom de la classe principale donne son nom au programme tout entier et
doit être également celui du fichier contenant le programme, complété de l’extension .java
La méthode main : obligatoire dans tout programme Java : c’est elle qui “commande” l’exécution.
Définie par une suite de déclarations et d’actions délimitées par { et }. Pour l’instant, et jusqu’à ce
que l’on sache définir des sous-programmes, c’est ici que vous écrirez vos programmes.
Par convention, le nom d’une classe commence par une majuscule. Ce n’est pas une obligation
absolue, mais il est fortement conseillé de s’y conformer.
 Premier programme
• Voyons ligne par ligne le sens des instructions du programme.
 Les types de variables primitifs & constantes
Types de base
Les types de base en Java, ou types primitifs, ou types simples, sont pratiquement les mêmes
qu’en langage C :
▪ char : 16 bits (un seul caractère : '…')
▪ short : 16 bits (entier signé)
▪ int : 32 bits (entier signé)
▪ long : 64 bits (entier signé)
▪ float : 32 bits (réel)
▪ double : 64 bits (réel)
▪ byte : 8 bits (entier signé)
▪ boolean : 1 bit (true / false)
Remarque
▪ En Java le type String (chaîne de caractères : "…") est un type référence et non un type simple.
▪ Par convention, les noms de tous les types référence doivent commencer par une lettre
majuscule.
 Les types de variables primitifs & constantes
Noms de variables

Le nom d’une variable

▪ ne doit pas contenir d’espaces,
▪ ne doit pas commencer par un
symbole (sauf le symbole _ ou $),
▪ ne doit pas être un mot réservé
de Java.
 Les types de variables primitifs & constantes
Noms de variables

Remarque
 La déclaration et l’initialisation se font de la même manière qu’en langage C,
 le cas où une valeur numérique est affectée à un type dont la taille est inférieure, dans ce cas il
s’agit d’une erreur de compilation
 Les réels sont par défaut des « double », sauf s’ils sont suivis d’un ‘f’ ou ‘F’ pour indiquer qu’il
s’agit d’un « float »
 L’utilisation de variables non initialisées est une erreur de compilation.
 Les types de variables primitifs & constantes
Constante
▪ Les constantes sont déclarées avec le mot clef final,
▪ le reste de la syntaxe est le même que pour les autres variables,
▪ elles doivent être initialisées à la déclaration,
▪ leur contenu ne peut pas être modifié.
int a = 5;
int x = a - 15;
int n1, n2;
int n3 = 100, n4 = -2;
• short b = (short) a;
• ici un « cast » est nécessaire pour éviter une erreur de compilation. Le casting (ou trans-typage)
est l’action de changer le type d’une valeur vers le type de la variable d’affectation (b). le
langage java est un langage très typé, à l’inverse d’autres langages comme php ou javascript.
 Les types de variables primitifs & constantes
Constante

float y = 5.06F;
double z = 0.23;
boolean test = (y >= z);
char s = 'A';
char p = '*';
final int k = 15;
k = 16;
 Les types références

Les types références sont :

▪ les types références prédéfinis de Java (String, Integer, List, …),

▪ les types créés par le programmeur,
▪ les tableaux.

Pour les types simples, la zone mémoire allouée contient la valeur associée au nom de la variable,
tandis que pour les types références ou objets (voir prochain chapitre), cette zone mémoire
contient l’adresse mémoire (en hexadécimal) où sont stockés les champs de cet objet.
 Les opérateurs arithmétiques & logiques
Opérateurs arithmétiques
 Les opérateurs arithmétiques & logiques
Opérateurs arithmétiques
 Les opérateurs arithmétiques & logiques
Expression logique

Une expression logique est une expression qui n’a comme valeur possible que l’une des valeurs
Vrai ou Faux.
Exemple :

byte x = 5;
byte y = 2;
bool z = (x == y);

Un opérateur logique est un opérateur qui agit sur des variables et des expressions logiques.
 Les opérateurs arithmétiques & logiques
Opérateurs logique
 Afficher / lire des données
Définition : Imprimer des données vers « le fichier de sortie standard » du programme
Comme on le remarque dans le premier exemple, l’instruction [Link](…) sert à
afficher toutes sortes de données (numériques, chaînes de caractères, …), tout en passant à la
ligne suivante.
▪ System : cette classe utilitaire permet, entre autres, d'utiliser l'entrée standard (le clavier) et la
sortie standard (l’écran).
▪ out : objet de type PrintStream (flux d’écriture), et attribut de la classe System, cet attribut gère
la sortie standard, qui est par défaut : le périphérique d’affichage (l’écran).
▪ println : méthode de l’objet out qui écrit dans la console les informations passées en paramètre
(chaînes de caractères, nombres, …)
▪ print : idem que println, sans retour à la ligne.
▪ Pour faire une concaténation entre des chaînes de caractères, ou entre chaînes et variables, on
utilise l’opérateur « + »
Les notions de programmation orientée objets (Classes, Objets, Méthodes, …) seront détaillées
dans le prochain chapitre.
 Afficher / lire des données
Définition : Lire des données depuis « le fichier d’entrée standard » du programme

▪ Créer un objet de type Scanner, classe utilisée pour lire des informations depuis différentes
sources.
▪ Le constructeur de la classe Scanner doit prendre un objet de type InputStream (flux d’entrée),
qui doit être [Link], autre attribut de la classe System, qui représente l’entrée standard, qui
est par défaut : le clavier.
la classe Scanner se trouve dans le package : [Link], toutes les classes java sont organisées dans
des bibliothèques, logées dans des dossiers appelés en java « packages »
[Link] sc = new Scanner([Link]);
▪ Utiliser les méthodes nextInt( ), nextDouble( ), nextLine( ) de l’objet Scanner, … pour lire un
entier, un réel, du texte, …
 Afficher / lire des données
Définition : Lire des données depuis « le fichier d’entrée standard » du programme
 Les structures conditionnelles
Structure optionnelle
Une structure optionnelle est constituée d’un bloc d’instructions (une ou plusieurs instructions),
que l’ordinateur ne doit exécuter que si une condition est vérifiée, sans aucune autre alternative.
Si la condition n’est pas vraie, le bloc d’instructions est ignoré.
Syntaxe de base :
if(condition booléenne) {
instructions;
}

Remarques
▪ La condition booléenne peut être un booléen, ou un ensemble de booléens combinés avec des
opérateurs logiques.
▪ Pour une bonne lisibilité, l’indentation du code est nécessaire.
▪ Si un bloc IF ne contient qu’une seule instruction, alors les accolades ne sont pas obligatoires.
 Les structures conditionnelles
Structure optionnelle
▪ Un bloc IF peut contenir un autre bloc IF :

if(condition booléenne) {
instructions
if(condition booléenne) {
instructions
}
instructions
}
 Les structures conditionnelles
Structure alternative IF/ELSE
Une structure alternative IF / ELSE sert à exécuter un bloc d’instructions si une condition est vraie,
sinon on exécute un autre bloc d’instructions.
Syntaxe de base :
if(condition booléenne) {
bloc 1
} else {
bloc 2
}
▪ Si un bloc ELSE ne contient qu’une seule instruction, alors les accolades ne sont pas obligatoires :
if(condition booléenne)
Instruction1
else
instruction2
Un bloc ELSE peut lui aussi contenir un autre bloc IF, ou IF / ELSE
 Les structures conditionnelles
Structure alternative SWITCH-CASE
Supposons qu’on soit obligé de faire un test comme celui-là :

if(x == 0) {
Instruction1;
} else {
if(x == 1) {
instruction2;
} else {
if(x == 2) {
instruction3;
} else {
if(x == 3) {
instruction4;
} else {
instruction5;
}
}
}
}
 Les structures conditionnelles
Structure alternative SWITCH-CASE
La structure alternative SWITCH – CASE est un moyen élégant et efficace de réaliser le programme
précédent d’une manière plus simple.
Syntaxe de base :

switch(variable) {
case valeur_1 :
traintement_1;
break;
case valeur_2 :
traintement_2;
break;
case valeur_3 :
traintement_3;
break;
case ……
default :
traintement_par_défaut;
break;
}
 Les structures conditionnelles
Structure alternative SWITCH-CASE
• Tout comme les blocs if et else, un bloc case ou default peut tout contenir (des instructions, des
structures if, if/else, switch-case, …)
• Dans un bloc case ou default les accolades ne sont pas obligatoires, même quand le bloc
contient plusieurs instructions.
• L’instruction break sert à sortir de la structure switch quand l’un des blocs case est vérifié. Mais
elle n’est pas obligatoire selon la syntaxe de java.
• Le bloc default n’est pas obligatoire.
• Quand plusieurs blocs case contiennent le même traitement, ils peuvent être « rassemblés ».
Syntaxe :
case valeur_1 :
case valeur_2 :
case valeur_3 :
traintement_3;
break;
• Le test switch, peut être appliqué aux variables de types entier, caractère, ou chaine de
caractère.
 Les structures conditionnelles
Structure alternative ? :
Utilisée pour les affectations soumises à un test if/else.
Syntaxe de base :

variable = (condition booléenne) ? valeur_1 : valeur_2;

Traduction en utilisant if/else :

if(condition booléenne)
variable = valeur_1
else
variable = valeur_2;
 Les structures itératives
Une structure répétitive (ou itérative, appelée aussi boucle) oblige le programme à répéter un
bloc d’instructions tant que la condition de répétition est vraie.
Exemple : Somme des entiers de 1 à 10.
On se propose de calculer la somme des nombres entiers entre 1, 2, 3, …, 10.
Il nous faudra donc une variable qui sera nommée compteur pour faire le comptage de 1 à 10, et
une autre som pour faire la somme. Code sans structure itérative :
byte compteur = 1, som = 0;
som += compteur;
compteur++; // compteur vaut 2
som += compteur;
compteur++; // compteur vaut 3
…
…
som += compteur;
compteur++; // compteur vaut 10
[Link]("valeur de la somme : " + som);
La partie répétée sera exécutée tant que compteur <= 10
Bien sûr, il n’est pas pratique de répéter ces instructions, d’où l’utilité des boucles.
 Les structures itératives
La boucle WHILE
Syntaxe de base :
while(condition booléenne) {
instructions
incrémentation / décrémentation
}
 De même que les autres structures déjà étudiées (if, else, …), si un bloc while ne contient
qu’une seule instruction, alors les accolades ne sont pas obligatoires.
 Un bloc peut lui aussi contenir des structures alternatives (if, if/else, switch, …), itératives, …
 La boucle while continue de s’exécuter tant que la condition booléenne est vraie. Si la condition
booléenne est fausse, les instructions de la boucle ne seront pas exécutées.
 Il est essentiel que la condition booléenne devienne fausse après un certain nombre
d’itérations, sinon on parle de « boucle infinie ». Une boucle infinie conduit à un plantage du
programme.
 Les structures itératives
La boucle WHILE
L’utilisation de l’instruction break permet d’arrêter une boucle, même si la condition booléenne
est encore vraie. Syntaxe de base :
while(condition booléenne) {
instructions
if(autre condition booléenne) {
break;
}
incrémentation / décrémentation
}
Exemple : Somme des entiers de 1 à 10.
 Les structures itératives
La boucle DO-WHILE
Syntaxe de base :
Do {
instructions
incrémentation / décrémentation
} while(condition booléenne);
La boucle do-while a le même effet que la boucle while, sauf que la boucle do-while vérifie la
condition d’itération à la fin et non au début. Donc même si la condition est fausse, les
instructions seront exécutées au moins une fois.
La boucle do-while est toujours suivie d’un point-virgule.
Exemple : Somme des entiers de 1 à 10.
 Les structures itératives
La boucle FOR
Syntaxe de base :
for(initialisation; condition booléenne; incrémentation/décrémentation) {
instructions
}
 La boucle for a le même effet que la boucle while.
 La déclaration de la boucle for doit obligatoirement contenir ces 3 éléments :
o L’initialisation du compteur (ou bien déclaration et initialisation),
o Condition booléenne de répétition de la boucle,
o L’instruction d’incrémentation ou décrémentation du compteur.
Exemple : Somme des entiers de 1 à 10.
 Les tableaux : Tableaux de dimension 1
Définition
• Un tableau est une structure regroupant plusieurs valeurs de même type, chacune étant
stockée dans un espace particulier appelé une case du tableau.
• On peut traiter un tableau comme un tout, ou case par case. Traité comme un tout, on pourra le
stocker dans une variable, le passer en paramètre ou le donner en résultat d’un calcul. Chaque
case est désignée individuellement via son indice, qui correspond à sa position dans le tableau,
et peut être traitée comme variable individuelle : on pourra consulter sa valeur, la modifier, etc.
 Les tableaux : Tableaux de dimension 1
Spécificités des tableaux
Un tableau n’existe pas tant qu’on ne l’a pas créé. Les valeurs des types primitifs de Java (int,
double, boolean, char) existent sans qu’il soit nécessaire de les créer. Il n’est pas nécessaire de
créer la valeur 17 ou la valeur true.
Pour les tableaux, c’est différent : il faut les créer pour qu’ils existent et il y a un opérateur pour le
faire : l’opérateur new.
Un tableau est une valeur d’un type. Ce type dépend de ce que l’on met dans le tableau. Pour
chaque type qui existe en Java, on peut créer un tableau qui contient plusieurs valeurs de ce type,
chacune étant stockée dans une case du tableau.
Le type d’un tableau d’entier se note int[], celui d’un tableau de char se note char[]. Plus
généralement, si un type Java se note T, le type des tableaux contenant une valeur de ce type
dans chaque case se note T[].
Un type tableau, comme int[] par exemple, peut servir à déclarer une variable. int[] var;
Cette déclaration ne crée pas de tableau. Elle crée un nom que l’on pourra utiliser pour désigner
un tableau.
 Les tableaux : Tableaux de dimension 1
Spécificités des tableaux
Un tableau a une taille fixée lors de sa création, c’est le nombre de cases qu’il contient. Une fois
créé, le tableau ne peut plus jamais changer de taille : on ne peut ni lui ajouter ni lui enlever de
cases.
Pour créer un tableau, on utilise new suivi du type des éléments et du nombre de cases entre
crochets.
• var = new int[10];
L’expression new int[10] crée un nouveau tableau de 10 cases, chaque case pouvant contenir un
nombre entier, et elle renvoie ce tableau. Le reste de la ligne est une affectation normale qui
permet de donner une valeur à la variable var.
A partir de ce moment, il est possible d’utiliser chaque case du tableau pour y stocker une valeur.
Chaque case se comporte comme une variable de type int.
• var[0]=10;
• var[1]=tab[0]+1;
 Les tableaux : Tableaux de dimension 1
Déclaration et création
En Java, avant d’utiliser un tableau, il faut :
1. Déclarer une variable de type tableau (symbole []), en indiquant le type T de ses futures cases ;
T [] tab;
2. Créer explicitement la structure du tableau en mémoire (opérateur new), en donnant sa taille
et le type T de ses éléments. Cette taille ne pourra plus changer : en Java les tableaux sont de
taille fixe.
tab = new T[taille];
3. L’initialisation des cases avec des valeurs par défaut, est réalisée implicitement par l’opération
de création.
 Les tableaux : Tableaux de dimension 1
Déclaration
L’instruction :
T [] tab;
Ici, on déclare une variable tab destinée à contenir un tableau, dont les cases seront de type T.
Après déclaration, la variable tab existe, mais n’est pas encore initialisée à un tableau.
Exemples :
int [] tabNum; // tabNum est un tableau avec cases de type int
double [] t; // t est un tableau avec cases de type double
String [] m; // m est un tableau avec cases de type String
tabNum[0] = 5; // provoque une erreur: le tableau n’existe pas
Après ces déclarations, les variables tabNum, t et m existent, mais pas encore la suite de cases
que chacune d’entre elles pourra désigner. Par exemple, il est impossible de modifier la première
case de tabNum (notée tabNum[0]) : elle n’existe pas encore. Le compilateur signale l’erreur :
[Link]: variable tabNum might not have been initialized tabNum[0] = 5;
 Les tableaux : Tableaux de dimension 1
Création
L’opération de création : new T[n]; réalise la création et l’initialisation d’un tableau de n cases de
type T :
1. Allocation en mémoire d’un espace suffisant pour stocker n cases de type T.
2. Initialisation des cases du tableau avec des valeurs par défaut.
Les tableaux en Java sont de taille fixe. Une fois le tableau créé, l’espace qui lui est alloué en
mémoire ne peut pas changer. Par exemple, il est impossible d’ajouter ou d’enlever des cases
d’un tableau.
Exemple 1 : Déclaration, puis création du tableau tab avec trois entiers.
int [] tab; // Declaration
tab = new int[3]; // Creation
tab[0] = 7;
 Les tableaux : Tableaux de dimension 1
Création
Après l’instruction de création new, la variable tab est initialisée à un tableau contenant trois
entiers. Après l’affectation tab[0] = 7, la structure du tableau en mémoire est :

Il est possible de réunir la déclaration et la création d’un tableau en une seule instruction. On
pourra ainsi déclarer et créer le tableau de l’exemple 1 par :
Exemple 2 : Déclaration et création en une seule instruction.
int [] tab = new int[3];
 Les tableaux : Tableaux de dimension 1
Initialisation par une liste de valeurs
Lorsqu’un tableau est de petite taille, il est possible de l’initialiser en donnant la liste des valeurs
de chaque case. On utilise la notation {v_0, v_1, . . ., v_n}, où v_i est la valeur à donner à la case i
du tableau.
Nous reprendrons souvent cette notation pour regrouper en une seule instruction la déclaration,
la création et l’initialisation d’un tableau.
Exemple 3 : Déclaration, création et initialisation d’un tableau en une seule instruction.
int [] tab = {1,9,2,4};
Il est alors inutile de réaliser une création explicite via new : elle se fait automatiquement à la
taille nécessaire pour stocker le nombre des valeurs données.
Remarque:
int[] x;
x = {15, -24, 5}; // erreur de compilation
La déclaration et initialisation. doivent se faire en une seule instruction !!
 Les tableaux : Tableaux de dimension 1
Valeurs par défaut à la création
Lors de la création, les cases d’un tableau sont initialisées avec des valeurs par défaut :
 les cases boolean sont initialisées à false.
 les cases numériques sont initialisées à 0.
 les cases char sont initialisées au caractère nul ’\0’.
 les cases référence sont initialisées à la valeur null (référence nulle).
Longueur d’un tableau
La taille ou longueur d’un tableau est le nombre n des cases qu’il contient. Supposons que tab
désigne un tableau de taille n. On peut obtenir sa longueur par la notation [Link]. Les indices
du tableau tab sont alors compris entre 0 et [Link]-1. Cette notation sera souvent employée
pour fixer la valeur maximale qui peut prendre l’indice d’un tableau.
 Les tableaux : Tableaux de dimension 1
Accès aux cases
L’accès aux cases de tab n’a de sens que pour les indices dans l’intervalle [0,. . ., [Link]-1].
 Si i est un indice compris dans cet intervalle : tab[i] : est un accès à la case de position i dans
tab. On peut consulter ou modifier cette valeur dans le tableau. Exemple : tab[i] = tab[i] + 1;
 Accès en dehors des bornes du tableau tab : si j n’est pas compris entre 0 et [Link]-1,
l’accès tab[j] provoque une erreur à l’exécution : l’indice j et la case associée n’existent pas dans
le tableau. Java lève l’exception ArrayIndexOutOfBoundsException.
Parcourir un tableau
• Le numéro de case peut être cherché dans une variable. Il arrive souvent qu’on utilise une
boucle for pour effectuer une opération sur chacune des cases d’un tableau. On utilise alors la
variable de la boucle for pour désigner un numéro de case. A chaque tour de boucle, l’opération
est effectuée sur une des cases du tableau et la boucle est parcourue autant de fois qu’il y a de
cases dans le tableau.
 for(i = 0 ; i <= [Link]-1 ; i += 1)
 for(int elem : tab)
 Les tableaux : Tableaux de dimension 1
Exercice 1
Demander à l'utilisateur de saisir le nombre d’élèves N d’une classe. Ensuite demander les notes
d’examen de ces N élèves, qui seront stockées dans le tableau notes. Le programme doit ensuite
afficher le nombre d'élèves qui ont eu la moyenne.
Exercice 2
Ecrire un programme qui demande à l'utilisateur de saisir 5 entiers qui seront stockés dans un
tableau T_ENTIER. Le programme doit ensuite afficher la valeur du plus grand élément de ce
tableau.
Indication : stocker le 1ier élément dans une variable plusGrand, comparer ensuite tous les
autres éléments un par un avec plusGrand, chaque fois qu’un élément est supérieur à plusGrand,
plusGrand devient cet élément-là.
 Les tableaux : Tableaux de dimension 1
Exercice 3
Lire les éléments d’un tableau de chaînes de caractères de taille 5 depuis le clavier, et afficher
ensuite celle qui contient le plus de caractères.
Indication : s’inspirer de l’exercice précèdent et utiliser la méthode length() de la classe String.
Exercice 4
Ecrire un programme qui lit les valeurs de 2 tableaux de chiffres A et B de tailles N et M lues au
clavier, et qui regroupe les éléments de A et B dans un tableau C. Afficher ensuite les éléments de
C à la manière de l’exemple 18.
Exemple :
 Les tableaux : Tableaux de dimension 1
Exercice 5
Ecrire un programme qui demande à l’utilisateur de taper 5 chiffres qui seront stockés dans un
tableau T, le programme doit remplir un autre tableau R avec les éléments de T mais à l’envers.
Afficher ensuite les éléments de R.
Exemple :
 Les tableaux : Tableaux de dimension 1
Exercice 6
Ecrire un programme qui lit une chaîne de caractères S et qui teste si oui ou non cette chaine est
un palindrome.
Indications :
 Un palindrome est une chaîne de caractères qui se lit de la même manière aussi bien de
droite à gauche que de gauche à droite. Ex. "kayak", "OTO", …
 Transférer les caractères de S dans un tableau de caractères T en utilisant la méthode
toCharArray de la classe String
 Créer un autre tableau R et s’inspirer de l’exercice précédent pour chercher si S est un
palindrome.
 La taille d’un tableau est indiquée par l’attribut de tableaux length
 Les tableaux : Tableaux de dimension 1
Exercice 7
Ecrire un programme qui demande à l’utilisateur de taper N entiers qui seront stockés dans un
tableau T. Le programme doit trier le tableau par ordre croissant et ensuite les afficher.
Indication (algorithme de tri « bulle »): On parcourt le tableau en comparant T[0] et T[1] et en
échangeant ces éléments s'ils ne sont pas dans le bon ordre. On recommence le processus en
comparant T[1] et T[2],... et ainsi de suite jusqu'à T[N-1] et T[N-2]. Lors de chaque itération, on
compte le nombre d'échanges effectués. On fait autant d’itérations que nécessaire jusqu'à ce
que le nombre d'échanges soit 0 : le tableau est alors trié.
 Les tableaux : Tableaux de dimension 2
Définition
Un tableau à 2 dimensions, ou matrice, est une grille de cellules, caractérisée par un nombre de
lignes et un nombre de colonnes. Et comme pour les tableaux à dimension 1, l’indexation des
lignes et des colonnes commence par 0.
Exemple, une matrice de réels, de 4 lignes et 6 colonnes peut être représentée comme ceci :

La syntaxe de déclaration d’un tableau à dimensions 2 se fait comme pour celle d’un tableau à
dimension 1, mais avec deux paires de crochets, la 1ière pour les lignes, et la 2ième pour les
colonnes.
 Les tableaux : Tableaux de dimension 2
Définition
La syntaxe de déclaration d’un tableau à dimensions 2 se fait comme pour celle d’un tableau à
dimension 1, mais avec deux paires de crochets, la 1ière pour les lignes, et la 2ième pour les
colonnes.
Syntaxe de base :
• 1iere syntaxe :
int[][] x = new int[nbr_lignes][nbr_colonnes]; // déclaration
x[ligne][colonne] = valeur;
• 2ieme syntaxe :
int y[][] = {{10, 10},{5, 5},{1, 1}}; // déclaration et initialisation
Attention!!
int y[][];
y = {{10, 10},{5, 5}}; // erreur de compilation
 Les tableaux : Tableaux de dimension 2
Exemple : Lire les éléments d’un tableau d’entiers de taille [3][3].
// lecture des éléments de la ligne 0
[Link]("tapez un entier\t");
t_int[0][0] = [Link]();
[Link]("tapez un entier\t");
t_int[0][1] = [Link]();
[Link]("tapez un entier\t");
t_int[0][2] = [Link]();

// lecture des éléments de la ligne 1

[Link]("tapez un entier\t");
t_int[1][0] = [Link]();
[Link]("tapez un entier\t");
t_int[1][1] = [Link]();
[Link]("tapez un entier\t");
t_int[1][2] = [Link]();
 Les tableaux : Tableaux de dimension 2
Exemple : Lire les éléments d’un tableau d’entiers de taille [3][3].
// lecture des éléments de la ligne 2
[Link]("tapez un entier\t");
t_int[2][0] = [Link]();
[Link]("tapez un entier\t");
t_int[2][1] = [Link]();
[Link]("tapez un entier\t");
t_int[2][2] = [Link]();
// même exemple avec les boucles
int l, c;
l = 0;
while(l < 3) {
c = 0;
while(c < 3) {
[Link]("tapez un entier\t");
t_int[l][c] = [Link]();
c++;
}
l++;}
Les chaines de caractères
Caractère / Chaine de caractère 3- afficher les caractères spéciaux
\' Apostrophe
1- caractères : le type char \" Guillemet
\\ Antislash
char x = 'A', y = '\n';
\t Tabulation
2- chaines de caractères : la classe String
\b Retour arrière (backspace)
String x = "ABC", y = ""; \r Retour chariot
Ou bien : \f Saut de page (form feed)
String x = new String("ABC"); \n Saut de ligne (newline)
Les chaines de caractères
Obtenir la longueur d’une chaine de caractère : fonction length( )
• String message = "bonjour tout le monde";
• [Link]([Link]()); // affiche 21

La concaténation
• La concaténation entre chaine de caractères et autres données se fait par l’opérateur +
Les chaines de caractères
Les méthodes de la classe String:
Méthodes Effets
String ch1 = "123";
extraire un nombre entier d’une chaine
int nbr1 = [Link](ch1);
String ch2 = "1.2345"; extraire un nombre réel d’une chaine
double nbr2 = [Link](ch2);
Retournent true si une chaine commence par une autre
boolean b1 = “BONJOUR".startsWith(“BON");
chaine
boolean b1 = "BONJOUR".endsWith(“JOUR"); Retournent true si une chaine se termine une autre chaine
boolean b1 = "BONJOUR".contains(“NJO"); Retournent true si une chaine contient une autre chaine
Retourne dans une autre chaine ch2, la partie de ch1 qui
String ch2 = [Link](debut) commence depuis la position debut. L’indexation
commence par 0
Retourne dans une autre chaine ch2, la partie de ch1 qui
String ch2 = [Link](debut,fin) commence depuis la position debut et qui se termine à la
position fin-1. L’indexation commence par 0.
 Les chaines de caractères
Les méthodes de la classe String:
Méthodes Effets
String ch1 = "BONJOUR à TOUS"; Remplace toutes les occurrences de la 1ère chaine par la
String ch2 = [Link]("OU" , "ou"); 2ème chaine.
String ch1 = "BONJOUR à TOUS"; Remplace la première occurrence de la 1ère chaine par la
String ch2 = [Link]("OU" , "ou"); 2ème chaine.
retourner une chaine qui correspond à la même chaine
String ch2 = [Link]();
en minuscules.
retourner une chaine qui correspond à la même chaine
String ch2 = [Link]();
en majuscule.

Boolean b1 = "BONJOUR".equalsIgnoreCase("BonJOuR"); Comparer sans tenir compte de la casse.

boolean b1 = "BONJOUR".equals("BonJOuR"); comparer en tenant compte de la casse.

[Link]() Teste si une chaine est vide.
String ch1 = [Link](); Enlève les espaces des deux côtés
 Les chaines de caractères
Les chaines de caractères modifiables
La classe StringBuilder
• Rappel : une chaine de caractères est un objet et
non une variable primitive. Les objets String ont
une particularité de plus par rapport aux autres : " nom = \’IALA\’ ";
lors de chaque modification d’une chaine de
caractères, un nouvel objet est créé et alloué à la
référence de cette chaine, tandis que l’objet
courant est abandonné. Ceci génère un grand
nombre d’objets non utilisés, ce qui constitue une
mauvaise gestion de l’espace mémoire.
• Ce sont les chaines de caractères StringBuilder et
StringBuffer qui sont utilisées dans les cas où on
a besoin d’effectuer plusieurs modifications (ex. :
multiple concaténation).
 Les dates
La date et le temps sont gérés par les classes LocalDate, LocalDateTime et LocalTime du package
[Link].
Méthodes Effets
LocalDate d = [Link](); Obtenir la date courante
LocalDateTime dt = [Link](); Obtenir la date & heure courante
LocalTime t = [Link](); Obtenir l’heure courante (format 24H)
LocalDate d = [Link](2000, [Link], 01); Obtenir une date spécifique

Obtenir l’une des composantes d’une date (l’année, le jour,

l’heure, …)
 Les dates
Formater une date
• Le « formatage » d’une date consiste à obtenir une chaine de
caractères qui correspond à cette date sous un format
spécifique (jour en lettres / chiffres, mois en lettres / chiffres,
…), et selon les paramètres linguistiques d’une langue
spécifique.
Etapes à suivre :
1. Créer un objet LocalDateTime (ou LocalDate ou LocalTime)
LocalDateTime dt = [Link]();
2. Créer un objet de type DateTimeFormatterBuilder.
DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
3. Définir le format souhaité
[Link]("chaine formattée");
4. Créer un objet de type DateTimeFormatter sur la base du builder
DateTimeFormatter formatter = [Link](Locale.une_langue);
5. Formater un objet LocalDateTime (ou LocalDate ou LocalTime) avec l’objet formatter
[Link](formatter);
 Les dates
Arithmétique des dates
Méthodes Effets

Comparer deux dates

Utiliser les méthodes plusDays, plusMonths, plusHours, plusYears, … et

minusDays, minusMonths, … selon le type d’objet LocalTime, LocalDate ou Ajouter des valeurs à une date
LocalDateTime.

Ajouter des valeurs à une date

Exécution de programmes et mémoire (1)
Variables et mémoire
La mémoire contient les données du programme dans des variables. Une variable désigne
un emplacement en mémoire et elle a un nom. Ce qui fait varier la mémoire au cours de
l’exécution d’un programme sont trois choses :
 La déclaration d’une variable, qui se traduit par l’allocation d’un espace mémoire et
son association avec le nom de la variable.
 L’affectation qui va stocker une valeur dans l’espace mémoire associé au nom de la
variable.
 La fin de vie d’une variable qui fait que le nom ne désigne plus rien et l’espace
mémoire correspondant est libéré. Il pourra être réutilisé pour une autre variable.
Nous reviendrons sur le troisième point dans une section dédiée à la fin de la vie des
variables et nous concentrer sur les deux premiers points en prenant un exemple.
Exécution de programmes et mémoire (1)
Exemple
 Exécution de programmes et mémoire (1)
• L’exécution de la ligne 3 et 4 du programme est de même nature :
il s’agit de l’allocation d’un espace mémoire de 8 octets à la
variable euro et dollars. L’état de la mémoire devient le suivant.
• L’exécution de la ligne 5 ne change rien à la mémoire : c’est un
affichage à l’écran.
• La ligne 6 affecte une valeur à la variable euros, nous supposons
que la valeur 10.0 est lue au clavier. Après exécution de la ligne 6,
la mémoire est dans l’état suivant.
• La ligne 7 est une affectation à la variable dollars. Le calcul utilise la
valeur de la variable euros qui va être lue dans la mémoire privée
de la variable. Après exécution de cette ligne 7, la mémoire est
dans l’état suivant.
• L’état de la mémoire ne change plus par la suite, car il n’y a ni
déclaration ni affectation dans les lignes 8 et 9 du programme.
 Exécution de programmes et mémoire (1)
Fin de vie d’une variable : les blocs
• La vie d’une variable commence lors de
l’exécution de sa déclaration. Sa vie se
termine à la fin de la suite d’instruction où
elle est déclarée. Cette suite d’instruction
s’appelle un bloc.
• Il arrive souvent que l’on déclare des
variables en début de la méthode main.
Ces variables existent jusqu’à la fin de
l’exécution de la méthode main, qui est
aussi la fin de l’exécution du programme.
• Si une variable est déclarée dans la suite
d’instruction du cas else d’un if, elle
n’existe que jusqu’à la fin de ce cas else.
Prenons un exemple.
 Exécution de programmes et mémoire (1)
Fin de vie d’une variable : les blocs
• La variable comment commence à exister
à la ligne où elle est déclarée et elle cesse
d’exister à la fin de la suite d’instruction
du cas else, c’est à dire à la ligne 11. Lors
d’une exécution, si la condition du if est
vraie, c’est le cas if qui est exécutée, la
variable n’existe à aucun moment. Si la
condition est fausse, elle commence à
exister après l’exécution de la ligne 7 et
elle cesse d’exister après l’exécution de la
ligne 10. En particulier, lors de l’exécution
de la ligne 12, la variable comment
n’existe pas dans la mémoire.
 Exécution de programmes et mémoire (1)
Fin de vie d’une variable : les blocs
• Dans le cas d’une boucle while, si une variable est déclarée dans le corps de la boucle, une nouvelle
variable est créée à chaque tour de boucle à la fin de la suite d’instruction qui constitue le corps de
la boucle.
• Dans tous les cas, la variable existe jusqu’à la fin de la suite d’instructions où elle a été déclarée,
cette fin étant matérialisée dans le programme par une accolade fermante : celle qui ferme la
méthode, celle qui ferme le cas if ou le cas else, celle qui ferme le corps d’une boucle.
• Il y a un cas un peu différent, celui d’une variable déclarée dans la partie initialisation d’une boucle
for. Une variable de ce type n’existe que pendant l’exécution de la boucle, mais elle est la même
pour tous les tours de boucle, ce qui est un comportement différent d’une variable déclarée dans le
corps de la boucle. Il n’est pas possible d’utiliser cette variable après le for : elle n’existe plus ; si on a
besoin de sa valeur après, il faut la déclarer avant la boucle.
 Exécution de programmes et mémoire (1)
Fin de vie d’une variable : les blocs
• Examinez cet exemple, qu’est ce que vous remarquez??
 Exécution de programmes et mémoire (1)
Les tableaux et la mémoire
Avec les tableaux arrive une nouvelle instruction qui a un effet sur la mémoire : l’instruction new.
Elle a pour but et pour effet d’allouer une mémoire privée pour le tableau. Cette mémoire n’est pas
identifiée par un nom mais par une adresse. Elle est dans une partie de la mémoire différente de celle
qui contient les variables. La mémoire privée du programme est divisée en deux parties :
 la Pile (anglais : Stack) qui contient les mémoires privées des variables déclarées dans les
méthodes.
 le Tas (anglais : Heap) qui contient les mémoires privées des tableaux.
Les emplacements dans la pile sont repérés par des noms et dans le tas par des adresses. Tout ce que
nous avons dit à propos des variable dans la section précédente est vrai pour toutes les variables, y
compris celles des types tableaux. Mais l’instruction new a un comportement tout à fait nouveau que
nous allons présenter au moyen d’un exemple simple.
 Exécution de programmes et mémoire (1)
Les tableaux et la mémoire

Exemple de création d’un tableau

 Exécution de programmes et mémoire (1)
Les tableaux et la mémoire
La ligne 3 a pour effet de réserver une mémoire privée pour la variable tab dans la pile. L’état de la
mémoire après exécution de cette ligne est le suivant :

L’instruction new a deux effets :

 Réserver un espace mémoire suffisamment grand pour 3 booléens (au moins 3 bits) dans le tas
pour en faire la mémoire privée du tableau.
 Renvoyer l’adresse de cet espace mémoire.
 Exécution de programmes et mémoire (1)
Les tableaux et la mémoire
L’affectation de la ligne 4 met la valeur renvoyée par new, c’est-à-dire l’adresse de la mémoire
privée du tableau, dans la mémoire privée de la variable tab. Les variables de type tableau
contiennent l’adresse de la mémoire privée du tableau. La taille de l’adresse ne dépend pas
de la taille du tableau et c’est pourquoi l’on n’a pas besoin de spécifier la taille du tableau lors
de la déclaration de la variable.
Après exécution de la ligne 4, la mémoire est dans l’état suivant.
 Exécution de programmes et mémoire (1)
Les tableaux et la mémoire
La ligne suivante est une affectation à une case du tableau. Cette affectation change le contenu d’une
case du tableau dans la mémoire privée du tableau, dans le tas. L’état mémoire devient le suivant.

La dernière ligne du programme consiste à afficher le contenu de la mémoire privée de tab,

autrement ce que nous avons appelé adresse-1.
 Exécution de programmes et mémoire (1)
Affectation entre tableaux
• Lorsque dans un programme, on réalise une
affectation entre variables de type tableau, cela
recopie l’adresse de la mémoire privée d’une
variable dans la mémoire privée de l’autre. C’est
la même chose lorsque l’on fait une affectation
entre deux variables de type int : l’entier stocké
dans la mémoire privée d’une variable est
recopié dans la mémoire privée de l’autre
variable.
• Cette opération de copie d’adresse ne change
rien dans le tas et ne crée pas de nouveau
tableau. Seule l’instruction new crée des
tableaux.
 Exécution de programmes et mémoire (1)
Affectation entre tableaux
Après exécution des lignes 3 et 4, la mémoire est
dans l’état suivant :

La ligne 5 consiste à lire le contenu de la mémoire

privée de la variable tab1 et à l’écrire dans la
mémoire privée de la variable tab2. Cela conduit à
l’état suivant.
 Exécution de programmes et mémoire (1)
Affectation entre tableaux
Il y a deux variables différentes qui contiennent
l’adresse du seul tableau qui existe dans le tas. Du
coup, il y a deux façons différentes d’accéder à une
case du tableau, par exemple celle d’indice 0. Ces
deux façons s’écrivent respectivement tab1[0] et
tab2[0]. Ce sont deux façon différentes de désigner
le même emplacement de la mémoire, dans le tas.
Les lignes 6 et 7 affichent les adresses contenues
dans tab1 et tab2, ce qui permet de constater que
ce sont une seule et même adresse.
 Exécution de programmes et mémoire (1)
Affectation entre tableaux
La ligne 8 modifie tab1[0], en y mettant true à la
place de false. Ce faisant, le programme modifie
aussi tab2[0], puisque dans l’état où est le
programme, tab1[0] et tab2[0] sont une seule et
même chose.
En fin de programme, l’état de la mémoire est le
suivant.

A la ligne 9, c’est donc true qui est affiché.

 Exécution de programmes et mémoire (1)
Tableaux de tableaux et mémoire
• Si l’on déclare un tableau de la façon suivante :
• int[][] tab = {{1,2},{3,4},{5,6}};
• On définit un tableau de trois cases et dans chacune
des trois cases il y a un tableau à deux cases.
• Les cases du grand tableau ne contiennent pas
directement les trois petits tableaux mais leurs
adresses ou références. De la même façon que la
variable tab dans la pile ne contient pas directement
le grand tableau, qui est dans le tas, mais son
adresse.
 Exécution de programmes et mémoire (1)
Tableaux non rectangulaires
• Compte tenu de la structure de tableaux enchâssés
dans un autre tableau, rien n’oblige à ce que les
tableaux des différentes cases aient la même taille.
On peut parfaitement avoir un tableau avec dans la
première case un tableau de taille 2, dans la
deuxième case, un tableau de taille 3 et dans la
troisième case un tableau de taille 1. Suit la
déclaration d’un tel tableau et l’état mémoire
correspondant.
• int[][] tab = {{1,2},{3,4,5},{6}};
 Exécution de programmes et mémoire (1)
Tableaux non rectangulaires
• Est-ce que ces tableaux asymétriques ont un
intérêt en pratique ? Oui, parfois.
• Par exemple, les distances entre villes sont
souvent représentées par un tableau
triangulaire : la relation étant symétrique, il est
inutile d’avoir une case pour la distance A-B et
une autre pour la distance B-A.
• Autre exemple : si l’on veut retracer dans un
tableau les notes d’un élève avec une colonne
pour chaque matière, rien ne dit que le
nombre de contrôles est égal dans toutes les
matières. Il peut donc y avoir un nombre de
lignes différent d’une colonne à l’autre.
 Exécution de programmes et mémoire (1)
Tableaux avec partage
Dans un tableau de tableaux, rien n’empêche de
mettre le même petit tableau dans plusieurs case du
grand tableau. On a alors une structure étrange, que
l’on ne peut pas dessiner sans prendre en compte la
notion d’adresse ou référence. Le programme suivant
est un exemple de tableau à 3 cases contenant toutes
les trois le même petit tableau.
 Exécution de programmes et mémoire (1)
Les String et la mémoire
Les String comme les tableaux sont stockés dans le
tas et les variable de type String contiennent
l’adresse de la mémoire privée d’une chaîne dans
la mémoire.
Après exécution de la ligne 4, l’état de la mémoire
est le suivant.
 Exécution de programmes et mémoire (1)
Les String et la mémoire
La ligne 5 déclare une nouvelle variable msg3 et lui
affecte le contenu de msg1, c’est-à-dire adresse-1.
L’état de la mémoire en fin de programme est donc
le suivant.

Dans cet état msg1 et msg3 sont deux moyens

d’accéder à la même chaîne de caractères, à la
même mémoire privée.
 Exécution de programmes et mémoire (1)
Les String et la mémoire
• Examinez cet exemple, qu’est ce que vous remarquez??
 Exécution de programmes et mémoire (1)
Les String et la mémoire
• L’état de la mémoire à partir de la fin de l’exécution de la ligne 5 est le suivant.

• Ceci explique pourquoi il ne faut pas utiliser == et != pour comparer deux chaînes de caractères si
l’on veut comparer leurs contenus et non pas l’adresse de leurs mémoires privées.
 Exécution de programmes et mémoire (1)
Résumé du chapitre
 La mémoire est divisée en deux parties : la pile et le tas
 La pile contient les mémoires privées des variables
 Le tas contient les mémoires privées des tableaux et des chaînes de caractères.
 Les mémoires privées des variables de type tableau ou de type String contiennent
une adresse désignant un espace dans le tas où est enregistrée le contenu du
tableau ou de la chaîne.
 Pour les tableaux et les chaînes, == et != comparent les adresses et non le
contenu des tableaux et des chaînes.
 Méthodes
Une méthode que l’on peut appeler également un sous-programme, une fonction ou une procédure, est un
petit programme qui réalise une tâche déterminée. Elle prend en entrée des paramètres et peut renvoyer un
résultat ou ne pas renvoyer de résultat.
Signature d’une méthode
• Pour appeler une de ces méthodes, il faut écrire son nom suivi d’une liste de paramètres entre
parenthèses. Pour utiliser une méthode, il faut connaitre le nombre et le type de ses paramètres. Il faut
également savoir si elle renvoie un résultat et le cas échéant, le type de son résultat. On appelle signature
d’une méthode la liste des types de paramètres et du résultat éventuel de la méthode.
• Les quatre méthodes mentionnées ci-dessus ont les signatures suivantes, notées graphiquement.
• On peut également décrire les signatures textuellement. On utilise alors le petit mot-clé void pour dire
qu’une méthode ne renvoie pas de résultat.
• [Link] : String  void
• [Link] :  int
• [Link] : int, int  int
• [Link] :  double
 Méthodes
Étude de la méthode main
Pour savoir comment écrire une méthode, on peut commencer par regarder la méthode que nous savons déjà écrire, à
savoir la méthode main. Prenons un exemple de programme.
La méthode commence par un entête qui figure sur la ligne numéro 2, suivi d’une liste d’instructions entre accolades
(accolade ouvrante en fin de ligne 2, fermante en ligne 10, instructions des lignes 3 à 9).
Voyons les différentes composantes de l’entête :
• public static : deux mot-clés de Java que nous n’expliquerons
pas pour le moment et qui seront toujours écrits en début
d’entête pour toutes les méthodes.
• void : spécifie que la méthode ne renvoie pas de résultat. Si
au contraire, la méthode renvoyait un résultat, ce serait le
type de ce résultat qui apparaîtrait à cette position de
l’entête.
• main : le nom de la méthode. Dans le cas de la méthode
main, ce nom est imposé. C’est cette méthode qui est
toujours exécutée lorsqu’on demande à exécuter un
programme. Pour les autres méthodes, leur nom sera au
libre choix du programmeur, comme le nom des variables du
programme.
• (String[] args) : c’est la liste des paramètres de la méthode.
Ici, il n’y a qu’un paramètre. Ce paramètre a pour nom args
et pour type String[]. Ce paramètre est comme une sorte de
variable, utilisable dans le programme.
 Méthodes
Étude de la méthode main
• On peut se demander à quoi sert le paramètre de la méthode main. Il sert à transmettre des données entrées lors de la
demande d’exécution du programme. Par exemple, si l’on demande l’exécution d’un programme depuis une ligne de
commande dans un terminal, on commence cette ligne par la commande java, ensuite on met le nom de la classe
contenant la méthode main et ensuite on peut ajouter des données séparées par des espaces. Ces données sont
transmises au programme dans le tableau args.
• Voyons quelques exemples d’appels d’un programme qui utilise ce paramètre.

Et deux exécutions de ce programme : > java ArgMain un deux 47 789

Taille de args: 4
> java ArgMain
Contenu de args[0]: un
Taille de args: 0 Contenu de args[1]: deux
Contenu de args[2]: 47
Contenu de args[3]: 789
 Méthodes
Appel d’une méthode
• Une méthode sans résultat ou procédure est un Exemple:
bout de code qui a un nom et qui peut être appelé
depuis le reste du programme. En Java, une
méthode est forcément déclarée dans une classe.
Dans sa forme la plus simple, elle s’exprime ainsi :

• Il y a deux méthodes dans la classe : main et

dessinerLigne.
• L’ordre dans lequel sont écrites les méthodes dans la
classe n’a aucune importance. Ici, il y d’abord le main
puis dessinerLigne. Ce pourrait être l’inverse sans
changer le fonctionnement du programme. La
méthode dessinerLigne est définie dans la classe
Lignes1. Par convention, en Java, le nom d’une
méthode est supposé commencer par une
minuscule.
 Méthodes
Appel d’une méthode
• La méthode est appelée plusieurs fois dans le main. L’appel d’une méthode sans résultat a la forme :
• [Link]éthode() ;
• Si l’appel de la méthode est dans la même classe que la méthode appelée, on peut ne pas mettre le nom de la
classe qui est alors sous-entendu et l’appel devient :
• nomDeLaMéthode() ;
• Une méthode peut avoir un ou plusieurs paramètres d’entré.
• Exemple: public static void dessinerLigne(int longueurLigne, char symbole)
• Une méthode peut avoir une valeur de sortie:
• On met le type de la valeur renvoyée à la place du void des méthodes :

• On renvoie la valeur du résultat à l’aide de l’instruction return.

• Exemple: public static String dessinerLigne(int longueurLigne, char symbole, String msgAffiche)
 Méthodes et mémoire
Un principe fondamental du langage Java est que chaque méthode a ses propres variables et aucune
variable ne peut être partagée par deux méthodes différentes.
Pour chaque exécution d’une méthode, une portion de la pile lui est affectée pour y stocker ses
paramètres et ses variables. Ses variables sont celles qui sont déclarées dans son corps.
Le calcul d’un appel de méthode se fait en plusieurs temps :
 Calcul de la valeur des paramètres
 Affectation d’une mémoire privée dans la pile. Dans cette mémoire privée les paramètres sont stockés
avec leurs noms et leurs valeurs calculées à l’étape précédente.
 Exécution des instructions du corps de la méthode.
 Une fois l’exécution de ces instructions terminée, la mémoire privée de la méthode dans la pile est
libéré. La valeur calculée est renvoyée à la méthode contenant l’appel (sauf méthode void, pas de valeur
renvoyée dans ce cas).
 Méthodes et mémoire
Voyons un exemple d’exécution d’un programme comportant un appel à une méthode.
Exemple 1:
 Méthodes et mémoire
Voyons un exemple d’exécution d’un programme comportant un appel à une méthode.
Exemple 2:
 Méthodes et mémoire
Voyons un exemple d’exécution d’un programme comportant un appel à une méthode.
Exemple 3:
 Méthodes et mémoire
Voyons un exemple d’exécution d’un programme comportant un appel à une méthode.
Exemple 4:
 la classe ArrayList
La classe ArrayList permet de construire des tableaux de taille variable. De la même
manière qu’un tableau est un tableau d’int, de char, de String (etc.), une ArrayList contient
des valeurs d’un type donné. On doit préciser ce type quand on déclare la variable. Pour
cela, on fait suivre le nom de la classe ArrayList par le type des éléments, entre chevrons (<
et >). Par exemple :
ArrayList<String> maListe;
déclare la variable maListe comme étant une référence vers une ArrayList de Strings.
Une ArrayList est un objet, et comme les tableaux, les objets sont créés par l’exécution de
l’instruction new.
maListe= new ArrayList<String>();
va créer une ArrayList vide.
Enfin, notez que pour qu’une classe puisse utiliser les ArrayList, il faut écrire
import [Link];
Méthodes de la classe ArrayList Effets
size() fonction qui renvoie la longueur d’une ArrayList
renvoie l’entrée de la case numéro i. Comme pour les tableaux, les cases des ArrayList
get(int i) sont numérotées en commençant à 0. Le type de l’objet retourné est celui précisé lors
de la création de l’ArrayList.
add(Type element) ajoute un élément à la fin de la liste.
remplace l’ancienne valeur qui était dans la case i par element. Logiquement,
set(int i, Type element)
i doit être inférieure à la size() de l’ArrayList.
remove(int i) supprime l’élément qui est dans la case i ;
supprime la première occurrence de l’élément de valeur element; si l’élément est
présent plusieurs fois, il ne sera enlevé qu’une seule fois. Le contenu des cases est
remove(Type element)
décalé, et la longeur de l’ArrayList diminue de 1. Si l’élément n’est pas présent, la liste
n’est pas modifiée.
contains(Type element) renvoie vrai si la liste contient la valeur element.
indexOf(Type element) renvoie la position de element dans la liste, et -1 s’il n’y apparaît pas.
add(int i, Type element) ajoute la valeur element à la position i. i doit être inférieure ou égale à size()
clear() vide la liste.
addAll(ArrayList<Type> l1) ajoute tous les éléments de l2 à la fin de l1 (concatène donc l1 et l2. l1 est modifiée, l2
Exp: [Link](l2) ne l’est pas.
Méthodes de la classe ArrayList Effets
retainAll l’appel enlève tous les éléments de l1 qui ne sont pas dans l2.
Exp: [Link](l2)
removeAll l’appel enlève tous les éléments de l1 qui sont dans l2. Après l’appel, il ne reste plus d’élément
Exp : [Link](l2) de l2 dans l1.

Exercice

Ecrivez un programme qui simule une caisse enregistreuse. Ce programme

nous permet d’éditer le ticket de caisse d’un client en y ajoutant des produits ou
en les supprimant. A cet égard, nous allons représenté un ticket par deux
ArrayList. La première contient les noms des produits achetés, et la seconde
contient leur prix.
 Notions de Classes et Objets
1. Définitions et syntaxe
▪ Classe : Tout comme les structures de données en langage C, une classe en POO désigne une catégorie
d’individus ayant tous les mêmes propriétés (appelées « attributs ») et les mêmes comportements (appelées
« méthodes » ou « opérations »).
▪ Objet : Chaque individu appartenant à une classe est appelé un « objet ». Chaque objet définit ses propres
valeurs pour les attributs.
Une classe comporte les éléments suivants :
• Des données stockées dans des variables appelées attributs. Elles doivent contenir toute l’information dont
le programme a besoin concernant l’entité à représenter.
• Un moyen d’initialiser les données à la création de l’objet. C’est ce qu’on appelle un constructeur.
• Des traitements qui utilisent ou modifient les données : ce sont les méthodes de l’objet. On distingue les
opérations qui utilisent les données en lecture uniquement, sans les modifier, et celles qui changent les
données. Les premières sont appelées accesseurs, les secondes des modificateurs.
On peut créer plusieurs classes dans un seul fichier Java.
La classe qui porte le nom du fichier doit être déclarée avec le mot-clef « public ».
 Notions de Classes et Objets
2. Attributs des comptes

Exemple des comptes bancaires

Prenons un exemple, celui d’un compte en banque (un peu simplifié).
On va utiliser trois attributs pour représenter un compte :

— Le nom du titulaire.
— Le numéro de compte.
— Le solde du compte.

Ces trois attributs seront trois variables de type respectif String, int et double.
 Notions de Classes et Objets
3. Constructeur
• Le rôle du constructeur est d’initialiser les attributs de la classe. Ici, il y a trois attributs : le titulaire et le
numéro de compte ne peuvent pas être devinés dans le constructeur en utilisant du code Java. Il faut que
cette information soit donnée lors de la création de l’objet. Cela sera fait au moyen de paramètres du
constructeur. Le solde pour sa part peut être fixé à 0.0 à la création de l’objet. Cela revient à supposer que
les comptes sont vides à leur création.
• Le constructeur est une sorte de méthode appelée par l’instruction new lors de l’instanciation d’une classe.
Cette méthode renvoie l’objet créé par new correctement initialisé. Dans la classe, il se distingue des
méthodes par le fait qu’il porte le même nom que la classe et que le type des objets renvoyés n’est pas
précisé. Dans son code, il n’y a pas de return pour renvoyer l’objet créé. C’est fait automatiquement de
façon sous-entendue. Voici le code du constructeur à ajouter dans la classe :
Notions de Classes et Objets
3. Constructeur
• Si vous ne créez pas un constructeur dans votre classe, le compilateur va
automatiquement vous créer un constructeur par défaut implicite.
• Si le constructeur surchargé est créé, le constructeur par défaut implicite ne sera plus
créer par le compilateur.
• La plateforme java différencie entre les différents constructeurs déclarés au sein d’une
même classe en se basant sur le nombre des paramètres et leurs types.
On ne peut pas créer deux constructeurs ayant le même nombre et types des
paramètres.
Compte(int id){
[Link]=id
}
Compte(int id) {
[Link]=id*2
}
 Notions de Classes et Objets
4. Méthodes
• Il s’agit de déterminer quelles
opérations sont nécessaires pour
utiliser un compte bancaire. Parmi
les opérations usuelles que tout un
chacun fait sur son compte, il y a la
consultation du solde, le dépôt
d’argent et le retrait d’argent. Ces
trois opérations doivent
nécessairement figurer dans la
classe sous forme de trois
méthodes.
• Faut-il d’autres méthodes? Pas
nécessairement, mais on peut
ajouter des méthodes qui
permettront de faciliter la mise au
point des programmes et/ou
d’homogénéiser les pratiques.
 Notions de Classes et Objets
4. La méthode toString
• La méthode toString définie dans la classe Object renvoie le nom de la classe de l'objet concerné suivi de
l'adresse de cet objet.
• Quand on redéfinit la méthode to String, on fait en sorte qu'elle renvoie une chaîne de caractères servant à
décrire l‘objet concerné.
• Cette méthode est appelée par [Link] et par la concaténation de chaînes +. Si on n’écrit pas
cette méthode dans la classe, c’est un toString par défaut qui est utilisé et qui affiche plus ou moins la
référence de l’objet.
 Notions de Classes et Objets
4. La méthode toString
Voyons un exemple de création puis d’affichage d’un compte.
 Méthodes et variables statiques.
Les composantes statiques des classes
Nous avons vu qu’une classe peut contenir un constructeur, des variables et méthodes d’instance. Mais une
classe peut aussi contenir de variables et méthodes qui ne sont pas d’instance, mais statiques ou de classe.
Les déclarations de ces variables et méthodes contiennent le mot-clé static.
Nous utilisons régulièrement une méthode statique : le main qui constitue le programme.
Une méthode statique existe dans la classe indépendamment des objets instances de la classe. Alors que les
méthodes d’instance n’existent que dans les objets créés en instanciant la classe avec un new. Si l’on reprend
l’exemple des comptes bancaires, la méthode get_solde qui est une méthode d’instance ne peut être utilisée
que s’il existe déjà un objet de type Compte. Elle peut alors être appelée et elle renvoie le solde de ce
compte-là.
Une méthode statique comme main existe dans la classe et peut être utilisée sans qu’aucun objet instance de
la classe ne soit créé. On peut l’utiliser en l’appelant non pas sur un objet mais sur la classe.
un attribut dit « statique » présente les différences suivantes :
o Il n’appartient pas à l’objet, mais à toute la classe,
o Sa valeur est la même pour tous les objets,
o Ne nécessite pas l’instanciation d’objets pour être utilisé.