Les bases du

langage
Rajae El Ouazzani

2014-2015
Historique de JAVA
 Créé en 1995 par la société Sun Microsystems.
 Langage de programmation inspiré du C++.
 Initialement conçu pour réaliser des programmes
interactifs sur le Web.
 Libre (General Public License) depuis novembre 2006.
 Racheté par Oracle en 2010.
 Version actuelle (depuis juillet 2011) : Java 7 [1]

2014-2015 2
 Présentation de JAVA [2]
 Langage 100% Objet : Tout code fait partie d’un objet (à voir plutard).
 Java est à la fois un langage compilé et interprété.
 Le code source Java est compilé en un pseudo-code universel binaires,
destiné à une machine virtuelle JVM qui va l’interpréter. Il est appelé
souvent "J-code" ou "bytes code".
 Le bytes code Java désigne un flux d'octets binaire au format d'une
classe java.

2014-2015 3
Présentation de JAVA (Suite) [3,4,5,6]
 La JVM représente un interpréteur. Elle se comporte comme un
processeur réel, exécute des instructions fondées sur une machine à
pile et gère cette pile en mémoire.
 Le code de Java est implicitement portable. La même application
peut être exécutée sur toute plate-forme fournissant
l'environnement JVM.
 La JVM est fourni dans le JRE (Java Runtime Environment=
L'environnement d'exécution Java).
 JRE est une famille de logiciels qui permet l'exécution des
programmes écrits en langage de programmation Java.

2014-2015
 public class MyProg {
public static void main(String[] args) {
Exemple }
System.out.println("Hello, World");

2014-2015 5
Savoir plus sur les langages compilés
et interprétés [7]
 un langage compilé, c'est un langage qui est, avant de pouvoir
l'exécuter, traduit en langage machine par un compilateur.
 Un langage interprété est un langage qui sera traduit dans un langage
plus ou moins similaire au langage machine. Ce dernier sera exécuté
par un interpréteur (machine virtuelle).
 Le même code source peut être utilisé, sans le recompiler, sur
plusieurs plateformes matérielles différentes.
 Mais un interpréteur (logiciel) doit être installé sur la plateforme
cible.

2014-2015 6
La plateforme Java [8]
 La plupart des plateformes sont une combinaison entre le
système d'exploitation (software) et le hardware.
La plateforme Java est une plateforme software seulement. Elle
travaille sur différentes plateformes hardware.
 La plateforme Java a deux composants:
 Java Virtual Machine JVM;
 Java Application Programming Interface (API).
 API: c'est une large collection de software composants groupés
en bibliothèques appelés packages.

2014-2015 7
Chapitre 1: Les bases du langage
Java

2014-2015 8
Plan du chapitre 1: Les bases du langage Java
 Section 1: La syntaxe de Java
 Les identificateurs
 Les littéraux
 Les mots clés
 Les commentaires
 Les expressions
 Les opérateurs
 Section 2: Structures de contrôle du déroulement
 Les boucles
 Les instructions de contrôle des boucles
 Les instructions conditionnelles
 Section 3: Les types de données en Java
 Les types de données primitifs
 Les types de données composites

9
Section 1: La syntaxe de Java

2014-2015 10
 Les identificateurs [9]
 Est composé de lettres(A..Z, a..z), _, $, chiffres (0..9);
 Il commence par une lettre, sous tiré ( _ ) ou le symbole dollar ( $ );
 Un identificateur ne doit pas commencer par un chiffre.
 Un identificateur ne peut pas contenir d’espace vide (tabulation, espace,
nouvelle ligne ou retour chariot).
 Les identificateurs différencient les minuscules et les majuscules.
 Il ne doit pas être un mot clé (à voir plutard);
 Remarques:
 D’habitude, les identificateurs en Java sont mnémoniques (facile à
mémoriser).
 En général, les identificateurs des classes démarrent par une lettre
majuscule:
 MaClasseExemple: exemple du nom d’une classe en Java.

 monObjetExemple: exemple du nom d’un objet en Java.

Les littéraux [9]
 Un littéral, ou une constante, représente une valeur qui ne
change jamais.
 Il y’a une distinction entre un identificateur qui représente une
valeur et un littéral qui est une valeur.
 Par exemple, le nombre 20 est un littéral; l’identificateur age
représente un nombre qui peut être égal à 20. En Java, un
littéral peut être un nombre (entier ou virgule flottante), un
booléen, un caractère ou une chaîne de caractères.
 Types de littéraux: entiers, en virgules flottantes, booléens,
caractères et chaines de caractères.

2014-2015 12
 Les littéraux
 Littéraux entiers: peuvent prendre 3 formats: décimal,
hexadécimal (commencent toujours par 0X) et octal (commencent
par 0).
 Un littéral entier peut être stocké dans les types de données byte,
short, int ou long. Par défaut, Java stocke les littéraux entiers dans
le type de données int, limité à 32 bits.
 Pour stocker un littéral entier dans le type de données long, qui
peut recevoir des valeurs de 64 bits, on ajoute le caractère l ou L à
la fin du littéral. Par exemple, le littéral 9999L est stocké dans le
type long.

2014-2015 13
 Les littéraux
 littéraux en virgule flottante:
 Un littéral en virgule flottante est un nombre contenant un point
décimal et/ou un exposant. Un littéral en virgule flottante suit une
notation standard ou scientifique. Par exemple, 123.456 est la
notation standard, alors que 1.23456e+2 est la notation
scientifique.
 Les littéraux en virgule flottante sont du type double sur 64 bits
(type par défaut) ou du type float sur 32 bits. Pour stocker un
littéral en virgule flottante dans le type float, ajoutez la lettre f ou F
à la fin du nombre.

2014-2015 14
 Les littéraux
 littéraux booléens:
 true / false
 littéraux de type caractère:
 Un littéral caractère représente un caractère Unicode unique. Les
littéraux caractère sont toujours mis entre guillemets simples
(quotes); par exemple, ‘A’ et ‘9’ sont des littéraux caractère. Java
utilise le type char pour stocker des caractères uniques.
 Le jeu de caractères Unicode, sur 16 bits, remplace le code ASCII
de 8 bits pour inclure les symboles et les caractères d’autres
langues.
NB: Système de codage créé en 1998, Unicode spécifie un nombre unique pour chaque
caractère, quels que soient la plate-forme, le logiciel et la langue utilisés. Alors que
l'ASCII étendu à 8 bits pouvait prendre en compte un maximum de 256 caractères,
Unicode traduit chaque caractère en 16 bits et peut donc prendre en compte plus de
65.000 caractères uniques, et traiter informatiquement tous les systèmes d'écriture de la
2014-2015 15
planète.
Les littéraux
 littéraux de type chaîne
 Un littéral chaîne représente une suite de caractères.
 En Java, les chaînes sont toujours entre guillemets doubles.
 Java gère les chaînes différemment de C/C++; ce dernier
représente une chaîne par un tableau de caractères, alors que Java
utilise les classes String et StringBuffer.
 Ainsi, de tous les types de littéraux dont nous avons parlé, seuls
les littéraux chaîne sont stockés par défaut sous forme d’objets.
 Les chaînes seront détaillées plutard.

2014-2015 16
 Les mots clés
abstract double int super
Un mot clé est
boolean else interface switch
un identificateur
prédéfini qui a break extends long synchronized
une signification byte false native this
spéciale pour le byvalue final new threadsave
compilateur Java case finally null throw
et qui ne peut
catch float package transient
pas être redéfini.
char for private true
class goto protected try
const if public void
continue implements return while
default import short
do instanceof static
Les commentaires
 En Java, il y a trois styles de commentaires:
 /* commentaire sur plusieurs lignes */
 // commentaire jusqu'à la fin de la ligne
 /** utilisé par javadoc pour documentation automatique */

2014-2015 18
Les expressions [9]
 Une expression est une combinaison significative d’identificateurs,
de mots clés, de symboles et d’opérateurs qui a une valeur.
 De façon générale, une expression est tout ce qui peut être mis du
côté droit d’un signe d’affectation.
 s = "Bonjour à tous"; // Affectations de variables
 x = 123.4; // Affectations de variables
 y = (x * 5) / 2; /* Les expressions d’opérateurs utilisent des combinaisons
de variables, littéraux, appels de méthodes (sqrt), opérateurs et symboles. */
 x = obtenirValeur(); /* Appels de la méthode obtenirValeur(), qui
renvoie une valeur attribuée à x. */
 Personne p1 = new Personne(); /* cette expression alloue / affecte de
la mémoire à l’objet p1 de type Personne. Les expressions d’affectation
d’objet sont des expressions d’appel de méthode spéciales.

2014-2015 19
 Les opérateurs [9]
 Les opérateurs sont des symboles spéciaux qui exécutent une
fonction particulière sur des opérandes. Exemple: c=a+b
 Il y a cinq types généraux d’opérateurs:
 opérateurs arithmétiques,
 opérateurs logiques,
 opérateurs de comparaison,
 opérateurs d’affectation et
 opérateurs au niveau bits.
 Chaque catégorie peut être subdivisée en unaire et binaire. Les
opérateurs unaires utilisent un seul opérande, alors que les opérateurs
binaires utilisent deux opérandes.
 La préséance détermine la priorité des opérateurs.

2014-2015 20
 Les opérateurs arithmétiques
 Java fournit un jeu complet d’opérateurs destinés aux calculs arithmétiques.
Opérateur Définition Préséance
++/-- Incrémentation/ décrémentation automatique 1
+/- Plus / moins unaire 2
* Multiplication 4
/ Division 4
% Modulo 4
+/- Addition / soustraction 5

 Exemple pour ++/-- : int x, y = 3, z;

x = ++y; /* la variable y est incrémentée de 1, puis sa nouvelle valeur
(4) est attribuée à x. */
z = y--; /* la décrémentation automatique se fait après l’affectation de
la valeur actuelle de y à z. càd z a la valeur 4. */
2014-2015 21
 Les opérateurs logiques
 Les opérateurs logiques (ou booléens) permettent de regrouper des
expressions booléennes pour déterminer certaines conditions.
 Ces opérateurs exécutent les opérations booléennes standard (AND, OR,
NOT et XOR).
Opérateur Définition Préséance
! Complément logique unaire (NOT) 2
& Evaluation AND 9
^ XOR 10
| Evaluation OR 11
&& Court circuit AND 12
|| Court circuit OR 13

Court-circuités: les deux opérandes ne seront pas systématiquement examinés. Il y a

en effet des situations dans lesquelles la valeur de l'opération peut être déterminée
rien qu'en connaissant la valeur de l'opérande de gauche. 22
 Exemple
1. ! false // true
2. true && false // false
3. true || true // true
4. true ^ true // false

5. false && x // false

6. true || x // true
 La valeur de l’exemple 5 est false. En effet, si on consulte la table de vérité du
ET logique, on se rend compte qu'à partir du moment où l'un des opérandes
vaut false, le résultat est toujours false.
 Un raisonnement similaire d'applique pour l’exemple 6. En effet, en consultant
la table de vérité du OU logique, on voit que lorsqu'un des deux opérandes vaut
true, le résultat est toujours true.
2014-2015 23
 Les opérateurs de comparaison
 C’est pour comparer des valeurs. A la différence des opérateurs logiques, les
opérateurs de comparaison n’évaluent qu’une seule expression.

Opérateur Définition Préséance

< Inférieur à 7
> Supérieur à 7
<= Inférieur ou égal à 7
>= Supérieur ou égal à 7
== Egal à 8
!= Différent de 8

 L’opérateur d’égalité permet de comparer deux variables objet du même type.

Dans ce cas, le résultat de la comparaison n’a la valeur true que si les deux
variables font référence au même objet.
2014-2015 24
 Exemple
Personne p1 = new Personne();
Personne p2 = new Personne();
boolean r1 = p1 == p2; //r1 a la valeur false
p1 = p2;
boolean r2 = p1 == p2; //r2 a la valeur true

 Comme p1 et p2 font référence à des objets différents, le premier test

d’égalité donne le résultat false (bien qu’ils soient du même type).
 La deuxième comparaison donne le résultat true, puisque les deux
variables représentent maintenant le même objet.
 Remarque: La méthode equals() est utilisée la plupart du temps pour
comparer des objets. Cette méthode, définie dans la classe Object, doit
être implémentée (écrire son code) dans une sous-classe de la classe
Object, avant que l’égalité des objets de la classe puisse être contrôlée. 25
 Les opérateurs d’affectation
 Ces opérateurs permettent d’attribuer des valeurs aux variables.
Opérateur Définition Préséance
= Affectation 15
+= Ajout et affectation 15
-= Soustraction et affectation 15
*= Multiplication et affectation 15
/= Division et affectation 15
&= AND avec affectation 15
|= OR avec affectation 15
^= XOR avec affectation 15
Exemples :
 int y = 2; y *= 2; //identique à (y = y * 2)
 boolean b1=true, b2=false; b1 &= b2; //identique à (b1 = b1 & b2)
2014-2015 26
 Les opérateurs au niveau bits
 Il y a deux types d’opérateurs au niveau bits :
 Les opérateurs de décalage qui permettent de décaler les chiffres binaires
d’un nombre entier vers la droite ou la gauche et
 Les opérateurs booléens.
 Exemple:
short i = 13; //i a la valeur 0000000000001101, un short est codé sur 2 Octets.
i = i << 2; //i a la valeur 0000000000110100, ajout de 2 bits.
i >>= 3; //i a la valeur 0000000000000110, sustraction de 3 bits.
 Dans la deuxième ligne, l’opérateur de décalage des bits décale tous les bits de
i de deux positions vers la gauche.
 L’opérateur de décalage sur la droite décale ensuite les bits de trois positions
vers la droite.

2014-2015 27
  Le tableau suivant donne la liste complète des opérateurs Java au
niveau bits :
Opérateur Définition Préséance
~ Complément au niveau bits 2
<< Décalage gauche signé 6
>> Décalage droit signé 6
>>> Décalage droit par ajout de zéros (non signé) 6
& AND au niveau bits 9
| OR au niveau bits 10
^ XOR au niveau bits 11
<<= Décalage gauche avec affectation 15
>>= Décalage droit avec affectation 15
>>>= Décalage droit par ajout de zéros avec affectation 15

2014-2015 28
Un opérateur spécial " ? : "
 Nous avons cité deux types d’opérateurs: unaire et binaire. De
plus, il y a un opérateur ternaire que Java tire de C, l’opérateur ? :
 Sa syntaxe est :
expression1? expression2: expression3;
 expression1 est évaluée en premier. Si sa valeur est true,
expression2 est calculée, sinon expression3 est calculée.
Exemple:
int x = 3, y = 4, max; if(x>y) max=x;
max = (x > y)? x: y; /* équivalent à : else max=y */
 En général, max reçoit la valeur de x ou de y, selon que x est
supérieur à y ou non.

2014-2015 29
Section 2: Structures de contrôle du
déroulement

2014-2015 30
Les boucles [9]
 En Java, il y a trois façons de créer des boucles:
 while() {}
 do {} while()
 for

2014-2015 31
Boucle while
 La boucle while est utilisée pour créer un bloc de code qui sera
exécuté tant qu’une condition particulière est satisfaite.
 Syntaxe:
while (condition) {
code à exécuter dans une boucle
// incrémentation / décrémentation
}
 La boucle commence par tester la condition. Si la condition a la
valeur true, la boucle exécute la totalité du bloc. Ensuite, elle teste
la condition une nouvelle fois et répète ce processus jusqu’à ce
que la condition prenne la valeur false. A ce moment, la boucle
achève son exécution.
2014-2015 32
Exemple
int x = 0;
//imprime "Bouclage" 10 fois
while (x < 10){
System.out.println("Bouclage");
x++;
}

Remarque:
 Vous pouvez également arrêter l’exécution d’une boucle
avec les instructions return, continue ou break.

2014-2015 33
 La boucle do while
 La boucle do while ressemble à la boucle while, sauf que do while
évalue la condition après les instructions et non avant. Le code suivant
montre la boucle while précédente convertie en boucle do while:
int x = 0;
do{
System.out.println("Bouclage");
x++;
}while (x < 10);
Remarque:
 La différence principale entre les deux boucles est que, à la différence
de la boucle while, la boucle do while s’exécute toujours au moins une
fois.

2014-2015 34
La boucle for
 La boucle for est la plus puissante des constructions de boucles.
Voici la syntaxe générale d’une boucle for :
for (expr init; expr condition; expr opération) {
}
Exemple:
for (int x = 0; x < 10; x++){
System.out.println("Bouclage");
}

2014-2015 35
Instructions de contrôle des boucles [9]

 break
 continue.

2014-2015 36
 break
 L’instruction break permet de sortir d’une boucle avant que la condition
de test soit respectée. Quand la boucle rencontre une instruction break,
elle se termine immédiatement en ignorant le code restant.
Exemple :
int x = 0;
while (x < 10){
System.out.println("Bouclage");
x++;
if (x == 5) break;
else
//faire quelque chose d’autre
}
 Dans cet exemple, la boucle s’arrête quand x est égal à 5.
37
continue
 L’instruction continue permet d’ignorer le reste de la boucle et de
reprendre l’exécution à l’itération suivante de la boucle.
Exemple:
for ( int x = 0 ; x < 10 ; x++){
if(x == 5)
continue; //revient au début de la boucle avec x=6
System.out.println("Bouclage");
}

 Cet exemple n’imprime pas “Bouclage” si x a la valeur 5.

2014-2015 38
Instructions conditionnelles [9]
 Avec les instructions conditionnelles, le code a la possibilité de
prendre des décisions. En Java, il y a deux structures
conditionnelles:
 l’instruction if-else et
 l’instruction switch.

2014-2015 39
L’instruction if-else
 La syntaxe de l’instruction if-else est la suivante:
if (condition1) {
//blocCode 1
}
else if (condition2) {
//blocCode 2
}
else {
//blocCode 3
}

2014-2015 40
Exemple
if ( x % 2 == 0)
System.out.println("x est pair");
else
System.out.println("x est impair");
if (x = y)
System.out.println("x est égal à y");
else if (x < y)
System.out.println("x est inférieur à y");
else
System.out.println("x est supérieur à y");

2014-2015 41
L’instruction switch
 D’une certaine façon, l’instruction switch est une version spécialisée
de l’instruction if-else. Voici la syntaxe générale de l’instruction
switch:

switch (expression){
case valeur1: blocCode1;
break;
case valeur2: blocCode2;
break;
default : blocCode3;
}
2014-2015 42
 Remarques importantes
 Les blocs de code n’ont pas besoin d’être mis entre accolades.
 Le bloc de code default correspond au bloc else d’une instruction if-else.
 Les blocs de code sont exécutés selon la valeur d’une variable ou d’une
expression, pas d’une condition.
 La valeur de l’expression doit être de type nombre entier (ou d’un type qui
peut être transtypé en int sans risque, comme char).
 Les valeurs case doivent être des expressions constantes du même type que
l’expression.
 Le mot clé break est facultatif. Il est nécessaire pour terminer l’exécution de
l’instruction switch une fois qu’un code de bloc s’exécute. Si, par exemple,
break n’est pas mis après blocCode1 et si blocCode1 est exécuté, alors
blocCode2 s’exécute immédiatement après blocCode1.
 Si un bloc de code doit être exécuté quand l’expression a une valeur parmi
plusieurs, il faut énumérer les valeurs-chacune étant précédée d’un mot clé
case et suivie par un point-virgule. 43
Exemple 1
int grade = 4;
switch (grade) {
case 0;
case 1:
case 2: System.out.println("échoué"); break;
case 3: System.out.println("passable"); break;
case 4: System.out.println("bien"); break;
case 5: System.out.println("très bien");break;
case 6: System.out.println("avec félicitations");break;
default: System.out.println("Ca n'existe pas!");
}

2014-2015 44
Exemple 2
switch (c){
case '1': case '3': case '5': case '7': case '9':
System.out.println("c est un chiffre impair"); break;
case '0': case '2': case '4': case '6': case '8':
System.out.println("c est un chiffre pair"); break;
case ' ':
System.out.println("c est un espace"); break;
default :
System.out.println("c n’est ni un chiffre ni un espace");
}

2014-2015 45
Section 3: Les types de données Java

2014-2015 46
 Présentation [9]
 En Java, il y a deux catégories de types de données :
 Le type de données intégrés/primitifs et
 Le type de données composites.
 Les types de données primitifs peuvent ensuite être divisés en trois
autres catégories: numérique, booléen et caractère. Ils sont compris
par le compilateur et ne nécessitent pas de bibliothèques spéciales.
(A la base, une bibliothèque spéciale fait référence à n’importe quelle
collection de code qui ne fait pas partie de la définition actuelle du
langage).
 Les types composites sont de deux sortes: tableaux et chaînes.
Généralement, les types composites nécessitent l’utilisation de
bibliothèques spéciales.
2014-2015 47
 Les types de données primitifs
Type Taille (bits) Valeurs min. et max. Désignation
boolean 1 true ou false valeur logique
char 16 0 à 0xFFFF (65535) caractère unicode (non
signé)
byte 8 -128 à 127 entier signé sur 1 octet
short 16 -32 768 à 32 767 entier signé sur 2 octets
int 32 -2 147 483 648 à 2 147 483 647 entier signé sur 4 octets
long 64 -9 223 372 036 854 775 808 à 9 223 entier signé sur 8 octets
372 036 854 775 807
float 32 +/-1.40239846e-45 à +/- réel 4 (norme IEEE 754)
3.40282347e+38
double 64 +/- 4.94065645841246544e-324 à réel 8 (norme IEEE 754)
+/- 1.79769313486231570e+308

48
 Exemple
public class VariablesExemples {
public static void main( String[] args ){
boolean result=true;
char option;
option = 'C';
double grade = 0.0;
}
}
Remarque :
 La taille des différents types de données est indépendante de la
machine hôte.

2014-2015 49
Types de données composites

 Les tableaux.
 Les chaines de caractères.

2014-2015 50
 Les tableaux [8]
 La déclaration d'un tableau se fait à l'aide d'une paire de crochets:
int [ ] nombre; // équivalent à int nombre[ ];
char voyelle[ ];
 À la différence de C, les tableaux en Java sont des objets de la classe
tableau. Ces déclarations n'introduisent que des références des
tableaux et n'allouent aucune place dans la mémoire, donc on ne peut
pas indiquer le nombre des éléments dans la déclaration.
 Pour allouer la place pour ces tableaux, on peut soit:
 Utiliser l'opérateur new:
int nombre[ ] = new int[10]; //un tableau de 10 éléments
 Affecter une série d'éléments au tableau au moment de sa création:
char voyelle[ ] = {'a', 'e', 'i', 'o', 'u'}; // un tableau de 5 éléments
2014-2015 51
 La taille d'un tableau est disponible grâce à la variable publique length:
int longueur = voyelle.length; //longueur = 5
char c=voyelle[0]; // accès au premier élément du tableau

 L’accès à un élément qui est à l'extérieur du tableau génère une exception:

ArrayIndexOutOfBoundsException de type RuntimeException.

 La méthode arraycopy() de la classe System sert à copier un certain nombre

d'éléments d'un tableau dans un autre:

System.arraycopy (objetsSource, positionSource, objetDestin, positionDestin, longueur)

La syntaxe de l’utilisation d’un méthode est: classe.méthode()

52
 Exemple
 Ajout d’un élément au tableau voyelle:
char voyelle[ ] = {'a', 'e', 'i', 'o', 'u'};
char tmp[ ] = new char[voyelle.length+1];
System.arraycopy(voyelle, 0, tmp, 0, voyelle.length);
tmp[voyelle.lemgth] = 'y';
voyelle[voyelle.length-1]
voyelle=tmp;
voyelle : 'a' 'e' 'i' 'o' 'u'

tmp : 'a' 'e' 'i' 'o' 'u' 'y'

tmp[voyelle.length]
tmp[tmp.length-1]

 Remarque: Il n'y a plus de références sur l'ancien objet et il sera

récupéré par le ramasse-miette. 53
 Parcours de tableau
 Pour parcourir complètement ou partiellement un tableau, il suffit d'utiliser une
boucle for.
Exemple de parcours et d’affichage des éléments d’un tableau sur la
console:
public class Array{
public static void main(String a[]){
int tab[] = {-3,4,-17,2,-1,8};
for(int i =0; i< tab.length; i++){
System.out.println(" "+tab[i]);
}
}
}
Résultat : -3 4 -17 2 -1 8
 Il ne faut pas oublier que le premier indice du tableau est 0, ensuite on parcourt
toutes les positions jusqu'à atteindre tab.length - 1.
54
 Parcours avec une boucle améliorée
 Java 5.0 offre une nouvelle boucle for qui permet de parcourir facilement
tous les objets qui représentent des collections d'objets. La syntaxe de cette
boucle for est la suivante:
for (<type_de_donnée> <nom_variable>:<collection_à_parcourir>) {
// Corps de la boucle
}
Exemple:
public class Array{
public static void main(String a[]){
int tab[] = {-3,4,-17,2,-1,8};
for(int nb :tab){
System.out.println(" "+nb);
}
}
} 2014-2015 55
 Java gère les tableaux à plusieurs dimensions avec des objets, se sont
des tableaux de tableaux. La syntaxe ressemble à celle de C:
int matrice [ ] [ ]; Résultat:
matrice = new int [3][8]; 30000000
matrice[0][0] = 3; 05000000
matrice [1][1] = 5; 00000000

 On peut créer des tableaux dont les lignes n'ont pas forcément la
même taille:
int mat[][] = new int[3][ ]; Résultat:
mat[0] = new int [3]; 000
mat[1] = new int[5]; 00000
0000
mat[2] = new int[4];

2014-2015 56
Exemple 1
public class MatriceEntiers{
public static void main(String a[]){
int mat[][] = {{3,4},{17,2,1,8}};
for(int i =0; i< mat.length; i++){
for(int j = 0; j< mat[i].length; j++)
System.out.print(" "+mat[i][j]);
System.out.println();
}
}
}
Résultat:
34
17 2 1 8
2014-2015 57
 Exemple 2
 public class MatriceChaines {
public static void main(String a[]){
String couleur[][] = {{"rouge","vert","bleu"},{"noir", "blanc"}};
for(String[] ligne :couleur){
for(String elm:ligne)
System.out.print(" "+elm);
System.out.println();
}
}
}
Résultat:
rouge vert bleu
noir blanc
2014-2015 58
Les chaines de caractères
 Les chaines de caractères sont traitées par les 2 classes
suivantes:
 La classe String: pour les chaines constantes.
 La classe StringBuffer: pour les chaines variables.

 Ces 2 classes seront détaillées dans le Chapitre 3.

2014-2015 59
 Références
[1] : https://www.java.com/fr/download/faq/release_dates.xml
[2] : http://refg.tu-sofia.bg/JavaCours/OOP.html
[3] : http://refg.tu-sofia.bg/JavaCours/OOP.html
[4] :
http://fr.wikipedia.org/wiki/Environnement_d%27ex%C3%A9cuti
on_Java
[5] : http://fr.wikipedia.org/wiki/Bytecode_Java
[6] : http://fr.wikipedia.org/wiki/Machine_virtuelle_Java
[7] : http://fr.openclassrooms.com/forum/sujet/compile-vs-interprete-
26416
[8] : http://refg.tu-sofia.bg/JavaCours/OOP.html
[9] : http://www.i3s.unice.fr/~riveill/cours/langage/99-java-intro.pdf
60