Syntaxe du langage Java

Les commentaires
 /* commentaire sur une ou plusieurs lignes */
 Identiques à ceux existant dans le langage C
 // commentaire de fin de ligne
 Identiques à ceux existant en C++
 /** commentaire d'explication */
 Les commentaires d'explication se placent
généralement juste avant une déclaration
(d'attribut ou de méthode)
 Ils sont récupérés par l'utilitaire javadoc et
inclus dans la documentation ainsi générée.

2
Instructions, blocs et blancs
 Les instructions Java se terminent par un
;
 Les blocs sont délimités par :
{ pour le début de bloc
} pour la fin du bloc
Un bloc permet de définir un regroupement
d’instructions. La définition d’une classe ou
d’une méthode se fait dans un bloc.
 Les espaces, tabulations, sauts de ligne
sont autorisés. Cela permet de présenter
un code plus lisible.
3
Point d’entrée d’un programme Java
 Pour pouvoir faire un programme
exécutable il faut toujours une classe qui
contienne une méthode particulière, la
méthode « main »
 c’est le point d’entrée dans le programme : le
microprocesseur sait qu’il va commencer à
exécuter les instructions à partir de cet endroit
public static void main(String arg[ ])
{
…/…
}

4
Exemple (1)

La classe est l’unité de

Fichier [Link] base de nos programmes.
Le mot clé en Java pour
public class Bonjour définir une classe est
class
{ //Accolade débutant la classe Bonjour
public static void main(String args[])
{ //Accolade débutant la méthode main
/* Pour l’instant juste une instruction */
[Link](“bonjour”);
} //Accolade fermant la méthode main
} //Accolade fermant la classe Bonjour

5
Exemple (2)

Fichier [Link] Accolades délimitant le

début et la fin de la définition
de la class Bonjour
public class Bonjour
{
public static void main(String args[])
{
Accolades délimitant le début
[Link](“bonjour”); et la fin de la méthode main

}
} Les instructions se terminent
par des ;

6
Exemple (3)

Fichier [Link] Une méthode peut recevoir

des paramètres. Ici la méthode
public class Bonjour main reçoit le paramètre args
qui est un tableau de chaîne
{ de caractères.

public static void main(String args[])

{
[Link](“bonjour”);
}
}

7
Compilation et exécution (1)

Le nom du fichier est nécessairement

Fichier [Link] celui de la classe avec l’extension
.java en plus. Java est sensible à la
casse des lettres.
Compilation en bytecode
java dans une console DOS:
javac [Link] public class Bonjour
Génère un fichier
[Link] {
Exécution du programme
(toujours depuis la console public static void main(String[] args)
DOS) sur la JVM :
java Bonjour {
Affichage de « bonjour »
dans la console [Link](“bonjour”);
}
}
8
Compilation et exécution (3)
 Pour résumer, dans une console DOS, si j’ai un
fichier [Link] pour la classe Bonjour :
 javac [Link]
 Compilation en bytecode java
 Indication des erreurs de syntaxe éventuelles
 Génération d’un fichier [Link] si pas d’erreurs
 java Bonjour
 Java est la machine virtuelle
 Exécution du bytecode
 Nécessité de la méthode main, qui est le point d’entrée
dans le programme

9
Identificateurs (1)
 On a besoin de nommer les classes, les
variables, les constantes, etc. ; on parle
d’identificateur.
 Les identificateurs commencent par
une lettre, _ ou $
Attention : Java distingue les majuscules des
minuscules
 Conventions sur les identificateurs :
 Si plusieurs mots sont accolés, mettre une
majuscule à chacun des mots sauf le premier.
 exemple : uneVariableEntiere
 La première lettre est majuscule pour les classes
et les interfaces
 exemples : MaClasse, UneJolieFenetre
10
Identificateurs (2)

 Conventions sur les

identificateurs :
 La première lettre est minuscule pour
les méthodes, les attributs et les
variables
 exemples : setLongueur, i, uneFenetre
 Les constantes sont entièrement en
majuscules
 exemple : LONGUEUR_MAX

11
Les mots réservés de Java
abstract default goto null synchronized

boolean do if package this

break double implements private throw

byte else import protected throws

case extends instanceof public transient

catch false int return true

char final interface short try

class finally long static void

continue float native super volatile

const for new switch while

12
Les types de bases (1)
 En Java, tout est objet sauf les types de base.
 Il y a huit types de base :
 un type booléen pour représenter les variables ne pouvant prendre
que 2 valeurs (vrai et faux, 0 ou 1, etc.) : boolean avec les valeurs
associées true et false
 un type pour représenter les caractères : char
 quatre types pour représenter les entiers de divers taille : byte,
short, int et long
 deux types pour représenter les réelles : float et double
 La taille nécessaire au stockage de ces types est
indépendante de la machine.
 Avantage : portabilité
 Inconvénient : "conversions" coûteuses

13
Les types de bases (2) : les entiers
 Les entiers (avec signe)
 byte : codé sur 8 bits, peuvent représenter
des entiers allant de -27 à 27 –1 (-128 à
+127)
 short : codé sur 16 bits, peuvent
représenter des entiers allant de -215 à
215 –1
 int : codé sur 32 bits, peuvent représenter
des entiers allant de -231 à 231 –1
 long : codé sur 64 bits, peuvent
représenter des entiers allant de -263 à 263 –
1
14
Les types de bases (3) : les entiers
 Opérations sur les entiers
 opérateurs arithmétiques +, -, *
 / :division entière si les 2 arguments sont des
entiers
 % : reste de la division entière

 exemples d’opérations:
 15 / 4 donne 3
 15 % 2 donne 1

15
 Les types de bases (4) : les entiers
 Opérations sur les entiers (suite)
 les opérateurs d’incrémentation ++
et de décrémentation et --
 ajoute ou retranche 1 à une variable
int n = 12;
n ++; //Maintenant n vaut 13
 n++; « équivalent à » n = n+1;
n--; « équivalent à » n = n-1;
 8++; est une instruction illégale
 peut s’utiliser de manière suffixée : ++n. La différence avec
la version préfixée se voit quand on les utilisent dans les
expressions.
En version suffixée la (dé/inc)rémentation s’effectue en
premier int m=7; int n=7;
int a=2 * ++m; //a vaut 16, m vaut 8
int b=2 * n++; //b vaut 14, n vaut 8

16
Les types de bases (5) : les réels

 Les réels
 float : codé sur 32 bits, peuvent
représenter des nombres allant de -
1035 à + 1035
 double : codé sur 64 bits, peuvent
représenter des nombres allant de -
10400 à +10400

17
Les types de bases (6) : les réels
 Les opérateurs
 opérateurs classiques +, -, *, /
 attention pour la division :
 15 / 4 donne 3 division entière
 15 % 2 donne 1
 11.0 / 4 donne 2.75
(si l’un des termes de la division est un
réel, la division retournera un réel).
 puissance : utilisation de la méthode
pow de la classe Math.
 double y = [Link](x, a) équivalent à
x^a, x et a étant de type double

18 P.O.O Java B.M

Les types de bases (7) : les booléens
 Les booléens
 boolean
contient soit vrai (true) soit faux (false)
 Les
opérateurs logiques de
comparaisons
 Egalité : opérateur ==
 Différence : opérateur !=
 supérieur et inférieur strictement à :
opérateurs > et <
 supérieur et inférieur ou égal :
opérateurs >= et <=

19 P.O.O Java B.M

Les types de bases (8) : les booléens
 Notation
boolean x;
x= true;
x= false;
x= (5==5); // l ’expression (5==5) est évaluée et
la valeur est affectée à x qui vaut alors vrai
x= (5!=4); // x vaut vrai, ici on obtient vrai si 5 est différent
de 4
x= (5>5); // x vaut faux, 5 n'est pas supérieur strictement à 5
x= (5<=5); // x vaut vrai, 5 est bien inférieur ou égal à 5

20 P.O.O Java B.M

Les types de bases (9) : les booléens
 Les autres opérateurs logiques
 et logique : &&
 ou logique : ||
 non logique : !
 Exemples : si a et b sont 2 variables
booléennes
boolean a,b, c;
a= true;
b= false;
c= (a && b); // c vaut false
c= (a || b); // c vaut true
c= !(a && b); // c vaut true
c=!a; // c vaut false
21 P.O.O Java B.M
Les types de bases (10) : les
caractères
 Les caractères
 char : contient une seule lettre
 le type char désigne des caractères en
représentation Unicode
 Codage sur 2 octets contrairement à
ASCII/ANSI codé sur 1 octet. Le codage
ASCII/ANSI est un sous-ensemble d’Unicode
 Plus d’information sur Unicode à :
[Link]

22 P.O.O Java B.M

Les types de bases (11) : les
caractères

 Notation
char a,b,c; // a,b et c sont des variables du type
char
a='a'; // a contient la lettre 'a'
b= '\u0022' //b contient le caractère guillemet : "
c=97; // x contient le caractère de rang 97 : 'a'

23 P.O.O Java B.M

Les types de bases (12)
exemple et remarque

int x = 0, y = 0;
float z = 3.1415;
double w = 3.1415;
long t = 99L;
boolean test = true;
char c = 'a';

 Remarque importante :
 Java exige que toutes les variables soient
définies et initialisées. Le compilateur sait
déterminer si une variable est susceptible
d'être utilisée avant initialisation et
produit une erreur de compilation.
24 P.O.O Java B.M
Les structures de contrôles (1)
 Lesstructures de contrôle
classiques existent en Java :
 if,else
 switch, case, default, break
 for
 while
 do, while

25 P.O.O Java B.M

Les structures de contrôles (2) : if /
else
 Instructions conditionnelles
 Effectuer une ou plusieurs instructions seulement
si une certaine condition est vraie
if (condition) instruction;
et plus généralement : if (condition)
{ bloc d’instructions}
condition doit être un booléen ou renvoyer une valeur
booléenne
 Effectuer une ou plusieurs instructions si une
certaine condition est vérifiée sinon effectuer
d’autres instructions
if (condition) instruction1; else instruction2;
et plus généralement if (condition) { 1er bloc
d’instructions} else {2ème bloc d’instruction}
26 P.O.O Java B.M
Les structures de contrôles (3) : if /
else

[Link]

import [Link].*;

public class Max

{
public static void main(String args[])
{
Console console = [Link]();
int nb1 = [Link]([Link]("Entrer un entier:"));
int nb2 = [Link]([Link]("Entrer un autre entier:"));
if (nb1 > nb2)
[Link]("l'entier le plus grand est "+ nb1);
else
[Link]("l'entier le plus grand est "+ nb2);
}
}

27 P.O.O Java B.M

Les structures de contrôles (4) : while
 Boucles indéterminées
 On veut répéter une ou plusieurs instructions un
nombre indéterminés de fois : on répète
l’instruction ou le bloc d’instruction tant que une
certaine condition reste vraie
 nous avons en Java une première boucle while
(tant que)
 while (condition) {bloc d’instructions}
 les instructions dans le bloc sont répétées tant
que la condition reste vraie.
 On ne rentre jamais dans la boucle si la
condition est fausse dès le départ

28 P.O.O Java B.M

Les structures de contrôles (5) : while

 Boucles indéterminées
 un autre type de boucle avec le while:
 do {bloc d’instructions} while (condition)
 les instructions dans le bloc sont répétées
tant que la condition reste vraie.
 On rentre toujours au moins une fois dans
la boucle : la condition est testée en fin de
boucle.

29 P.O.O Java B.M

Les structures de contrôles (6) : while
[Link]

import [Link].*;

public class Facto1

{
public static void main(String args[])
{
int n, result,i;
n = [Link]([Link]().readLine("Entrer une valeur pour n:"));
result = 1; i = n;
while (i > 1)
{
result = result * i;
i--;
}
[Link]("la factorielle de "+n+" vaut "+result);
}
}

30 P.O.O Java B.M

Les structures de contrôles (7) : for

 Boucles déterminées
 On veut répéter une ou plusieurs instructions un
nombre déterminés de fois : on répète l’instruction ou
le bloc d’instructions pour un certain nombre de pas.
 La boucle for
for (int i = 1; i <= 10; i++)
[Link](i); //affichage des nombres de 1 à 10
 une boucle for est en fait équivalente à une boucle
while
for (instruction1; expression1; expression2) {bloc}
… est équivalent à …
instruction 1; while (expression1) {bloc; expression2}}

31 P.O.O Java B.M

Les structures de contrôles (8) : for
[Link]

import [Link].*;

public class Facto2

{
public static void main(String args[])
{
int n, result,i;
n = [Link]([Link]().readLine("Entrer une valeur pour n:"));
result = 1;
for(i =n; i > 1; i--)
{
result = result * i;
}
[Link]("la factorielle de "+n+" vaut "+result);
}
}

32 P.O.O Java B.M

Les structures de contrôles (9) : switch

 Sélection multiples
 l’utilisation de if / else peut s’avérer lourde quand
on doit traiter plusieurs sélections et de multiples
alternatives
 pour cela existe en Java le switch / case assez
identique à celui de C/C++
 La valeur sur laquelle on teste doit être un char ou
un entier (à l’exclusion d’un long).
 L’exécution des instructions correspondant à une
alternative commence au niveau du case
correspondant et se termine à la rencontre d’une
instruction break ou arrivée à la fin du switch

33 P.O.O Java B.M

Les structures de contrôles (10) :
switch

[Link]

import [Link].*; Variable contenant la valeur

que l’on veut tester.
public class Alternative
{ Première alternative :
public static void main(String args[]) on affiche Un et on sort
{ du bloc du switch au break;
int nb = [Link]([Link]().readLine("Entrer une valeur pour n:"));
switch(nb)
{ Deuxième alternative :
case 1: on affiche Deux et on sort
[Link]("Un"); break; du bloc du switch au break;
case 2:
[Link]("Deux"); break;
default:
[Link]("Autre nombre"); break; Alternative par défaut:
} on réalise une action
} par défaut.
34 } P.O.O Java B.M
Les tableaux (1)
 Les tableaux permettent de stocker plusieurs
valeurs de même type dans une variable.
 Les valeurs contenues dans la variable sont
repérées par un indice
 En langage java, les tableaux sont des objets
 Déclaration
 int tab [ ];
String chaines[ ];
 Création d'un tableau
 tab = new int [20]; // tableau de 20 int
 chaines = new String [100]; // tableau de 100 chaine

35 P.O.O Java B.M

Les tableaux (2)
 Le nombre d'éléments du tableau est
mémorisé. Java peut ainsi détecter à
l'exécution le dépassement d'indice et
générer une exception. Mot clé length
 Il est récupérable par [Link]
int taille = [Link]; //taille vaut 20
 Comme en C/C++, les indices d’un tableau
commencent à ‘ 0 ’. Donc un tableau de taille
100 aura ses indices qui iront de 0 à 99.

36 P.O.O Java B.M

Les tableaux (3)

 Initialisation
tab[0]=1;
tab[1]=2; //etc.
noms[0] = new String( "Boule");
noms[1] = new String( "Bill");//etc
 Création et initialisation simultanées
String noms [ ] = {"Boule","Bill"};
Point pts[ ] = { new Point (0, 0), new Point (10, -1)};

37 P.O.O Java B.M

Les tableaux (4)

[Link]
public class Tab1
{
public static void main (String args[])
{
Pour déclarer une variable tableau
int tab[ ] ;
on indique le type des éléments du
tab = new int[4];
tableau et le nom de la variable
tab[0]=5;
tableau suivi de [ ]
tab[1]=3;
tab[2]=7;
tab[3]=tab[0]+tab[1]; on utilise new <type> [taille];
} pour initialiser le tableau
}
On peut ensuite affecter
des valeurs au
différentes cases du
Les indices vont toujours
tableau :
de 0 à (taille-1)
<nom_tableau>[indice]
38 P.O.O Java B.M
Les tableaux (5)

[Link] Mémoire
public class Tab1
{
public static void main (String args[])
{
int tab[ ] ; 0x0000
0x258
tab = new int[4];
tab[0]=5; 0
tab[1]=3; 0
tab[2]=7; 0
tab[3]=tab[0]+tab[1]; 0
}
}

39 P.O.O Java B.M

Les tableaux (6)

[Link]
Mémoire
public class Tab1
{
public static void main (String args[])
{ 0x258
int tab[ ] ;
tab = new int[4];
tab[0]=5; 5
0
tab[1]=3; 0
3
tab[2]=7; 0
7
tab[3]=tab[0]+tab[1]; 0
8
}
}

40 P.O.O Java B.M

Les tableaux (7)

[Link] Mémoire
public class Tab2
{
0x0258
public static void main (String args[])
{
String tab[ ] ; 0x0106
tab = new String[4]; 0x0116
tab[0]=new String("Pierre"); 0x0126
tab[1]=new String("Paul"); 0x0136
tab[2]=new String("Jacques");
tab[3]=new String("Philippe");
}
"Pierre"
}
"Paul"
"Jacques"
"Philippe"

41 P.O.O Java B.M

La classe String (1)

 Attention ce n’est pas un type de base. Il s'agit

d'une classe défini dans l’API Java (Dans le
package [Link])
String s="aaa"; // s contient la chaîne "aaa" mais
String s=new String("aaa"); // identique à la ligne précédente
 La concaténation
 l’opérateur + entre 2 String les concatène :
String str1 = "Bonjour ! ";
String str2 = null;
str2 = "Comment vas-tu ?";
String str3 = str1 + str2; / * Concaténation de chaînes : str3
contient " Bonjour ! Comment vas-tu ?"

42 P.O.O Java B.M

Différences entre objets et types de
base

Mémoire
3
int x=3,y=3;
x == y est vrai 3

0x768
0x852

String s1="abc",s2="abc"; Abc

s1 == s2 est faux... ....

Quand on compare 2 variables d’un type de base

on compare leur valeur. Quand on compare 2 objet
Abc
avec les opérateurs on compare leur référence (leur
....
adresse en mémoire). Introduction de la méthode
equals() pour les objets : [Link](s2) est vrai

43 P.O.O Java B.M

La classe String (2)

 Longueur d’un objet String :

 méthode int length() : renvoie la longueur de la chaîne
String str1 = "bonjour";
int n = [Link](); // n vaut 7
 Sous-chaînes
 méthode String substring(int debut, int fin)
 extraction de la sous-chaine depuis la position debut
jusqu’à la position fin non-comprise.
String str2 = [Link](0,3); // str2 contient la valeur "bon"
 le premier caractère d’une chaîne occupe la position 0
 le deuxième paramètre de substring indique la position
du premier caractère que l ’on ne souhaite pas copier

44 P.O.O Java B.M

La classe String (3)

 Récupération d’un caractère dans une chaîne

 méthode char charAt(int pos) : renvoie le caractère
situé à la position pos dans la chaîne de caractère à
laquelle on envoie se message
String str1 = "bonjour";
char unJ = [Link](3); // unJ contient le caractère 'j'
 Modification des objets String
 Les String sont inaltérables en Java : on ne peut
modifier individuellement les caractères d’une
chaîne.
 Par contre il est possible de modifier le contenu de
la variable contenant la chaîne (la variable ne
référence plus la même chaîne).
str1 = [Link](0,3) + " soir"; /* str1 contient
maintenant la chaîne "bonsoir" */

45 P.O.O Java B.M

La classe String (4)

 Les chaînes de caractères sont des objets :

 pour tester si 2 chaînes sont égales il faut utiliser la
méthode boolean equals(String str) et non ==
 pour tester si 2 chaînes sont égales à la casse près il
faut utiliser la méthode boolean
equalsIgnoreCase(String str)
String str1 = "BonJour";
String str2 = "bonjour"; String str3 = "bonjour";
boolean a, b, c, d;
a = [Link]("BonJour"); //a contient la valeur true
b = (str2 = = str3); //b contient la valeur false
c = [Link](str2);//c contient la valeur true
d = "bonjour".equals(str2); //d contient la valeur true
46 P.O.O Java B.M
La classe String (5)

 Quelques autres méthodes utiles

 boolean startsWith(String str) : pour tester si
une chaine de caractère commence par la
chaine de caractère str
 boolean endsWith(String str) : pour tester si
une chaîne de caractère se termine par la
chaine de caractère str
String str1 = "bonjour ";
boolean a = [Link]("bon");//a vaut true
boolean b = [Link]("jour");//b vaut true

47 P.O.O Java B.M

La classe String (7)

Plus d’informations
dans les
documentations
de l’API dans le
package
[Link]

48 P.O.O Java B.M

La classe Math

 Les fonctions mathématiques les plus connues

sont regroupées dans la classe Math qui
appartient au package [Link]
 les fonctions trigonométriques
 les fonctions d’arrondi, de valeur absolue, ...
 la racine carrée, la puissance, l’exponentiel, le
logarithme, etc.
 Ce sont des méthodes de classe (static)
double calcul = [Link] ([Link](5,2) +
[Link](7,2));
double sqrt(double x) : racine carrée de x
double pow(double x, double y) : x puissance y

49 P.O.O Java B.M