Dossier 1 Principaux éléments de syntaxe Java

Java Dossier 1 page 1
IUT Montpellier — Informatique — Licence professionnelle 2009/10
Programmation par objets en Java
Dossier 1
Principaux éléments de syntaxe Java
Cette partie n'aborde pas les notions de classe et d'objet (et ne considère que
certains aspects de la notion de tableau, car tableaux et objets sont gérés de la
même façon).
Types et variables
Il existe des types primitifs et 2 types construits : les classes et les tableaux.
Types primitifs
Type
Contenu Taille Exemples de valeurs littérales
boolean booléen 1 bit
(en principe) true false
char Caractère
UNICODE 16 bits 'a'
'\n' '\t' '\''
b
yte entier signé 8 bits -128 128
011 (préfixe 0 en base octale)
0xF (préfixe 0x en base hexa)
short entier signé 16 bits
int entier signé 32 bits
long entier signé 64 bits
float nombre flottant
simple précision
32 bits 0.3 2. .5
2E2 (2 x 102)
2E-3 (2 x 10-3)
par défaut, une valeur littérale
est de type double
0.3f --> de type float
double nombre flottant
double précision
64 bits
Attention 'a' est une valeur de type caractère (type simple char) alors que "a" est une chaîne
de caractères (type classe String)
Déclaration et initialisation de variable
Une variable est toujours typée : soit par un type simple, soit par un type construit (objet ou
tableau). Dans le deuxième cas, la variable est appelée référence (référence sur un objet ou
sur un tableau).
int i,j; // déclaration de 2 variables
int i = 0; // déclaration et initialisation d'une variable
boolean ok = false;
final int max = 10; // déclaration d'une constante
// l'initialisation est alors obligatoire
Bidule b = null; // Bidule est un nom de classe
/* déclaration d'une variable de type classe, donc destinée à désigner un
objet (on l'appelle une "référence"); initialisation à "ne repère aucun
objet" */

Java Dossier 1 page 2
Instructions
Les instructions de Java sont calquées sur celles de C/C++
Instruction vide ;
Affectation emplacement = expression ;
• L'affectation retourne une valeur (la valeur de l'expression)
Bloc d'instructions
{ séquence d'instructions }
• Si le bloc est composé d'une seule instruction, les {} ne sont pas nécessaires
Instructions conditionnelles
if (expression) bloc
if (expression) bloc else bloc
• Il existe aussi une instruction switch équivalent au case du Pascal :
switch (expression)
{
case valeur_constante : bloc
...
case valeur_constante : bloc
default : bloc // clause facultative
}
• Lorsqu'un case est satisfait, le bloc correspondant est exécuté, et si ce bloc ne se termine pas
par une instruction break; le bloc suivant est lui aussi exécuté (etc...)
Instructions itératives
while (expression) bloc équivalent au while du Pascal
do bloc while (expression) équivalent au repeat du Pascal
(mais test d'arrêt inversé)
for (expression-1; expression-test ; expression-2)
bloc
équivalent à
expression-1;
while(expression-test)
{
bloc
expression-2;
}
... donc aussi puissant qu'un while
Instructions de "sortie" :
break; termine le plus petit while, do, for , switch qui le contient
continue; termine l'itération courante de la boucle la plus interne qui le contient
Attention,
égal s'écrit ==

Java Dossier 1 page 3
Opérateurs
Un opérateur retourne une valeur d'un certain type. L'affectation est à la fois une instruction
(elle effectue une action) et un opérateur (elle retourne une valeur).
Opérateurs arithmétiques + - * / %
L'opérateur / effectue une division entière lorsque les deux opérandes sont des entiers.
Opérateurs d'incrémentation / décrémentation ++ --
Opérateurs d'affectation non simples += -= *= /=
a++ ; // incrémentation de a de 1
a+=2; // équivalent à a = a + 2;
Opérateurs à résultat de type booléen > >= < <=
! non
== égal != différent
&& et || ou
Les opérateurs logiques && et || effectuent une évaluation "incomplète" de l'expression
logique (si l'évaluation du premier opérande suffit à déterminer la valeur de l'expression, le
deuxième opérande n'est pas évalué : on les appelle aussi des "ET-ALORS" et "OU-
SINON").
Premières applications
• Hello World
/* Fichier Exemple.java
Un fichier source java comporte (au plus) une classe publique qui donne
son nom au fichier.
*/
public class Exemple
{
public static void main (String args[])
// args est un tableau d'objets de la classe String
{
System.out.println("Hello, world!");
}
}
Exécuter une application consiste à exécuter la méthode main d'une classe (cette exécution
impliquant généralement la création d'objets et l'appel de méthodes d'autres classes). La
signature de la méthode main est forcément celle ci-dessus.
Une méthode statique (comme la méthode main ci-dessus) est une méthode qui n'est pas
invoquée à partir d'un objet. Les méthodes statiques sont plutôt des fonctions au sens des
langages de programmation non objets, elles n'auraient pas leur place dans un langage
complètement basé sur des objets.
Attention à
la casse !

Java Dossier 1 page 4
• Passage d'arguments à la méthode main
via le tableau args...
public class ExempleArgs
{
public static void main (String args[])
{
if (args.length == 0)
System.out.println("Hello inconnu!");
else
System.out.println("Hello" + args[0]);
// l'indice du premier élément d'un tableau est 0
}
}
L'instruction System.out.println(...) ne prend qu'un seul argument. Pour afficher plusieurs
chaînes de caractères avec un seul appel, on peut concaténer ces chaînes en une seule grâce à
l'opérateur +.
Syntaxe des méthodes (fonctions)
<spécificateurs> <type de retour> <nom de la méthode>
(<liste des paramètres formels>)
{ <corps de la méthode> }
Exemple 1 :
public class Util
{
public static void ecrit (String a, String b)
{ System.out.println(a + " : " + b); }
}
Exemple de code qui utilise la méthode écrit :
// La classe Scanner appartient au package java.util
Scanner sc = new Scanner(System.in);
System.out.println("Entrez une première chaine");
String s1 = sc.nextLine();
System.out.println("Entrez une seconde chaine");
String s2 = sc.nextLine();
Util.ecrit(s1,s2);
Si le type de retour n'est pas void, la méthode doit retourner une valeur de ce type, et ceci
dans tous les cas. Elle le fait par l'instruction return :
return expression;
// ceci retourne la valeur de l'expression et termine la méthode
Exemple 2 :
public static int carre (int a)
{ return a * a;}
Lorsque le type de retour est void, return peut être utilisé pour terminer prématurément la
méthode.
Exemple 3 :
public static void main (String args[])
{
if (args.length == 0)
{ System.out.println("Presente-toi!");
return; // fin main
}
else
System.out.println("Hello" + args[0]);
// etc.... suite de la méthode main
}

Java Dossier 1 page 5
Exercice 1 : Problème de syntaxe
(a) Considérons les lignes suivantes extraites d'un programme :
boolean ok = false;
int x;
// .... du code susceptible de modifier la valeur de la variable ok;
if (ok = true)
x = 1;
else x = 0;
System.out.println(x);
Le programme affiche toujours 1. Pourquoi?
(b) Combien de tours de boucle sont effectués à l'exécution du bloc suivant?
while (ok = true)
{
..........
}
(c) Même question
while (ok = false)
{
..........
}
Exercice 2 : boucle for
Remplacer la boucle ci-dessous par une boucle for équivalente.
int k = 0;
int i = 1;
while (i <10)
{ k = k + i; // s'écrit aussi k += i;
i++;
}
//valeur de k ici?
Exercice 3 : parcours totaux / partiels
On considère une variable T de type tableau d'entiers. On suppose que le tableau est rempli
de valeurs significatives. Vous n'avez donc pas à vous préoccuper de la création et de
l'initialisation de T.
A propos de tableaux :
1. les indices commencent à 0
2. la taille d'un tableau désigné par T s'obtient grace à son attribut length
T. length retourne le nombre d'éléments ("cases") de T
3. les indices d'un tableau vont donc de 0 à (T.length - 1)
4. T[i] désigne l'élément (la case) d'indice i , si i est un indice valide
1. Ecrire une suite d'instructions qui fait la somme des valeurs contenues dans T. On
stockera le résultat dans une variable.
2. Ecrire une suite d'instructions qui répond à la question "T contient-il la valeur 0 ?"On
stockera le résultat dans une variable (de type booléen donc).