You are on page 1of 11

Segment 2 : Java sans objet : instructions, types et

expressions de base (1/5)

2 Concepts de base........................................................................................................................10
2.1 Instruction..........................................................................................................................12
2.1.1 Déclaration/initialisation............................................................................................13
2.1.2 Affectation.................................................................................................................13
2.2 Types de base.....................................................................................................................13
2.2.1 Type numérique .........................................................................................................13
2.2.2 Type Booléen.............................................................................................................14
2.3 Expressions ........................................................................................................................15
2.3.1 Expression Arithmétique ...........................................................................................15
2.3.2 Expression de comparaison .......................................................................................16
2.3.3 Expressio n booléenne ................................................................................................17
2.3.4 Expression d’affectation............................................................................................18
2.3.5 Evaluation des expressions ........................................................................................19

Marc Tizzano (EMN) 9


2 Concepts de base

Nous allons maintenant présenter quelques définitions un peu indigestes. Elles seront
illustrées par des exemples et seront revues dans la suite du cours.

Identificateur : Un identificateur est constitué de lettres, de chiffres du caractère $ et du


caractère souligné. Il ne peut pas commencer par un chiffre. Les identificateurs permettent
de nommer les concepts manipulés par le programme.

A360, $1, sont des identificateurs


un_identificateur_tres_long est un identificateur
2A n’est pas un identificateur
voyelle est un identificateur

Variable : Les identificateurs peuvent être des variables, ils ont alors un type (voir la
définition plus bas dans le chapitre) et correspondent à un emplacement mémoire. Les
variables mémorisent des valeurs qui évoluent au cours du temps. Par exemple :

int an;//an est une variable


char uneVoyelle;//uneVoyelle est une variable

Constante : Certains identificateurs sont définis comme des variables qui ne peuvent
changer de valeur. On les appelle des constantes, et on utilise les mots réservés final static
pour le spécifier.

final static float TAUX_TVA = 18.6 //Une constante

Java a défini quelques constantes couramment utilisées en mathématique :

Math.PI;
Math.E;

Notez que la notation Math.QuelqueChose indique que QuelqueChose appartient à


la bibliothèque appelée Math.
Le code suivant affiche la valeur de Pi :

System.out.println("La valeur de Pi est " + Math.PI);

Pour rendre les programmes plus lisibles, on utilise des conventions de nommage. Les plus
utilisées sont les suivantes :

Marc Tizzano (EMN) 10


• Les variables commencent par une minuscule. Si plusieurs mots constituent la
variable, leur première lettre est mise en majuscule. Par exemple :
ageDuCapitaine, maVariable.
• Les constantes sont écrites en majuscule et les mots qui constituent la constante sont
séparés par un blanc souligné _. Par exemple :
TAUX_CONVERSION_EURO

Mot réservé : certains identificateurs sont réservés pour définir des éléments de syntaxe.
Ce sont les mots clefs comme class, public ; ils ne peuvent être utilisés comme variable ou
comme définition de concepts propres au programmeur. Voici la liste des mots réservés en
Java :

abstract boolean break byte byvalue case


cast catch char class const continue
default do double else extends false
final finally float for future generic
goto if implements import inner instanceof
int interface long native new null
operator outer package private protected public
rest return short static super switch
synchronized this throw throws transient true
try var void volatile while

Certains de ces mots clefs (comme const, future) ne sont pas actuellement utilisés, ils sont
réservés à un usage futur.

Type : Un type est un ensemble de données ayant des propriétés communes. Entier (int en
Java) est un exemple de type. Java est fortement typé, cela veut dire que chaque expression
du langage possède un type et que toute incohérence est rejetée. Par exemple l’addition de
2 entiers est légale, alors que l’addition de 2 booléens est impitoyablement rejetée. De plus
cette vérification se faisant à la compilation, le typage est dit statique.

INFO02EXE01
Indiquez si ces identificateurs sont corrects :
package, CompteBancaire, Euro, throws, true, Cki, Bonjour, $$_$, 2PlusEnPlusFort,

Indiquez si ces variables de type int sont correctes (testez ) :


int package; int CompteBancaire; int Euro; int throws; int true; int Cki; int Bonjour; int
$$_$; int 2PlusEnPlusFort;

Maintenant que nous avons défini nos briques de base, construisons des structures plus
complexes.

Marc Tizzano (EMN) 11


2.1 Instruction

Une instruction est soit une instruction simple soit une instruction composée.

• Une instruction simple se termine par un ";" (point- virgule)

//une instruction (d’affectation)


valeur = (ageDuCapitaine + monAge);

• Une instruction composée ou bloc est une suite d’instructions regroupées entre
accolades {}

//instruction composée de 3 instructions simples


{
valeur = (ageDuCapitaine + monAge);
if (valeur > 56) System.out.println(“Ou la la !”);
valeur = 33;
}

Notez que les blocs d’instructions sont indentés (c'est-à-dire que des espaces ont été
ajoutés en début de ligne). Cela n’est pas obligatoire, mais rend le code plus lisible.

Une instruction simple est :


• une déclaration de variable
• sans initialisation : int largeur;
• avec initialisation : int largeur = 10;
• une affectation
• largeur = 10;
• un appel de méthode
• augmenterLargeur(10);
• une instruction de contrôle qui peut être
• une sélection
• if (largeur<3) …;
• une répétition
• while (largeur < 3) …;

Chacun de ces types d'instruction simple est une expression et une expression est une
suite "correcte" d’opérateurs et d’opérandes.

Dans ce paragraphe nous allons expliquer les deux premiers types d'expression (nous
verrons les autres types plus loin).

Marc Tizzano (EMN) 12


2.1.1 Déclaration/initialisation

Chaque variable définie par le programmeur doit être déclarée. Elle peut être déclarée
quand on en a besoin et elle peut être initialisée dans la même expression (cf. paragraphe
précédent sur les variables ).

int a; // Déclaration de a variable de type int


int aa=2; //Déclaration et initialisation

a=aa+56;
int i; //Déclaration d'une variable i après une instruction

2.1.2 Affectation

Une affectation se compose d’une variable, d’un opérateur d’affectation, suivi d’une
expression.

a=5;//est une affectation


a = a + 5;//est une affectation
a+=5; // est une autre affectation
a = a<<3; //est encore une affectation

2.2 Types de base

En Java les types de base sont les entiers (byte, short, int, long), les nombres à virgule
flottante (float, double), les booléens (boolean), les caractères (char), les chaînes de
caractères (String).

En réalité les chaînes de caractères ne sont pas des types de base. Néanmoins nous les
avons placés dans ce paragraphe car en pratique elles sont utilisées comme un type de base
et elles en possèdent toutes les caractéristiques.

Détaillons maintenant chacun de ces types (dans ce segment et dans les suivants).

2.2.1 Type numérique

On distingue les entiers et les nombres à virgules.

Les entiers sont signés (entiers relatifs) et peuvent être représentés sur 8 bits (type byte) ,
16 bits (short), 32 bits (int) et 64 bits (long). Contrairement à d’autres langages, cette
représentation est indépendante de la plate-forme sur laquelle s'exécute le programme.
Les constantes littérales (par exemple 367 est une constante littérale) peuvent être
représentées selon plusieurs systèmes de notation (octal et hexadécimal). Elles sont notées
0x (caractère zéro) en hexadécimal et commence par un 0 (caractère zéro) en octal.

Marc Tizzano (EMN) 13


Le code suivant :

int a = 020;//constante littérale en octal


int b = 0x10; ;//constante littérale en hexadécimal
int c=16;// constante littérale

System.out.print("a = ");
System.out.println(a);
System.out.print("b = ");
System.out.println(b);
System.out.print("c = ");
System.out.println(c);

Produit le résultat :

a = 16
b = 16
c = 16

Notez que l'affichage se fait toujours en décimal.

Les nombres à virgule respectent la norme IEEE 754. Ils peuvent être définis
• en simple précision, ils sont représentés sur 32 bits : float
• ou en double précision, ils sont représentés sur 64 bits : double
Les constant es littérales peuvent s'écrire avec ou sans exposant.

double d = 1.414;//notation sans exposant


double dd = 1414e-3;//notation avec exposant = 1414 10-3
float f = 3.414;

2.2.2 Type Booléen

Comme pour tous les langages modernes, les booléens ne peuvent prendre que 2 valeurs :
true ou false. Le type booléen est un type à part entière, à ne pas confondre avec le type
entier.
Par exemple :

boolean v = 1;

est interdit

Marc Tizzano (EMN) 14


2.3 Expressions

Les expressions sont des suites d’opérandes (des variables ou des constantes) liées par des
symboles désignant des opérations (appelées opérateurs) à effectuer :

(largeur*hauteur) est une expression


a<<2 est une autre expression
" Bonjour "+ nom est encore une expression

En java on distingue les expressions selon le type des opérandes. Nous verrons qu’en
certaines occasions et selon des règles précises, Java peut changer (on emploie le terme de
promotion) le type de certains opérandes. Mais n’anticipons pas.

2.3.1 Expression Arithmétique

Ces expressions ressemblent aux expressions du langage Pascal. Les seuls opérateurs
nouveaux sont les opérateurs ++ et -- . Ils permettent d’incrémenter ou de décrémenter les
variables de type numérique. Suivant qu’ils sont postfixés ou préfixés leur comportement
est différent :
• j= ++i; est équivalent à {i=i+1 ; j=i};
• j= i++; est équivalent à {j=i ; i=i+1};

int i =2;
int ii =2;
int j;
j = i++; //j est egal à 2 et i est égal à 3
j = ++ii; // j et ii sont egaux à 3

Nom Description Type opérandes


+ Addition Ajoute 2 valeurs num x num : num1
- Soustraction Soustrait 2 valeurs num x num : num
* Multiplication Multiplie 2 valeurs num x num : num
/ Division Divise 2 valeurs num x num : num
% Modulo Retourne le reste de la division num x num : num
entière.
+ Plus unaire Aucun effet num : num
- Moins unaire Change le signe num : num
++ Incrément Ajoute 1 (ou 1.0) num : num
-- Décrément Soustrait 1 (ou 1.0) num : num

1
num x num : num signifie que l'opérateur prend 2 types numériques (entier et flottant) en paramètre et
retourne un type numérique en résultat.

Marc Tizzano (EMN) 15


Exemple 2 Résultat
+ 3+2 5
- 3-2 1
* 3*2 6
/ 3/2 1
3/2.0 1.5
% 14% 5 4
= x=8 met la valeur 8 dans x
+ +x 6
- -x -6
++ ++x x vaut 7
-- --x x vaut 5

INFO02EXE02
Construisez une expression qui transforme des degrés Fahrenheit en degrés Celsius.
Sachant que pour obtenir des Celsius, il faut enlever 32 au Fahrenheit puis multiplier par 5
et diviser par 9.

2.3.2 Expression de comparaison

Comme leur nom l’indique, les opérateurs de comparaison, permettent de comparer deux
expressions de type quelconque.

Nom Effet Type opérandes


== Egalité Retourne true, si les deux type 3 x type : bool
membres de l’expression sont
égaux. Sinon retourne false.
!= Inégalité Retourne true, si les deux type x type : bool
membres de l’expression sont
différents. Sinon retourne false.
< Inférieur Retourne true, si le membre type x type : bool
gauche de l’expression est
inférieur au membre droit.
Sinon retourne false.
> Supérieur Retourne true, si le membre type x type : bool
gauche de l’expression est
supérieur au membre droit.
Sinon retourne false.
<= Inférieur ou égal Retourne true, si le membre type x type : bool
gauche de l’expression est
inférieur ou égal au membre
droit. Sinon retourne false.
>= Supérieur ou égal Retourne true, si le membre type x type : bool
gauche de l’expression est
supérieur ou égal au membre

2
Si on utilise x dans l’exemple on suppose que sa valeur est 6
3
type représente un type quelconque

Marc Tizzano (EMN) 16


Nom Effet Type opérandes
droit. Sinon retourne false.

Attention à ne pas confondre le symbole = qui représente une affectation et == qui


représente l’égalité.

if(a=1) …

est incorrecte en Java.

Pour tester l’égalité il faut écrire :

if (a==1) …

2.3.3 Expression booléenne

Nom Effet Type opérandes


& ET booléen Retourne true si les 2 bool x bool : bool
expressions booléennes sont
évaluées à true. Sinon retourne
false.
| OU inclusif Retourne true si au moins une bool x bool : bool
booléen des 2 expressions booléennes
est évaluée à true. Sinon
retourne false.
^ OU exclusif Retourne true si une et une bool x bool : bool
booléen seule des 2 expressions
booléennes est évaluée à true.
Sinon retourne false.
! NON logique Inverse l’expression booléenne bool : bool
&& ET logique Retourne true si les 2 bool x bool : bool
expressions booléennes sont
évaluées à true. Sinon retourne
false. Interrompt l’évaluation
dès que le résultat est acquis
(voir remarque)
|| OU inclusif Retourne true si au moins une bool x bool : bool
logique des 2 expressions booléennes
est évaluée à true. Sinon
retourne false. Interrompt
l’évaluation dès que le résultat
est acquis (voir remarque)

Attention il ne faut pas confondre && (resp. || ) et & (resp. |). En effet && réalise une
évaluation "paresseuse". En effet dès que la valeur de l’expression est acquise l’évaluation
est interrompue. Considérons l’expression suivante :

c=a && b;

Marc Tizzano (EMN) 17


Si a est faux, quelle que soit la valeur de b, c sera faux. Donc b n’est pas évaluée.
Considérons maintenant l’expression

c= a & b;

Quelle que soit la valeur de a, b est évaluée. C’est ainsi qu'après

int i= 3;
c = (1 > 2) & (i++ < 10);

i vaut 4.

Alors qu'après

int i= 3;
c = (1 > 2) && (i++ < 10);

i vaut 3.

2.3.4 Expression d’affectation

Ces expressions permettent d’effectuer des affectations. Seul = est vraiment important. Les
autres permettent simplement de simplifier le code.

Nom Description Type opérandes


= Affectation Affecte une valeur à une variable Type quelconque x valeur : valeur
op= op affectation Affecte une valeur à une variable Type quelconque x valeur : valeur
avec op +,-,*,/ après avoir réalisé l’opération op.
etc. x op= y est pratiquement
équivalent à x = x op y (cf.
Remarque)

Exemple 4 Résultat
= x=8 met la valeur 8 dans x
+= x+=8 met la valeur 14 (6+8)
dans x

x += y n’est pas strictement équivalent à x = x + y. En effet considérons les deux


expressions suivantes (avec i égal à 5):

i++ += 2;//Expression 1
i++ = i++ + 2; //Expression 2

4
Si on utilise x dans l’exemple on suppose que sa valeur est 6

Marc Tizzano (EMN) 18


Après l’expression 1 i vaut 8 (5+1+2) alors qu’après l’expression 2 i vaut 9 (5+1+1+2).
Ces expressions sont à déconseiller et on écrira plutôt :

i += 3;
ou
i += 4;

2.3.5 Evaluation des expressions

Les expressions sont évaluées selon des règles très précises. Si une expression est
ambiguë, comme 2+3*4, l’évaluation de l’expression se fait en considérant la priorité des
opérateurs. L'expression 2+3*4 est évaluée comme suit :
• 3*4 à 12 car * est prioritaire sur + . Puis 2 + 12 à 14 par application de l'addition.
Le tableau suivant indique, en ordre décroissant, la priorité des principaux opérateurs en
Java :

1 ! ++ --
2 */%
3 +-
4 <<>>
5 == != <<=> >=
6 &
7 ^
8 |
9 &&
10 ||
11 = += -= *= /= %= <<=>>= &= ^= |=

Par exemple * est prioritaire sur +.

Quand les opérateurs ont la même priorité, l’expression est évaluée de gauche à droite,
excepté pour les opérateurs de priorité 11, pour lesquels l’évaluation se fait de droite à
gauche.

INFO02EXE03
Qu'affiche le code suivant :
System.out.println(3+4 + " : nbre de jours dans la semaine");
Et celui ci
System.out.println (" Nbre de jours dans la semaine : "+ 3 + 4 );
Expliquez. Comment, sans faire directement le calcul, modifier la deuxième expression
pour imprimer le résultat correct ?.

Marc Tizzano (EMN) 19