Les bases du langage Java CHAPITRE III

• Règles de base, commentaires et identificateurs

• Types de données et déclaration

• Opérateurs arithmétiques, relationnels et logiques

• Ecriture et lecture des données

• Structures de contrôle (Test et boucles)

• Les méthodes en Java

• Les tableaux en Java

 CHAPITRE III

Règles de base Les bases de Java

• Java est sensible à la casse (minuscule ≠ majuscule ).

• Les blocs de code sont encadrés par des accolades:{ et }

• Chaque instruction se termine par un point virgule ';'

2
 CHAPITRE III

Commentaires dans le code source Les bases de Java

• Trois façons d’inclure des commentaires en Java :

• Commentaire abrégé:
// commentaire sur une seule ligne
int n=1; // déclaration du compteur
• Commentaire multi lignes:
/* commentaires ligne 1
commentaires ligne 2 */
• Commentaire de documentation automatique:
• Les textes entre « /** » et « */ » sont utilisés pour créer des commentaires que l’exécutable JAVADOC
pourra traiter afin de produire une documentation.
/** Commentaires destinés
à la documentation */

3
 CHAPITRE III

Identificateurs Les bases de Java

• Un identificateur (identifier) permet de désigner une classe, une méthode, une variable, etc.
• Les identificateurs ne peuvent commencer que par :
• Une lettre
• Un « $ »
• Un « _ » (underscore)
• Et ne commencent pas par :
• Un chiffre
• Un signe de ponctuation autre que « $ » ou « _ »
• Interdiction d’utiliser les mots-clés (ex: abstract, new, return, try, class, public, etc.)
• Exemples:
• x254, Compte, _Compte, $Compte

4
 CHAPITRE III

Types de données primitifs Les bases de Java

• Ne sont pas des objets !!!

• Occupent une place fixe en mémoire réservée à la déclaration

• Types primitifs :

• Entiers : byte (1 octet), short (2 octets), int (4 octets) et long (8 octets).

• Flottants : float (4 octets) et double (8 octets)

• Booléens : boolean (true ou false)

• Caractères : char (codage Unicode sur 16 bits)

5
 CHAPITRE III

Déclaration, Initialisation et constantes Les bases de Java

• Déclaration et initialisation Penser à l’initialisation au risque d’une

erreur de compilation:
int n;
int n = 15; System.out.println(" n = " + n);
boolean b = true;
float nombre;
char c = ‘A’;

• Constantes
• Ce sont des variables dont la valeur est affectée final int N = 5;
final int T;
qu'une fois. ...
• Elles ne peuvent plus être modifiées. T = 8;
N = 10; // erreur : N est déclarée final
• Elles sont définies avec le mot clé final.
• Les noms des constantes se composent des lettres en majuscules avec underscore.
• Exemple : VALEUR_TVA, NOMBRE_PI. 6
 CHAPITRE III

Le format des nombres décimaux Les bases de Java

• Les types float et double stockent des nombres flottants, pour être reconnus, ils doivent
posséder soit:
• un point: 2.5, 10.0
• un exposant: 2e6, 1e-1 (équivalent à 2*106 et 1*10-1)
• ou l'un des suffixes f, F, d, D: 2.0d, 5.25D, 3.14f, 0.1F
• Il est possible de préciser des nombres sans partie entière ou sans partie décimale: .1, 5., +.2
• Exemple:
float pi = 3.141f;
double x = 3d; //ou bien double x = 3.0;
float flot1 = +.1f; //ou bien flot1=.1f, flot1 a la valeur 0.1
float flot2 = 2e6f; //équivalent à 2*106

• NB. C’est pas obligatoire de suffixer une valeur double, par contre, une valeur représentant un
float doit être, obligatoirement, suffixée par f ou F. 7
 CHAPITRE III

Opérateurs arithmétiques Les bases de Java

Op. Description Op. Description

+ addition += assignation additive • Règles de précédences des opérateurs
Niveau Symbole Signification
- soustraction -= assignation soustractive
1 () Parenthèse
* multiplication *= assignation multiplicative * Produit

/ division /= assignation divisionnelle 2 / Division

% Modulo
% modulo %= assignation modulo + Addition ou concaténation
3
- Soustraction
++ incrémentation -- décrémentation

• Opérateurs d’affectation élargies: +=, -=,*=, /=, %= (exemple: x=x+5; ➔ x+=5;)

• post-incrémentation : a++; • post-décrémentation : a--;

• pré-incrémentation: ++a; • pré-décrémentation: --a;
8
 CHAPITRE III

Opérateurs arithmétiques - Exemple Les bases de Java

public class OpArithm { • c = a++; opération de post-incrémentation qui est équivalente à:

• c = a; puis a = a + 1;
public static void main(String[] args) {
int c,d;
• Donc c = 1 et a = 2.
int a = 1; • d = a++ - a; est équivalente aux actions suivantes:
int b = 2; • a++ : on va utiliser la valeur de a qui est 2, dans l’opération de
soustraction, ensuite l’incrémenter de 1.
c=a*b-a+b; • a: la valeur utilisée ici est la valeur obtenue après l’incrémentation: 3.
System.out.println("a = " + a); • Donc le résultat sera : d = 2 – 3 = -1.
System.out.println("b = " + b); • Et a = 3.
System.out.println("c = a*b-a+b =" + c);
• c = ++a; opération de pré-incrémentation qui est équivalente à:
c=a++; • a = a + 1; puis c = a;
d=a++ - a; • Donc c = 4 et a = 4.
System.out.println("a = " + a); • d = ++b – a++; est équivalente aux actions suivantes:
System.out.println("c = a++ = " + c); • ++b: on va, tout d’abord incrémenter b de 1 et la valeur trouvée, qui
System.out.println("d = a++ - a =" + d); est 3, sera utilisée dans l’opération de soustraction.
• a++: on va utiliser la valeur de a qui est 4, dans l’opération de
c=++a; soustraction, ensuite l’incrémenter de 1.
d=++b - a++;
• Donc le résultat sera : d = 3 – 4 = -1.
System.out.println("a = " + a);
• Et a = 5.
System.out.println("b = " + b);
System.out.println("c = " + c); a = 5
a = 1 a = 3 b = 3
System.out.println("d = " + d);
b = 2 c = a++ = 1 c = 4
}} c = a*b-a+b =3 d = a++ - a =-1 d = -1 9
 CHAPITRE III

Opérateurs relationnels et logiques Les bases de Java

• Opérateurs relationnels (comparaison) • Opérateurs logiques

Op. Description Op. Description
== égal à
& ou && ET logique
!= différent de

> strictement supérieur à | ou || OU logique

< strictement inférieur à ! NON logique

>= supérieur ou égal à
OU exclusif
^
<= inférieur ou égal à

• && et || sont des opérateurs optimisés, respectivement de & et de |.

• Soit l’expression p && q, selon la table de vérité de ET logique, si p est fausse alors toute l’expression sera
fausse quelque soit la valeur de q.
• L’opérateur && évalue p, si p est fausse il n’évaluera pas q, en revanche, & évalue toujours p et q.
• Même principe pour l’opérateur ||.
• L’utilisation de && et || permet d’optimiser la vitesse d’exécution. 10
 CHAPITRE III

Exemple d’opérateurs relationnels et logiques Les bases de Java

public class OpCompLog {

public static void main(String[] args) {

int x = 4, y = 8, z = 3, t = 7;
Boolean bool; Résultats
bool = x < y ;
System.out.println( "x < y =" + bool );
x < y = true

bool = (x < y) && (z == t); (x < y) && (z == t)= false

System.out.println( "(x < y) && (z == t)=" + bool );
(x < y) | (z == t)= true
bool = (x < y) | (z == t);
System.out.println( "(x < y) | (z == t)=" + bool );
(x < y) ^ (z == t)= true
bool = (x < y) ^ (z == t);
System.out.println( "(x < y) ^ (z == t)=" + bool );

}
11
 CHAPITRE III
Exercice sur les opérateurs relationnels et Les bases de Java
logiques
public class OpLogique {

public static void main(String[] args) {

int i=10, j=5 ;
Résultats
if (i<5 && j++<10) System.out.println ("A: vrai") ;
else System.out.println ("A: faux") ; A: faux
System.out.println ("i = " + i + " j = " + j) ; i = 10 j = 5
B: vrai
if (i<15 && j++<10) System.out.println ("B: vrai") ;
i = 10 j = 6
else System.out.println ("B: faux") ;
System.out.println ("i = " + i + " j = " + j) ; C: vrai
i = 10 j = 7
if (i<15 | j++<10) System.out.println ("C: vrai") ;
else System.out.println ("C: faux") ;
System.out.println ("i = " + i + " j = " + j) ;

12
}
 CHAPITRE III

Transtypage (cast) Les bases de Java

• La conversion implicite d’un type ordinaire(primitif) vers un autre type ordinaire se fait d’un
type plus petit vers un autre plus grand.

• La hiérarchie est la suivante : • Exemple:

• byte → short → char → int → long → float → double int n ; float f;
• Le type boolean est incomparable avec les autres
n = 3;
f = n; // 3 est converti en 3.0
types de base.

• La conversion explicite d’un type ordinaire(primitif) vers un autre type ordinaire se fait d’un
type plus grand vers un autre plus petit.
• Exemple:
int n ; float f;
f = 3.0f;
n = f; // Faux
n = (int) f; // n aura la valeur 3
13
 CHAPITRE III

Les conversions implicites dans les expressions Les bases de Java

• Une conversion d’ajustement de type et une int n; long p; float x;

Soit l’expression suivante n * p + x :
conversion d’un type plus petit en un autre plus grand
n * p + x
dans une expression arithmétique: long
*
int -> long -> float -> double.
long
float
+
float
• Une conversion systématique ou promotion
short p1; byte p2; float x;
numérique est le faite de convertir les types byte, Soit l’expression suivante p1 * p2 + x :
char et short en int car les opérateurs numériques ne p1 * p2 + x
sont pas définis pour ces types. int int
*
int
• Forcer la conversion: soit c de type char l’expression float
+
c+=6 est équivalente à c=(char) c+6;
float 14
 CHAPITRE III

Exemple Les bases de Java

• Indiquez, pour chaque affectation dans le programme ci-dessous, si l'affectation est possible et,
le cas échéant, la valeur exacte qui sera affectée à la variable.
int n1 = 2; //n1 vaut 2
double r1 = 2.7; //r1 vaut 2.7 int n5 = 19 / 4; //n5 vaut 4
double r6 = 5.0;//r6 vaut 5.0
int n2 = 2.7; //impossible int n6 = n5 / r5;//impossible
double r2 = 5; //r2 vaut 5.0 int n7 = (int) (n5 / r5); //n7 vaut 0
double r7 = 19.0 + r6; //r7 vaut 24.0
int n3 = (int) 5.6; //n3 vaut 5 double r8 = 15.0 - n3; //r8 vaut 10.0
float r3 = 5.6f; //r3 vaut 5.6
double r9 = 19 / 4; //r9 vaut 4.0
int n4 = 9; //n4 vaut 9 double r10 = (double) (19 / 4);//r10 vaut 4.0
double r4 = (double) n4;//r4 vaut 9.0 double r11 = (double)19/(double)4;//r11 vaut 4.75
float r5 = (int) r4;//r5 vaut 9.0 15
 CHAPITRE III

Ecriture des données ou affichage Les bases de Java

• Usages : affichage à l’écran

• System.out.println(…) : revient à la ligne
• System.out.print(…) : ne revient pas à la ligne
• Différentes sorties possibles
• out : sortie standard
• err : sortie en cas d’erreur
• Tout ce que l’on peut afficher…
• Objets, nombres, booléens, caractères, …
• Tout ce que l ’on peut faire …
• Concaténation sauvage entre types et objets avec le "+"

System.out.println("a=" + a + "donc a < 0 est " + a < 0);

16
 CHAPITRE III

Lecture des entrées clavier Les bases de Java

• Pour lire des données tapées au clavier on utilise la syntaxe suivante:

Scanner sc = new Scanner(System.in); 2

• Pour récupérer la valeur tapée au clavier on utilise la syntaxe suivante:

String s=sc.nextLine();
int i = sc.nextInt(); Pour récupérer un caractère:
double d = sc.nextDouble(); String str=sc.nextLine(); 3
long l = sc.nextLong(); char c = str.charAt(0);
byte b = sc.nextByte();
Etc
• A la fin de chaque utilisation; il faut fermer l’objet Scanner:
sc.close(); 4

• A fin de pouvoir utiliser la classe Scanner il faut importer le fichier Scanner:

import java.util.Scanner; 1

17
 CHAPITRE III

Exemple de lecture/écriture Les bases de Java

import java.util.Scanner;
public class EntreeSortie {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a;
long l;
float f;
String st;
System.out.println("Entrer un entier:");
a = sc.nextInt();
System.out.println("Entrer un long:");
l=sc.nextLong();
System.out.println("Entrer un float:");
f=sc.nextFloat();
sc.nextLine();
System.out.println("Entrer un string:");
st=sc.nextLine();

System.out.println("a="+a);
System.out.println("l="+l);
System.out.println("f="+f);
System.out.println("st="+st);
sc.close();
}
} 18
 CHAPITRE III

Exercice Les bases de Java

• Connaissant le prix hors taxe affiché sur un article, écrire un programme java qui calcule le prix
d’achat de cet article si la TVA est de 20%.
import java.util.Scanner;
public class calculPrixTTC {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
final double TVA=0.2;
double prixHorsTaxe, prixTTC;
System.out.println("Donner le prix hors taxe de votre article:");
prixHorsTaxe = sc.nextDouble();
prixTTC = prixHorsTaxe * (1+TVA);
System.out.println("Le prix TTC de votre article est:" + prixTTC);
sc.close();
}}

19
 CHAPITRE III

Structures de contrôle Les bases de Java

• Les structures de contrôles permettent d’exécuter conditionnellement une instruction, ou de

réaliser une boucle.

Type d’instruction Mots clés utilisés

Décision (choix) if() else – switch() case

Boucle (itération) for( ; ; ) – while () – do while()

Branchement label : -- break – continue

20
 CHAPITRE III

Structures de contrôle (IF – ELSE) Les bases de Java

if (condition logique)
{
liste d’instructions
}
else
{
liste d’instructions dans le cas contraire
}

• Exercice:
Ecrire un programme java qui vérifie si un entier n est pair ou impair et affiche le résultat.

21
 CHAPITRE III

Structures de contrôle (SWITCH – CASE) Les bases de Java

switch (Variable) {
case Valeur1 :
Liste d'instructions
break;
case Valeur2 :
Liste d'instructions
break;
case Valeurs... :
Liste d'instructions
break;
default:
Liste d'instructions
break;
}

22
 CHAPITRE III

SWITCH – CASE: Exercice 1 Les bases de Java

import java.util.Scanner; Quels résultats affiche-t-il lorsqu’on lui fournit en

public class SwitchStr { donnée :
1. la valeur 0,
public static void main(String[] args) {
Scanner sc=new Scanner(System.in); 2. la valeur 1,
3. la valeur 4,
int n ; 4. la valeur 10,
System.out.println("Entrez un nombre entier:"); 5. la valeur -5.
n = sc.nextInt() ;
switch (n) Résultats
{
case 0 : System.out.println ("Nul") ; // avec la valeur 0
case 1 : Nul
case 2 : System.out.println ("Petit") ; Petit
break ; // avec la valeur 1
case 3 :
Petit
case 4 :
case 5 : System.out.println ("Moyen") ; // avec la valeur 4
default : System.out.println ("Grand") ; Moyen
Grand
sc.close(); // avec la valeur 10
} Grand
} // avec la valeur -5
}
Grand
23
 CHAPITRE III

SWITCH – CASE: Exercice 2 Les bases de Java

• Ecrire un programme java qui affiche :

• « Très bien » si la note est ‘A’

• « Bien » si la note est ‘B’.

• « Passable » si la note est ‘C’.

• « Insuffisant » si la note est ‘D’.

• Un message d’erreur dans le cas contraire.

24
 CHAPITRE III

Structures de contrôle (condition ternaire: ? :) Les bases de Java

• Exemple 1:
int x=10, y=20;
int max= (x<y) ? y : x; //max vaut 20

• Exemple 2:

int x=10, y=20;

int max= (x<y) ? Y*2 : x*2; //max vaut 20*2 donc 40

• Exercice:
Reprenez l’exercice de (IF-ELSE), en utilisant la condition ternaire "? :".

25
 CHAPITRE III

Structures de contrôle (FOR) Les bases de Java

• Syntaxe:

for (compteur; condition; modification du compteur) {

liste d'instructions
}

• Exemple:

for(int i=0 ; i<10 ; i++) {

System.out.println("La valeur de i est : " + i);
}

26
 CHAPITRE III

FOR: Exemple Les bases de Java

public class BoucleFor {

public static void main(String[] args) {

int i, n ;
for (i=0, n=0 ; i<5 ; i++) n++ ;
System.out.println ("A : i = " + i + ", n = " + n) ;

for (i=0, n=0 ; i<5 ; i++, n++) {}

System.out.println ("B : i = " + i + ", n = " + n) ;

for (i=0, n=50 ; n>10 ; i++, n-= i ) {}

System.out.println ("C : i = " + i + ", n = " + n) ;

for (i=0, n=0 ;i<3 ; i++, n+=i, System.out.println ("D : i = " + i + ", n = " + n)) ;
System.out.println ("E : i = " + i + ", n = " + n) ;
}
}

A : i = 5, n = 5 D : i = 1, n = 1
Résultats B : i = 5, n = 5 D : i = 2, n = 3
C : i = 9, n = 5 D : i = 3, n = 6
E : i = 3, n = 6 27
 CHAPITRE III

FOR: Exercice Les bases de Java

Ecrire un algorithme qui, à partir d’un nombre de départ, calcule la somme des entiers jusqu’à
ce nombre.

Par exemple, si le nombre de départ est 5, le programme doit calculer : 1 + 2 + 3 + 4 + 5 = 15

28
 CHAPITRE III

Structures de contrôle (WHILE, DO - WHILE) Les bases de Java

• WHILE:
while (condition réalisée) {
liste d'instructions
}

• Si le code de la boucle doit être exécuté au moins une seule fois:

do {
liste d'instructions
} while (condition réalisée)

• Exercice:
Ecrire un algorithme qui affiche les 20 premiers nombre impairs.

29
 CHAPITRE III

Structures de contrôle (BREAK, CONTINUE) Les bases de Java

• Exemple:
label:

for (int i=0 ; i<6 ; i++) {

for(int j=8 ; j>4 ; j--){

if (j==6) continue;//si j=6, aller au début de la boucle (sauter une itération)

if (i==4) break label;// si i=4, sortir de la boucle et aller à label

System.out.println("la valeur de i,j est :" + i + " , " + j);

30
 CHAPITRE III

BREAK, CONTINUE : Exercice Les bases de Java

public class BreakContinue {

public static void main(String[] args) {
int n=0 ;
do{
if (n%2==0) { Résultats
System.out.println (n + " est pair") ; 0 est pair
n += 3 ; 3 est multiple de 3
continue ; 9 est multiple de 3
} 15 est multiple de 3
if (n%3==0) { 20 est multiple de 5
System.out.println (n + " est multiple de 3") ;
n += 5 ;
}
if (n%5==0) {
System.out.println (n + " est multiple de 5") ;
break ;
}
n += 1 ;
}while (true) ;
}
}
31
 CHAPITRE III

Les méthodes en Java Les bases de Java

• C’est un sous-programme qui permet d'effectuer un ensemble d'instructions par simple appel de
la méthode dans le corps du programme principal.
• Déclaration:
TypeDeRetour nomDeLaMethode(Type1 argument1, Type2 argument2){
//liste d'instructions
}

• Exemples:

int somme(int val1, int val2){ void affiche(String s){

return val1 + val2; System.out.println(s);
} }

32
 CHAPITRE III

Passage de paramètres Les bases de Java

• Deux principales manières de passer des paramètres en programmation:

1. Passage par valeur:

• Fournit une copie de la valeur du paramètre,

• La valeur effective du paramètre ne sera pas modifiée.

2. Passage par référence:

• Fourni l’emplacement de la variable concernée,

• La valeur de la variable sera modifiée.

• En Java, contrairement à Pascal et C++, le passage par valeur est le seul existant.

33
 CHAPITRE III

Passage de paramètres – cas de types primitifs Les bases de Java

public class ParValeur {

public static int auCaree(int x){
System.out.println("Début da la méthode: x = " + x);
x= x*x;
System.out.println("Fin da la méthode: x = " + x);
return x;
}
public static void main(String[] args) {
int x= 10;
int y = auCaree(x);
System.out.println("Après la sortie da la méthode: x = " + x);
x = y;
System.out.println("Après l’affectation: x = " + x);
}
} Début da la méthode: x = 10
Fin da la méthode: x = 100
Après la sortie da la méthode: x = 10
Après l’affectation: x = 100 34
 CHAPITRE III

Surcharge de méthodes Les bases de Java

• La surcharge (overloading) est la possibilité de définir des méthodes possédant le même nom
mais dont les arguments sont différents.

• Quand une méthode surchargée est invoquée, le compilateur sélectionne automatiquement la

méthode dont le nombre et le type des arguments correspondent au nombre et au type des
paramètres passés dans l’appel de la méthode.

• Des méthodes surchargées peuvent avoir des types de retour différents à condition qu’elles aient
des arguments différents.

35
 CHAPITRE III

Surcharge de méthodes – Exemple Les bases de Java

class Additionneur {
public static int somme(int a, int b){ // 1 public static void main(String[]
return (a+b); args){
}
public static int somme(int a, int b, int c){ // 2 int a=4;
return (a+b+c); int b=10;
} float c=15.4f;
float d=3.5f;
public static float somme(float a, float b){ // 3
return (a+b);
int s1 = somme(a,b); // 1
}
int s2 = somme(a,b,a);// 2
public static float somme(int a, int b){ float s3 = somme(c,d);// 3
//4 interdit à cause de 1
return ((float)a+(float)b); System.out.println("s1= "+s1+"
} s2= "+s2+" s3= "+s3);
}
}

36
 CHAPITRE III

Les tableaux en java - Définition Les bases de Java

• Un tableau est une variable qui peut stocker plusieurs valeurs, de même type, à la fois, chacune
étant numérotée ;

• Les éléments d’un tableau peuvent être:

• Des variables d’un type primitif (int, boolean, double, char, …)

• Des références sur des objets (à voir dans la partie Classe et Objet)

• Exemple: tableaux de notes des élèves:

Nom du Indices Notes[8]
Notes[0] Notes[1]
tableau
0 1 2 3 4 5 6 7 8
Notes[ ] 14 12 1 4 16.5 13 9 10 2

Valeurs 37
 CHAPITRE III

Les tableaux en java - Création Les bases de Java

• Création d’un tableau

1. Déclaration : déterminer le type du tableau

2. Dimensionnement : déterminer la taille du tableau

3. Initialisation : initialiser chaque case du tableau

38
 CHAPITRE III

Les tableaux en java - Déclaration Les bases de Java

• La déclaration précise simplement le type des éléments du tableau

type[] monTableau;

• Peut s’écrire également Une déclaration de tableau ne doit pas préciser de dimensions
int monTableau[5]; // Erreur
type monTableau[];

• Exemple:

double resultats[];
char[] lettres;
String[] employes;

39
 CHAPITRE III

Les tableaux en java - Dimensionnement Les bases de Java

• Le nombre d’éléments du tableau sera déterminé au moment de sa création en utilisant le mot

clé new.
• La taille déterminée à la création du tableau est fixe, elle ne pourra plus être modifiée par la
suite:
int[] monTableau; // Déclaration
OU int[] monTableau= new int[3];
monTableau = new int[3]; // Dimensionnement

• La création d’un tableau par new

• Alloue la mémoire en fonction du type de tableau et de sa taille
• Initialise le contenu du tableau à 0 dans le cas des types simples
• Récupérer la longueur d’un tableau avec :
monTableau.length
40
 CHAPITRE III

Les tableaux en java - Initialisation Les bases de Java

• Les tableaux peuvent être initialisés par l'intermédiaire d'une liste de valeurs:
int[] notes = {10, 9, 12, 14, 16, 20, 19, 18};
String [] jours={ "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi",
"Dimanche"}

• Comme en C/C++ les indices commencent à zéro.

• L’accès à un élément d’un tableau s’effectue suivant cette forme:

monTab[varInt]; // varInt >= 0 et <monTab.length

• Si vous rencontrez l'erreur, ArrayIndexOutOfBoundsException….c'est que vous avez demandé une

case du tableau qui n'existe pas.
• On peut, aussi, initialiser un tableau comme suit:
int[] monTab = new int[3];
monTab[0] = 1; monTab[1] = 2; monTab[2] = 3;
41
 CHAPITRE III

Les tableaux en java – Exemple1 Les bases de Java

Quelles erreurs ont été commises dans le programme suivant ?

public static void main (String args[])

Résultats
{
int n=10 ; 1. OK
final int p=5 ;
2. OK
/*1*/ int t1[] = {1, 3, 5} ;
/*2*/ int t2[] = {n-1, n, n+1} ; 3. OK
/*3*/ int t3[] = {p-1, p, p+1} ;
4. Erreur (une seule ligne)
/*4*/ int t4[] ;
t4 = {1, 3, 5} ; 5. OK
/*5*/ float x1[] = {1, 2, p, p+1} ;
6. Erreur
/*6*/ float x2[] = {1.25, 2.5, 5} ;
/*7*/ double x3[] = {1, 2.5, 5.25, 2*p} ; 7. OK
}

42
 CHAPITRE III

Les tableaux en java – Exemple2 Les bases de Java

Que se passera-t-il si l’on exécute le programme suivant ?

public class Tableaux{

Résultats
public static void main (String args[]){
1
int t1[] = {1, 2, 3} ;
2
int t2[] = new int[4] ;
3
for (int i=0 ; i<4 ; i++ ) t2[i] = 2*i ;
t2 = t1 ; ArrayIndexOutOfBounds
Exception
for (int i=0 ; i<4 ; i++)
System.out.println (t2[i]) ;
}
}

43
 CHAPITRE III

Les tableaux en Java - Multidimensionnels Les bases de Java

• Tableaux dont les éléments sont eux mêmes des tableaux:

• Déclaration
type[][] monTableau;

• Tableaux rectangulaires
• Dimensionnement :
monTableau = new type[2][3];

• Tableaux non-rectangulaires
• Dimensionnement :
monTableau = new type[2];
monTableau[0] = new type[2];
monTableau[1] = new type[3];

44
 CHAPITRE III

Les tableaux en Java - Exercice Les bases de Java

• En utilisant les tableaux, écrire un programme java permettant de calculer la moyenne d’un
nombre de notes saisies par un utilisateur.

45