Dossier 1 Principaux éléments de syntaxe Java

IUT Montpellier — Informatique — Licence professionnelle
Programmation par objets en Java
2009/10
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
boolean
char
booléen
Caractère
UNICODE
entier signé
entier signé
entier signé
entier signé
nombre flottant
simple précision
1 bit (en principe)
16 bits
byte
short
int
long
float
Exemples de valeurs littérales
8 bits
16 bits
32 bits
64 bits
32 bits
true false
'a'
'\n' '\t' '\''
-128 128
011 (préfixe 0 en base octale)
0xF (préfixe 0x en base hexa)
0.3
2.
.5
2E2 (2 x 102)
2E-3 (2 x 10-3)
double
nombre flottant 64 bits
double précision
par défaut, une valeur littérale
est de type double
0.3f --> de type float
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 1
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)
Attention,
égal s'écrit ==
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
...
case valeur_constante
default
}
: bloc
: bloc
: 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
Java
Dossier 1
page 2
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
&& et
!= différent
|| 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 "OUSINON").
Premières applications
• Hello World
/* Fichier Exemple.java
Un fichier source java comporte (au plus) une classe publique qui donne
son nom au fichier.
*/
Attention à
public class Exemple
la casse !
{
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.
Java
Dossier 1
page 3
• 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 4
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;
i++;
}
//valeur de k ici?
// s'écrit aussi k += i;
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).
Java
Dossier 1
page 5
Exercice 4 : méthodes
(a) Le compilateur n'accepte pas cette méthode, pourquoi?
public static int max (int a, int b)
{ if (a>b) return a;
}
(b) Que dire de cette méthode?
public static int max (int a, int b)
{ if (a>b) return a;
else return b;
System.out.println("je suis passé par max");
}
Exercice 5 : parcours totaux/partiels (suite)
(TP)
Cet exercice fait suite à l'exercice 3.
1. Écrire une classe Exo5, qui comporte une méthode main effectuant les actions
suivantes :
a. Création et initialisation d'un tableau T contenant 5 entiers.
//voici une façon de créer un tableau
// un certain nombre de valeurs connues
initialisé
avec
int [] T = {10,20,0,4,-1}
// int [] est le type "tableau d'entiers"
b. Affichage de la somme des valeurs contenues dans T
c. Affichage de la réponse à la question "T contient-il la valeur 0?"
2. Ajouter à la classe Exo5 les deux méthodes somme et contient0 spécifiées cidessous. Remplacer une partie des instructions de votre méthode main par des appels
à ces méthodes.
public static int somme (int [] tab)
// retourne la somme des valeurs contenues dans tab
public static boolean contient0 (int [] tab)
// retourne vrai si tab contient la valeur 0, et faux sinon
Java
Dossier 1
page 6
Exercice 6 : passer des paramètres à main
(TP)
Dans cet exercice, on n'effectue aucune saisie utilisateur. Les données sont passées au
programme lors du lancement de son exécution, sous la forme de chaînes de caractères
rangées dans le tableau args (pour passer des arguments à la méthode main avec Eclipse :
utiliser l'onglet "arguments" de l'entrée de menu "Run…").
Écrire une classe Bonjour, pour qu'un appel avec les arguments Pim Pam Poum
provoque l'affichage suivant :
Bonjour, Pim!
Bonjour, Pam!
Bonjour, Poum!
Le nombre de paramètres fournis à l'appel peut être quelconque : en particulier, le cas où
aucun argument n'est fourni ne doit pas provoquer d'erreur d'exécution.
• Entraînement à la syntaxe java : écrire une version utilisant la boucle while, puis une
version utilisant la boucle for.
Exercice 7 : parcours de matrices : le carré magique
(TP)
Un carré magique est une matrice de taille n par n, dont les cases sont remplies de valeurs de
1 à n2, suivant les règles suivantes:
o Toutes les cases prennent des valeurs distinctes
o Les nombres sont disposés de manière à ce que leurs sommes sur chaque rangée ainsi
que sur chaque colonne soient égales.
Ecrire une méthode static boolean isValidMagicSquare(int[][] grille) qui indique si la
matrice passée en paramètre est un carré magique valide.
Java
Dossier 1
page 7