Programmation Orientée Objet

Langage Java

Sources principales :
Sites : www.java.sun.com
Livres : 1- Au cœur de Java 2 : Notions fondamentales
2- Au cœur de Java2 : Foctions avancées
De Cay S.Horstmann & Gary Cornell
3-Java 2 Codes_en_stock de Loic Fieux
(1, 2, 3 Edition Campus Press)
1
 JAVA
c'est quoi ?
• Une technologie développée par SUN Microsystems™ lancée
en1995

– Un langage de programmation
– Une plateforme , environnement logiciel dans lequel les
programmes java s'exécutent.

• Présente dans de très nombreux domaines d’application : des

serveurs d’applications aux téléphones portables et cartes à
puces(JME)

• Java dérive des langages C++ et SmallTalk.

2
 Le Langage Java
D’après SUN

• Dans un des premiers papiers* sur le langage JAVA, SUN le décrit

comme suit :

« Java : a simple, object-oriented, distributed,

robust, secure, architecture neutral, portable,
high-performance, multithreaded, and dynamic
language »

• White Paper :The Java Language Environment - James Gosling, Henry

McGilton - May 1996

http://java.sun.com/docs/white/langenv/

3
 Exemple de programme en
Le code de la classe doit être
enregistré dans un fichier de JAVA Tout code java doit être défini à
même nom (casse comprise) l'intérieur d'une classe
que la classe
1

3 public class HelloWorld {

HelloWorld.java

public static void main(String[ ] args) {

La description
de la
int i = 0; classe est
effectuée à
while (i < 5) { l'intérieur d'un
4 2 bloc
Le point {}
d'entrée System.out.println("Hello World !");
pour
i++;
l'exécution
est la }
méthode }
main() }

Compilation : javac HelloWorld.java Exécution : java HelloWorld. Hello World !

Hello world !
------------ ------------ Hello World !
--------- javac --------- java Hello World ! 4
Hello World !
HelloWorld.java HelloWorld.class
 Compilation d’un code source

♠ Un code source ne peut être exécuté directement par un

ordinateur

♠ Il faut traduire ce code source dans un langage que

l’ordinateur (le processeur de l'ordinateur) peut comprendre
(langage natif)

♠ Un compilateur est un programme qui effectue cette

traduction

5
 Compilation en Java → bytecode

♠ En Java, le code source n’est pas traduit directement

dans le langage de l’ordinateur

♠ Il est d’abord traduit dans un langage appelé « bytecode

», langage d’une machine virtuelle (JVM ; Java Virtual
Machine) définie par Sun

♠ Ce langage est indépendant de l’ordinateur qui va

exécuter le programme

6
 La compilation fournit du bytecode

Programme écrit en Java Programme source

UneClasse.java

Compilateur

Programme en bytecode, Bytecode

indépendant de l'ordinateur UneClasse.class
7
 Compilation avec javac
Sun fournit le compilateur javac avec le JDK

javac HelloWorld.java

crée un fichier « HelloWorld.class » qui contient le

bytecode, situé dans le même répertoire que le fichier
« .java »

On peut désigner le fichier à compiler par un chemin

absolu ou relatif :

javac SousRep/HelloWorld.java

8
 Le langage Java
Un langage compilé & interprété
• Compilation d'un programme JAVA : génération de byte-code

public class Test { 01100001

public static void main(String[ ] args) 11100000 javap –c Test
{ 11111010
javac 11101...
Désassemble Test.class
for (int i = 0; i < 10; i++)
System.out.println("Hello " + i); ...
}
0 iconst_0
}
1 istore_1
Test.class 2 goto 30
5 getstatic #10 <Field
Test.java byte-code java.io.PrintStream
8 new #5 <Class
code source java.lang.StringBuffer
11 dup
12 ldc #1 <String "Hello ">
….
27 iinc 1 1
• Le byte-code est : 30 iload_1
31 bipush 10
– proche d'un langage machine 33 if_icmplt 5
– indépendant de la platforme d'exécution (matériel + OS) 36 return

9
 Exécution du bytecode

Le bytecode doit être exécuté par une JVM

Cette JVM n'existe pas ; elle est simulée par un programme

qui :

– lit les instructions (en bytecode) du programme .class,

– les traduit dans le langage natif du processeur de

l’ordinateur

– lance leur exécution

10
 Exécution avec java

♠Sun fournit le programme java qui simule une JVM

Nom d’une classe
♠ java HelloWorld (pas d'un fichier) ;
pas de suffixe .class !

interprète le bytecode de la méthode main() de la classe

HelloWorld

♠ HelloWorld.class doit être dans le répertoire courant ou

dans un des emplacements indiqués par une option
-classpath ou par la variable CLASSPATH

11
 Les JVM

♠ Les systèmes qui veulent pouvoir exécuter un

programme Java doivent fournir une JVM

♠ A l'heure actuelle, tous les systèmes ont une JVM

(Linux, Windows, MacOs,…)

♠ Il existe aussi depuis peu quelques JVM « en dur »,

sous forme de processeurs dont le langage natif est le
bytecode ; elles sont rarement utilisées

12
 Le bytecode peut être exécuté par
n'importe quelle JVM

Bytecode
UneClasse.class
WRITE ONCE
RUN EVERYWHERE

JVM sous Unix, JVM sous Linux,

processeur SPARC processeur Intel

JVM sous Windows, JVM sous MacOS,

processeur Intel 13
processeur Motorola
 Avantages de la JVM pour Internet

♠ Grâce à sa portabilité, le bytecode d'une classe peut

être chargé depuis une machine distante du réseau, et
exécutée par une JVM locale

♠ La JVM fait de nombreuses vérifications sur le bytecode

avant son exécution pour s’assurer qu’il ne va effectuer
aucune action dangereuse

♠ La JVM apporte donc

– de la souplesse pour le chargement du code à exécuter
– mais aussi de la sécurité pour l'exécution de ce code

14
 Une certaine lenteur...

♠ Les vérifications effectuées sur le bytecode et l'étape

d'interprétation de ce bytecode (dans le langage natif du
processeur) ralentissent l'exécution des classes Java

♠ Mais les techniques « Just In Time (JIT) » ou « Hotspot »

réduisent ce problème :
Elles permettent de ne traduire qu'une seule fois en code
natif les instructions qui sont exécutées

15
 Java et les autres langages

♠ Java est devenu en quelques années un des langages de

développement les plus utilisés, surtout pour les applications
qui ont besoin d'une grande portabilité ou d'une grande
souplesse sur Internet

♠ Pour les applications qui nécessitent une très grande

rapidité d'exécution, on préfère encore les langages C, C++,
ou le bon vieux Fortran
(qui a des bibliothèques très utilisées pour le calcul
scientifique)

16
 Spécifications de Java

♠ Java, c’est en fait

– le langage Java : http://java.sun.com/docs/books/jls/

– une JVM : http://java.sun.com/docs/books/vmspec/

– les API : selon la documentation javadoc fournie

avec les différents paquetages

♠ Java n’est pas normalisé ; son évolution est gérée par le

JCP (Java Community Process ; http://www.jcp.org/)
dans lequel Sun tient une place prépondérante

17
 Plate-forme Java

API (Application Programming Interface) :

bibliothèques de classes standard
18
 3 éditions de Java

♠ J2SE : Java 2 Standard Edition ; JDK = J2SE

Development Kit, aussi appelé SDK (Software
Development Kit) pour certaines versions
Fournit les compilateurs, outils, runtimes, et APIs pour
écrire, déployer, et exécuter des applets et applications

♠ J2EE : Enterprise Edition qui ajoute les API pour écrire

des applications installées sur les serveurs dans
des applications distribuées : servlet, JSP, EJB,…

♠ J2ME : Micro Edition, version allégée de Java pour écrire

des programmes embarqués (cartes à puce/Java
card, téléphones portables,…)
19
 Votre environnement de
développement
♠ Éditeur de texte NotePad

♠ Compilateur (javac)

♠ Interpréteur de bytecode (java)

♠ Aide en ligne sur le JDK (sous navigateur Web)

♠ Générateur automatique de documentation (javadoc)

♠ Testeur pour applet (appletviewer)

♠ Débogueur (jdb)
20
 Votre environnement de
développement
♠ Nombreux IDE (Integrated Development Environment)
commerciaux

JDeveloper
Oracle
Java Studio WebSphere Studio JBuilder
Creator Application Developper Borland Visual J++
Sunsoft (VisualAge) IBM Microsoft

♠ Des environnements open-source ou freeware

Eclipse (3.2) NetBeans (5.5) BlueJ Emacs + JDE

www.eclipse.org www.netbeans.org www.bluej.org http://sunsite.auc.dk/jde
21
 Variables d’environnement

♠ PATH : doit inclure le répertoire qui contient les utilitaires

Java (javac, java, javadoc,…)

♠ CLASSPATH : indique le chemin de recherche des classes

de l’utilisateur

♠ Le débutant ne doit pas avoir de variable CLASSPATH

22
 Une classe Point
/** Modélise un point de coordonnées x, y */
public class Point {
private int x, y;
public Point(int x1, int y1) { // un constructeur
x = x1;
y = y1;
}

public double distance(Point p) { // une méthode

return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}

public static void main(String[] args) {

Point p1 = new Point(1, 2);
Point p2 = new Point(5, 1);
System.out.println("Distance : " + p1.distance(p2));
}
} 23
 2 classes dans 1 fichier
/** Modélise un point de coordonnées x, y */
public class Point {
private int x, y;
public Point(int x1, int y1) {
x = x1; y = y1;
}

public double distance(Point p) {

return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
}
Fichier Point.java
/** Teste la classe Point */
class TestPoint {
public static void main(String[] args) {
Point p1 = new Point(1, 2);
Point p2 = new Point(5, 1);
System.out.println("Distance : " + p1.distance(p2));
}
} 24
 Compilation et exécution de la
classe Point

La compilation du fichier Point.java

javac Point.java

fournit 2 fichiers classes : Point.class et TestPoint.class

On lance l’exécution de la classe TestPoint qui a une

méthode main()
java TestPoint

25
 2 classes dans 2 fichiers
/** Modélise un point de coordonnées x, y */
public class Point {
private int x, y;
public Point(int x1, int y1) { Fichier Point.java
x = x1; y = y1;
}

public double distance(Point p) {

return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
}

/** Pour tester la classe Point */

class TestPoint { Fichier TestPoint.java
public static void main(String[] args) {
Point p1 = new Point(1, 2);
Point p2 = new Point(5, 1);
System.out.println("Distance : " + p1.distance(p2));
}
} 26
 Architecture d’un
programme source Java

♠ Programme source Java = ensemble de fichiers « .java »

♠ Chaque fichier « .java » contient une ou plusieurs

définitions de classes

♠ Au plus une définition de classe public par fichier « .java »

(avec nom du fichier = nom de la classe publique)

27
 Chargement dynamique des classes

♠ Durant l’exécution d’un code Java, les classes (leur

bytecode) sont chargées dans la JVM au fur et à mesure des
besoins

♠ Une classe peut être chargée:

– depuis la machine locale (le cas le plus fréquent)

– depuis une autre machine, par le réseau

– par tout autre moyen (base de données,…)

28
 Types de programmes Java

On peut développer deux types de programmes avec java

1- Applications indépendantes

2- Applets exécutées dans l’environnement/JVM

d’un navigateur Web et chargées par une page
HTML

29
 Application indépendante
♠ Application doit posséder une classe principale
– classe possédant une méthode de signature
Tableau de chaînes de caractères
(équivalent à argc, argv du C)
public static void main(String[] args)

♠ Cette méthode sert de point d’entrée pour l’exécution de

l’application

♠ Lancement de l’application s’effectue en exécutant la méthode main de

la classe principale de l’application; par exemple :

java TestPoint

lance l’interprétation du code de la méthode main() de la classe

principale TestPoint qui se trouve dans le fichier TestPoint.class

30
 Applet
♠ Classe ne possédant pas de méthode main()

• Hérite de java.awt.Applet ou javax.swing.JApplet

• Son bytecode réside sur un serveur http

• Elle est véhiculée vers un client http (navigateur Web) via une
page HTML qui contient son url

• Lorsqu’un navigateur compatible Java (avec sa propre

machine virtuelle java (JVM)) reçoit cette page HTML, il
télécharge le code de la classe et l’exécute sur le poste client

– l’applet doit posséder un certain nombre de méthodes pour

permettre cette exécution :

init(), start(), stop(), paint(), destroy()

31
import java.awt.*;
Exemple d’applet
import java.applet.*;
public class Checkerboard extends Applet {
/* This applet draws a red-and-black checkerboard.
It is assumed that the size of the applet is 160 by 160 pixels.
*/
public void paint(Graphics g) {
int row; // Row number, from 0 to 7
int col; // Column number, from 0 to 7
int x,y; // Top-left corner of square
for ( row = 0; row < 8; row++ ) {
for ( col = 0; col < 8; col++) {
x = col * 80; y = row * 80;
if ( (row % 2) == (col % 2) )
g.setColor(Color.red);
else
g.setColor(Color.black);
g.fillRect(x, y, 80, 80);
}
} // end for row
} // end paint()
} // end class Checkerboard 32
Exemple de page Web qui contient
une applet

<html>
<head>
<title>Utilsation des applets</title>
</head>
<body>
<h1 align = "center">Utilisation des applets</h1>
<p align=center>
<applet code="Checkerboard.class"
height=640 width=640>
</applet>
</p>
</body>
<html> 33
 Étapes pour l’exécution d’une applet

1. Demande chargement page Web

Qui contient une applet html

html
Client 2. Chargement de la page Web Serveur
http html
3. Demande chargement de l’applet
Navigateur HTTP
intégrant une référencée dans la page
machine .class
virtuelle Java 4. Chargement du bytecode de
La classe .class

3. Exécution de l’applet
dans la JVM du client

34
 Exécution de l'applet

♠ Le navigateur a sa propre machine virtuelle

♠ Un programme Java spécial démarré par le navigateur va

lancer certaines méthodes de la classe Applet :

init(), start(), stop(), destroy(), paint()

♠ init() est exécuté seulement quand l’applet

est lancée pour la première fois

♠ paint() dessine l'applet dans la page Web

35
 Utilité des applets
♠ Les applets permettent de faire des pages Web plus
riches (grâce aux possibilités offertes par Java)

♠ La page Web peut contenir

– des animations ou des mises en forme
complexes pour mettre en valeur certaines
informations

– des résultats de calculs complexes

– des informations « dynamiques » (pas connues

au moment où la page Web statique est créée)
trouvées en interrogeant une base de données
– ...
36
PROGRAMMATION EN JAVA

SANS OBJETS

37
 Lesson 1: Eléménts de base du langage
(Language Basics)

1. Variables (Variables)

2. Opérateurs (Operators)

3. Expressions, Instructions et Blocs (

Expressions, Statements, and Blocks)

4. Instructions de contrôle (Control Flow Statements )

38
 Exemple de programme

public class BasicsDemo

{ public static void main(String[] args)
{ int sum = 0;
int prod = 1;
for (int current = 1; current <= 10; current++)
{
if (current % 2 == 0)
sum += current;
else
prod *= current;
}

System.out.println("Sum = " + sum + " \n prod = " + prod );

}
} 39
 Variables
Definition:  Une variable est une donnée représentée par un identificateur

(A variable is an item of data named by an identifier. )

Vous devez explicitement donner un nom et un type à chaque variable que vous
voulez utiliser dans le programme.

Le nom d’une variable doit être un identificateur autorisé.

Un identificateur est une séquence non limitée de caractères Unicode qui commence
par une lettre.

Le nom d’une variable est utilisé pour référencer la donnée que la variable contient

Le type d’une variable détermine quelles sont les valeurs que la variable peut contenir
et quelles opérations peuvent être effectuées sur la variable.

40
 Variables

Pour donner à une variable un nom et un type, nous écrivons une

déclaration de variable de la maniére suivante :

type name
En plus du nom et du type, une variable à un domaine de visibilité ou
SCOPE

La partie du programme où le nom d’une variable peut être utilisé est

appelé domaine de visibilité (ou SCOPE) de la variable

41
 Variables
Les sections ci-dessous explorent les différents aspects d’une variable

• Types de données (Data Types)

 

• Noms de variable (Variable Names)

• Domaine de visibilité (Scope )

• Initialisation d’une variable (Variable Initialization)

• Variables constantes ou finales (Final Variables)

• Récapitulatifs sur les variables (Summary of Variables)

• Questions & Exercices (Questions and Exercises: Variables)

42
 Types de données
(Data Types)

Chaque variable doit avoir un type de donnée.

Le type de donnée d’une variable détermine l’ensemble des valeurs

que la variable peut contenir.
Il détermine également le type d’opérations qui peuvent être éffectuées sur elle.

Par exemple:
Une variable de type int ne peut contenir que des valeurs entières (négatives ou
positives).
Sur une variable entière nous pouvons effectuer des opérations arithmétiques
(addition, soustraction …etc)

43
 Types de données
Le langage Java contient deux catégories de types de données:

Types primitifs

Type référence

Types primitifs
Une variable de type primitif contient une valeur simple
(nombre, caractère, ou booléen).
Cette valeur est stockée en mémoire sur un nombre de bits déterminé et selon
un format bien précis.

Exemple:
Une variable de type int mémorise sa valeur sur 32 bits et utilise
la représentation en complément à 2

Une variable de type char mémorise sa valeur sur 16 bits et utilise le format Unicode
                                               
A variable of primitive type contains a value of a particular size and format. 44
Plus grandes valeurs des types primitifs

public class MaxVariablesDemo

{
public static void main(String args[])
{
//integers
byte largestByte = Byte.MAX_VALUE;
short largestShort = Short.MAX_VALUE;
int largestInteger = Integer.MAX_VALUE;
long largestLong = Long.MAX_VALUE;

//real numbers
float largestFloat = Float.MAX_VALUE;
double largestDouble = Double.MAX_VALUE;

//other primitive types

char aChar = 'S';
boolean aBoolean = true;

45
 Plus grandes valeurs des types primitifs

//Display them all.

System.out.println("The largest byte value is " + largestByte + ".");

System.out.println("The largest short value is " + largestShort + ".");
System.out.println("The largest integer value is " + largestInteger + ".");
System.out.println("The largest long value is " + largestLong + ".");
System.out.println("The largest float value is " + largestFloat + ".");
System.out.println("The largest double value is " + largestDouble + ".");
if (Character.isUpperCase(aChar))
{
System.out.println("The character " + aChar + " is uppercase."); }
else
{
System.out.println("The character " + aChar + " is lowercase.");
}

System.out.println("The value of aBoolean is " + aBoolean + ".");

} //fin de main
} // fin de la classe 46
 Types de données primitifs
MotClé Description Taille/Format
Entiers
byte Entier signé sur un octet 8-bits : Complément à 2
short Entier signé sur 2 octets 16-bit : Complément à 2
int Entier signé sur 4 octets 32-bit : Complément à 2
long Entier signé sur 8 octets 64-bit : Complément à 2
Nombres réels
Réel en virgule flottante simple
float 32-bit IEEE 754
précision
Réel en virgule flottante double
double 64-bit IEEE 754
précision
Autres types
char Un seul caractère 16-bit : Unicode
boolean Valeur boolèene (true or false) true or false
47
 Valeurs Litterales
Il est possible d’écrire directement une valeur littérale dans
votre programme.
Par exemple, pour assigner la valeur 20 à une variable de
type entier, vous pouvez écrire :
I = 20 ;
20 est une valeur littérale.

Le compilateur attribue a la valeur 20 le type int par défaut.

Le tableau de la page suivante présente différents type de
valeurs littérales.
48
 Exemples de valeurs litterales
Valeur Litterale Type De Données
178 int
8864L long
37.266 double
37.266D double
87.363F float
26.77e3 double
'c' char
true boolean
false boolean
49
 Types Références

La valeur d’une variable de type référence est une référence (adresse de) à la
valeur à ou à l’ensemble des valeurs représenté par la variable.
Objet
Nom d’objet Référence Ou
tableau

Une variable référence contient l’adresse d’un objet ou d’un tableau.

Une référence est appelé Pointeur ou adresse dans les autres langages(C, …)
Le Langage Java n’autorise pas l’utilisation explicite des pointeurs.

Les tableaux, Classes, et Interfaces sont des types Références.

50
 Noms de variables

En Java, le nom d’une varaible doit respecter les règles suivantes:

1. Il doit consister en une suite illimitée de caractères unicode qui commence par
une lettre

2. Il ne doit pas être un mot clé, une valeur booléenne (true ou false) ou le mot
réservé null

3. Il doit être unique dans son Scope. Une variable peut avoir le même nom que
d’autres variables déclarées dans des Scopes différents.

51
 Noms de variables

Par convention :

• Le nom d’une variable commence par une lettre minuscule, alors que celui
d’une classe commence par une lettre majuscule.

• Si le nom d’une variable est formé de plusieurs mots, la première lettre de

chaque mot doit être une lettre majuscule à l’exception de celle du premier
mot.

• Le caractère de soulignement est autorisé n’importe où dans le nom d’une

variable. Mais celui-ci est surtout utilisé dans les constantes

52
 Scope d’une variable

Le Scope d’une variable:

1. Définit la région du programme à partir de laquelle il est
possible de référencer la variable par son nom
2. Détermine l’instant où le système réserve de la mémoire
pour la variable et l’instant où il libère la mémoire occupée
par la variable.

Le Scope est différent du domaine de visibilité.

Le domaine de visibilité s’applique uniquement aux variables
membres et détermine si la variable peut ou non être utilisée
en dehors de la classe dans laquelle elle a été déclarée. La
visibilité est positionnée par un modificateur d’accès (Voir
Classes) 53
 Scope d’une variable

L’endroit de la déclaration d’une variable dans un programme établit son scope

et la place dans une des quatre catégories suivantes:

1. Variable membre (member variable)

2. Variable locale (local variable)

3. Paramètre de méthode (method parameter)

4. Paramètre de gestionnaire d’exception (exception-handler parameter)

54
 Variable membre
(member variable)

Une variable membre est un membre d’une classe ou d’un objet.

Elle est déclarée à l’intérieur d’une classe mais en dehors de toute méthode ou
constructeur.

Son scope est toute la classe dont elle est membre.

Nous étudierons en détail les variables membres dans une leçon ultérieure.

55
 Variable locale
(local variable)

Une variable locale est déclarée dans un bloc de code.

Un bloc de code est délimité par les accolades ({}).

Le Scope d’une variable locale s’étend de l’endroit où elle est déclarée jusqu’à la
fin du bloc où elle est déclarée.

Toutes les variables déclarées dans la méthode main sont des variables locales.
Le Scope de ces variables s’étend de leur lieu de déclaration jusqu’à la fin de la
méthode main indiquée par l’accolade fermante }.

56
 Paramètre de méthode
(method parameter)

Les paramètres de méthodes sont les argument formels des méthodes et

constructeurs.

Les paramètres sont utilisés pour passer des valeurs aux méthodes et aux
constructeurs.

Le Scope d’un paramètre est la méthode (ou constructeur) entière pour

laquelle il est défini.

57
 Paramètres de gestionnaire d’exception
(exception-handler parameter)

Les paramètre de gestionnaire d’exception sont similaires aux paramètres

de méthode mais sont paramètres d’un gestionnaire d’exception et non
d’une méthode ou d’un constructeur.

Le Scope d’un paramètre de gestionnaire d’exception est le bloc de code

encadré par les accolades {} qui vient après l’instruction catch.

Nous étudierons en détails ces paramètres dans la section : Gestion des

erreurs à l’aide des exceptions.

58
 Exemples de variables locales
Considérons le code ci-dessous:

if (...)
{
int i = 17; ...
}
System.out.println(« La valeur de i = " + i); // erreur

La dernière ligne de ce programme générera une erreur de compilation parce

que la variable locale i est utilisé en dehors de son Scope.

Le Scope de la variable i est le bloc de code compris entre { et }.

La variable i n’existe plus après l’accolade fermante }.

Pour remédier au problème:

-il faut soit déplacer la déclaration de la variable i en dehors du bloc de code de
l’instruction if,

-ou déplacer l’appel de la méthode println à l’intérieur du bloc du code de

l’instruction if. 59
 Initialisation de variable
Une variable locale ou variable membre peut être initialisée par une
instruction d’affectation lors de sa déclaration.
Le type de la variable doit être compatible avec le type de la valeur qui lui
est affectée.
L’exemple ci-dessous montre des exemples d’initialisation de variables:
//Entiers
byte largestByte = Byte.MAX_VALUE;
short largestShort = Short.MAX_VALUE;
int largestInteger = Integer.MAX_VALUE;
long largestLong = Long.MAX_VALUE;
//Nombres réels
float largestFloat = Float.MAX_VALUE;
double largestDouble = Double.MAX_VALUE;
//Autres types primitifs
char aChar = 'S';
boolean aBoolean = true;
Les paramètres des méthodes et des gestionnaires d’exception ne sont pas
initialisées selon cette méthode; Ils reçoivent leur valeur à partir du code
appelant

60
 Variables « Finales »
(Final Variables )

On peut déclarer une variable de n’importe quel Scope comme étant final.

La valeur d’une variable final ne peut pas être modifié après son initialisation.

Une variable final est similaire à une constante en C, C++ et C#.

Pour déclarer une variable final, utilisez le mot clé final dans la déclaration de la
variable juste avant le type.
Exemple:
Final int aFinalVariable = 0
Cette instruction déclare une variable final et l’initialise une fois pour toute.
Si on essaie de lui assigner une autre valeur dans la suite du programme, le
compilateur engendrera une erreur.

61
 Variables « Finales »
(Final Variables )

Il est possible de déférer l’initialisation d’une variable locale. Il faut tout

simplement déclarer la variable comme étant final, puis l’initialiser par la suite.
Exemple:
final int aBlankFinalVariable;
……………………….
aBlankFinalVariable = 0

Une variable locale final qui a été déclarée sans être initialisée est appelé
variable « blank final ». Une fois cette variable est initialisée, toute tentative
future pour lui assigner une autre valeur engendrera une erreur lors de la
compilation.

62
 Récapitulatif sur les variables
(Summary of Variables)

Lorsque vous déclarez une variable, vous devez spécifier explicitement son
type et son nom.

On distingue deux catégories de types de données:

- types primitifs
- type références

Une variable de type primitifs contient une valeur.

Une variable de type références contient une référence (adresse) de la valeur.

Les tableaux, classes, et interfaces sont des types références.

63
 Récapitulatif sur les variables
(Summary of Variables)

L’endroit de la déclaration de la variable définit implicitement son scope.

Le scope d’une variable détermine les sections du code qui peuvent se référer à
la variable par son simple nom.
Il y a quatre catégories de scope de variables: scope de variable membre,
scope de variable locale, scope de paramètre de méthode, et scope de
paramètre de gestionnaire d’exception.

Il est possible d’affecter une valeur initiale à une variable lors de sa déclaration
à l’aide de l’opérateur d’affectation (=).

Il est possible de déclarer une variable comme étant final.

La valeur d’une variable final ne peut pas être modifiée une fois elle est
initialisée.

64
 Questions et Exercises
Sur les Variables
Questions

Parmi les noms suivants soulignez ceux qui sont des noms de variables valides?

int
anInt
i
i1
1
thing1
1thing
ONE-HUNDRED
ONE_HUNDRED
something2do

65
 Opérateurs
(Operators)

Un opérateur effectue une opération (ou fonction) sur un, deux ou trois
opérandes.
Un opérateur qui requiert un seul opérande est appelé opérateur unaire.
Par exemple, ++ est un opérateur unaire qui incrémente la valeur de son
opérande de 1.

Un opérateur qui requiert deux opérandes est un opérateur binaire.

Par exemple, = est un opérateur binaire qui affecte la valeur de son opérande
qui se trouve à sa droite à son opérande suit se trouve à sa gauche.

En dernier, un opérateur qui requiert trois opérandes est appelé opérateur

ternaire. Il existe un seul opérateur ternaire qui est ?:
C’est un raccourci de l’instruction if-else.
Exemple : Max = a>b?a:b  (si (a>b) Max = a else Max=b)

66
 Opérateurs
(Operators)

Les opérateurs unaires supportent les deux notations prefix et postfix.

La notation prefix signifie que l’opérateur apparaît avant son opérande.
Opérateur op // notation prefix (op signifie opérande).
La notation postfix signifie que l’opérateur apparaît après son opérande
op Opérateur //notation postfix

Tous les opérateurs binaires utilisent la notation infix, qui signifie que l’opérateur
apparaît entre ses opérandes.
Op1 opérateur op2 //notation infix

L’opérateur trenaire utilise aussi la notation infix, car chaque composante de

l’opérateur apparaît entre deux opérandes.
Op1 ? Op2 : Op3 /notation infix

67
 Opérateurs
(Operators)

En plus d’effectuer une opération, un opérateur retourne une valeur.

La valeur retournée et son type dépendent de l’opérateur et du type de ses
opérandes.

Par exemple, les opérateurs arithmétiques tels que les opérateurs d’addition et
de soustraction retournent comme résultat un nombre dont le type dépend de
type de leurs opérandes.

Si on additionne deux entiers , le résultat retourné est un entier,

si on additionne deux réels le résultat retourné est un réel.

68
 Opérateurs
(Operators)

Les opérateurs se répartissent en les catégories suivantes :

 Opérateurs arithmétiques

 Opérateurs relationnels et logiques

 Opérateurs de décalage et bit à bit

 Opérateurs d’affectation

 Autres opérateurs

69
 Opérateurs arithmétiques
(Arithmetic operators)

Le lanagage Java fournit un ensemble d’opérateurs arithmétique qui opèrent sur

des nombres entiers et en virgules flottante.
Ces opérateurs sont : + (addition), -(soustraction), *(multiplication), /(division), et
%(modulo).
Le tableau suivant présente ces opérateurs:

Opérateurs arithmétiques binaires

Operateur Format
+ op1 + op2
- op1 - op2
* op1 * op2
/ op1 / op2
Description
Ajoute op1 à op2; utilisé également pour concaténer deux
Strings.
Soustrait op2 de op1.
Multiplie op1 par op2.
Divise op1 par op2.

% op1 % op2 Calcule le reste de la division de op1 par op2.

70
 Opérateurs arithmétiques
Exemple de programme
Le programme ArithmeticDemo ci-dessous, définit deux variables de type entier et
deux variables de type virgule flottante double précision. Il utilise les cinq
opérateurs arithmétiques pour effectuer les différentes opérations arithmétiques.
Ce programme utilise également l’opérateur + pour concaténer les strings.
Les opérations arithmétiques sont écrites en gras.

public class ArithmeticDemo {

public static void main(String[] args) {
//a few numbers
int i = 37;
int j = 42;
double x = 27.475;
double y = 7.22;
System.out.println("Variable values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" x = " + x);
System.out.println(" y = " + y); 71
//adding numbers
System.out.println("Adding...");
System.out.println(" i + j = " + (i + j));
System.out.println(" x + y = " + (x + y));

//subtracting numbers
System.out.println("Subtracting...");
System.out.println(" i - j = " + (i - j));
System.out.println(" x - y = " + (x - y));

//multiplying numbers
System.out.println("Multiplying...");
System.out.println(" i * j = " + (i * j));
System.out.println(" x * y = " + (x * y));

//dividing numbers
System.out.println("Dividing...");
System.out.println(" i / j = " + (i / j));
System.out.println(" x / y = " + (x / y));

72
//computing the remainder resulting
//from dividing numbers
System.out.println("Computing the remainder...");
System.out.println(" i % j = " + (i % j));
System.out.println(" x % y = " + (x % y));

//mixing types
System.out.println("Mixing types...");
System.out.println(" j + y = " + (j + y));
System.out.println(" i * x = " + (i * x)); } }

73
This is the output from the program.
Variable values...
i = 37
j = 42
x = 27.475
y = 7.22
Adding...
i + j = 79
x + y = 34.695
Subtracting...
i - j = -5
x - y = 20.255
Multiplying...
i * j = 1554
x * y = 198.37
Dividing...
i/j=0
x / y = 3.8054
Computing the remainder...
i % j = 37
x % y = 5.815
Mixing types...
j + y = 49.22
74
i * x = 1016.58
 Types des résultats des Opérations Arithmétiques

Noter que lorsqu’un entier et un nombre en virgule flottante sont utilisés

ensemble dans une opération arithmétique, le résultat est un nombre en
virgule flottante. Le nombre entier est implicitement converti en un nombre
en virgule flottante avant que l’opération ne soit effectuée.

Le tableau ci-dessous présente en résumé les types de données

retournés par les opérateurs arithmétiques en fonction des types des
opérandes utilisés. Les conversions nécessaires sont effectuées
implicitement avant que l’opération arithmétique ne soit effectuée.

75
 Types des résultats des Operations Arithmétiques

Type du
Type des Opérandes
Resultat
Aucun opérande n’est de type float ou double (Arithmétique
long
entière); au moins un opérande est de type long.
Aucun opérande n’est de type float ou double (Arithmétique
int
entière); aucun opérande n’est de type long.
double Au moins un opérande est de type double.
Au moins un opérande est de type float; aucun opérande n’est
float
de type double.

76
 Opérateurs Arithmétiques Unaires

En plus des formes binaire des opérateurs + et -,

chacun de ces opérateurs possède une forme unaire, comme le montre

le tableau suivant.

Operateurs Arithmétiques Unaires

Operateur Utilisation Description

Promouvoit op au type int s’il est de type byte,

+ +op
short,ou char

- -op Calcule l’opposé arithmétique de op

77
 Opérateurs d’incrémentation (++)
Et de décrémentation (--)

Il existe deux opérateurs arithmétiques considérés comme des raccourcis.

Le premier est l’opérateur ++ qui incrémente son opérande de 1.
Le deuxième est l’opérateur -- qui décrémente son opérande de 1.

Chacun de ces deux opérateurs peut apparaître avant (prefix) ou après (postfix)
son opérande.

La version prefix , ++op/--op, fournit comme résultat la valeur de l’opérande

après l’avoir incrémenté/décrémenté.

La version postfix op++/op--, fournit comme résultat la valeur de l’opérande

avant de l’incrémenter/décrémenter.

78
 Exemple de programme utilisant ++ et
--
Le programme suivant, appelé SortDemo , utilise ++ deux fois -- une fois.
 

public class SortDemo {

public static void main(String[] args) {
int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
for (int i = arrayOfInts.length; --i >= 0;) {
for (int j = 0; j < i; j++) {
if (arrayOfInts[j] > arrayOfInts[j+1]) {
int temp = arrayOfInts[j];
arrayOfInts[j] = arrayOfInts[j+1];
arrayOfInts[j+1] = temp;
}
}
}
for (int i = 0; i < arrayOfInts.length; i++) {
System.out.print(arrayOfInts[i] + " ");
}
System.out.println();
}
} 79
 Exemple de programme utilisant ++ et
--
Le programme suivant, appelé SortDemo , utilise ++ deux fois -- une fois.
 

public class SortDemo {

public static void main(String[] args) {
int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };
for (int i = arrayOfInts.length; --i >= 0;) {
for (int j = 0; j < i; j++) {
if (arrayOfInts[j] > arrayOfInts[j+1]) {
int temp = arrayOfInts[j];
arrayOfInts[j] = arrayOfInts[j+1];
arrayOfInts[j+1] = temp;
}
}
}
for (int i = 0; i < arrayOfInts.length; i++) {
System.out.print(arrayOfInts[i] + " ");
}
System.out.println();
}
} 80
 Détails sur le programme Précédent

Ce programme place 10 valeurs entières dans un tableau qui est une structure
à longueur fixe et qui mémorise plusieurs valeurs de même type. Par la suite, le
programme les classe par ordre croissant à l’intérieur du dit tableau.
La ligne du code écrite en gras déclare un tableau de nom arrayOfInts, crée le
tableau puis l’initialise par les 10 valeurs entières.
Le programme utilise arrayOfInts.length pour obtenir le nombre d’éléments
dans le tableau.
Chaque élément est accessible par cette notation : arrayOfInts[index], où
index indique la position de l’élément à l’intérieur du tableau.
Notez que les indices commencent à 0. Vous trouverez plus de détails sur les
tableaux dans la section Tableaux.

Le résultat d’exécution du programme est la suite des nombres triés dans

l’ordre croissant:

3 8 12 32 87 127 589 622 1076 2000

81
 Détails sur le programme Précédent
Examinons comment le programme SortDemo utilise l’opérateur -- pour contrôler
la boucle externe qui contient deux boucles de tri imbriquées.
L’instruction qui contrôle cette boucle est :
for (int i = arrayOfInts.length; --i >= 0;) {
...
}
L’instruction for est une structure d’itération et sera décrit ultérieurement dans ce
chapitre.

Ce qui est important ici est le code qui est mis en gras, qui permet de répéter
l’exécution du corps de la boucle tant que la valeur retournée par --i est supérieur
ou égale à 0.

L’utilisation de la version prefix de -- signifie que la dernière itération de la boucle

se produit lorsque i est ègale à 0.

82
 Détails sur le programme Précédent

Si nous changeons le code pour utiliser la version postfix de --,

la dernière itération de cette boucle se produit lorsque i devient ègal à -1.

Ce qui cause une erreur puisque i est utilisé comme indice du tableau,

et -1 n’est pas une valeur correcte d’un indice de tableau.

Les deux autres boucles du programme utilisent la version postfix de ++.

Dans les deux cas, la version utilisée n’a pas réellement d’importance parce
que la valeur retournée par l’opérateur n’est utilisée pour aucune autre chose.

Lorsque la valeur retournée par un opérateur d’incrémentation/décrémentation

n’est utilisée pour aucune autre chose, par convention la notation postfix op+
+/op-- est préférée.

83
Récapitulatif sur les opérateurs d’incrémentation(++)
et de décrémentation (--)

Operateur Utilisation Description

Incrémente op par 1; évalue
++ op++ l’expression en la valeur de op avant
qu’il ne soit incrémenté.
Incrémente op par 1; évalue
++ ++op l’expression en la valeur de op après
qu’il soit incrémenté.
Décrémente op par 1; évalue
-- op-- l’expression en la valeur de op avant
qu’il ne soit décrémenté.
Décrémente op par 1; évalue
-- --op l’expression en la valeur de op après
qu’il soit Décrémenté.

84
 Operateurs Relationnels et Logiques

Un opérateur relationnel permet de comparer deux valeurs. Il retourne toujours une

valeur boolèenne.
Par exemple l’opérateur != retourne la valeur booléenne true si les deux opérandes
ne sont pas égaux.
Le tableau ci-dessous fournit les différents opérateurs relationnels.

Operateurs Relationnels

Operateur Utilisation Description

> op1 > op2 Retourne true si op1 est supérieur à op2
>= op1 >= op2 Retourne true si op1 est supérieur ou égale à op2
< op1 < op2 Retourne true si op1 est inférieur à op2
<= op1 <= op2 Retourne true si op1 est inférieur ou égale à op2
== op1 == op2 Retourne true si op1 est égale à op2
!= op1 != op2 Retourne true si op1 est différent de op2
85
 Exemple de programme utilisant les
opérateurs relationnels
Le programme RetionalDemo suivant définit trois nombres entiers, et utilise les

Opérateurs Relationnels pour les comparer. Ces opérateurs sont écrits en gras.

public class RelationalDemo {

public static void main(String[] args) {
//a few numbers
int i = 37;
int j = 42;
int k = 42;
System.out.println("Variable values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" k = " + k);

//greater than
System.out.println("Greater than...");
System.out.println(" i > j = " + (i > j)); //false
System.out.println(" j > i = " + (j > i)); //true
System.out.println(" k > j = " + (k > j)); //false , they are equal 86
//greater than or equal to
System.out.println("Greater than or equal to...");
System.out.println(" i >= j = " + (i >= j)); //false
System.out.println(" j >= i = " + (j >= i)); //true
System.out.println(" k >= j = " + (k >= j)); //true

//less than
System.out.println("Less than...");
System.out.println(" i < j = " + (i < j)); //true
System.out.println(" j < i = " + (j < i)); //false
System.out.println(" k < j = " + (k < j)); //false

//less than or equal to

System.out.println("Less than or equal to...");
System.out.println(" i <= j = " + (i <= j)); //true
System.out.println(" j <= i = " + (j <= i)); //false
System.out.println(" k <= j = " + (k <= j)); //true

//equal to
System.out.println("Equal to...");
System.out.println(" i == j = " + (i == j)); //false
System.out.println(" k == j = " + (k == j)); //true
87
 //not equal to
System.out.println("Not equal to...");
System.out.println(" i != j = " + (i != j)); //true
System.out.println(" k != j = " + (k != j)); //false
}
}

Le résultat d’exécution du programme est fourni ci-dessous

Variable values...
i = 37
j = 42
k = 42
Greater than...
i > j = false
j > i = true
k > j = false
Greater than or equal to...
i >= j = false
j >= i = true
k >= j = true

88
Less than...
i < j = true
j < i = false
k < j = false
Less than or equal to...
i <= j = true
j <= i = false
k <= j = true
Equal to...
i == j = false
k == j = true
Not equal to...
i != j = true
k != j = false

89
 Operateurs Logiques (ou conditionnels)

Les opérateurs relationnels sont souvent utilisés avec les opérateurs logiques

pour former des expressions conditionnelles plus complexes.

Le langage Java fournit six opérateurs logiques, 5 sont binaires et un est unaire

Le tableau suivant présente ces six opérateurs.

90
 Operateurs Logiques (ou conditionnels)

Opérateur Utilisation Description

Retourne true si op1 et op2 sont tous les deux true;
&& op1 && op2
evalue op2 uniquement dans le cas ou op1 est true
Retourne true si op1 ou op2 est true; evalue op2
|| op1 || op2
uniquement dans le cas où op2 est false.
! !op Retourne true si op est false
Retourne true si op1 et op2 sont tous les deux booléens
et ont la valeur true; il evalue toujours op1 et op2;
& op1 & op2
Si les deux opérandes sont des nombres, il effectue
l’opération AND bit à bit.
Retourne true si op1 et op2 sont tous les deux booléens
et op1 ou op2 est true; evalue toujours op1 et op2; si
| op1 | op2
les deux opérandes sont des nombres, il effectue
l’opération OR inclusif bit à bit.
Retourne true si op1 et op2 sont differents — c’est-à-
^ op1 ^ op2
dire, si un seul opérande, et non les deux est true.

91
 Opérateurs de décalage et bit à bit

Un opérateur de décalage effectue une manipulation des bits en effectuant un

décalage gauche ou droite des bits de son opérande de gauche. Le tableau

Ci-dessous présente les opérateurs de décalage fourni par le langage Java.

Operateurs de décalage

Operateur Utilisation Description

Effectue un décalage gauche des bits de op1 un
<< op1 << op2 nombre de fois spécifié par l’opérande op2; remplit
avec 0 les bits de droite
Effectue un décalage droite des bits de op1 un
>> op1 >> op2 nombre de fois égal à op2. Remplit avec le bit le plus
significatif (bit de signe) les bits de gauche.
Effectue un décalage droite des bits de op1 un
>>> op1 >>> op2 nombre de fois égal à op2. Remplit avec 0 les bits
de gauche.
92
 Operateurs Logiques

Le tableau ci-dessous présente les quatre opérateurs logiques fourni par Java pour
Effectuer des opérations bit à bit sur leurs opérandes

Operateurs Logiques

Operateur Utilisation Operation

-Opération AND bit à bit si les deux opérandes sont des
nombres;
& op1 & op2
-Opération AND logique si les deux opérandes sont
booléen
-Opération OR bit à bit si les deux opérandes sont
des nombres;
| op1 | op2
-Opération OR logiques si les deux opérandes sont
booléens
^ op1 ^ op2 Opération OR exclusif(XOR)
~ ~op Complément à un des bits de l’opérande op
93
 Opérateurs de manipulation des bits
Programme BitwiseDemo  qui présente les opérateurs de manipulation des bits.

public class BitwiseDemo {

static final int VISIBLE = 1;
static final int DRAGGABLE = 2;
static final int SELECTABLE = 4;
static final int EDITABLE = 8;

public static void main(String[] args) {

int flags = 0;
flags = flags | VISIBLE;
flags = flags | DRAGGABLE;
if ((flags & VISIBLE) == VISIBLE) {
if ((flags & DRAGGABLE) == DRAGGABLE) {
System.out.println("Flags are Visible " + "and Draggable.");
}
}
flags = flags | EDITABLE;
if ((flags & EDITABLE) == EDITABLE) {
System.out.println("Flags are now also Editable.");
94
}}}
Résultat d’exécution du programme

Flags are Visible and Draggable.

Flags are now also Editable.

95
 Opérateurs d’affectation

Le langage Java utilise l’opérateur = pour affecter une valeur à une variable.

Le langage Java fournit aussi un ensemble d’opérateurs qui combine une

opération arithmétique, de décalage, ou de manipulation de bits avec

l’opération d’affectation.

Supposez que vous voulez ajouter un nombre à une variable, et puis affecter le

résultat à la variable en question, comme suit:

i = i + 2;

Vous pouvez écrire de façon plus concise cette instruction en utilisant l’opérateur
+=.

Les deux instructions i = i + 2; et i += 2; sont équivalentes

96
 Operateurs d’affectation

Le tableau suivant présente les différents opérateurs d’affectation fournis par Java.

Operateur Utilisation Description

+= op1 += op2 Equivalent à op1 = op1 + op2
-= op1 -= op2 Equivalent à op1 = op1 - op2
*= op1 *= op2 Equivalent à op1 = op1 * op2
/= op1 /= op2 Equivalent à op1 = op1 / op2
%= op1 %= op2 Equivalent à op1 = op1 % op2
&= op1 &= op2 Equivalent à op1 = op1 & op2
|= op1 |= op2 Equivalent à op1 = op1 | op2
^= op1 ^= op2 Equivalent à op1 = op1 ^ op2
<<= op1 <<= op2 Equivalent à op1 = op1 << op2
>>= op1 >>= op2 Equivalent à op1 = op1 >> op2
>>>= op1 >>>= op2 Equivalent à op1 = op1 >>> op2

97
 Autres Opérateurs
Le langage Java fourni d’autres opérateurs qui sont fournis dans le tableau ci-dessous.
Operateur Utilisation Description
?: op1 ? op2 : op3 si op1 est true, retourne op2; sinon, reoturne op3
Voir Création et Utilisé pour déclarer un tableau, pour créer un
[] utilisation des tableau, et pour accéder aux éléments d’un
tableaux   tableau.
Voir Utilisation des Utilisé pour former des noms longs (ou nom
.
Objets   qualifiés)
Voir Définition des Delimite une liste de paramètres séparés par
(params)
méthodes des virgules
Convertit op vers le type spécifié; une
(type) (type) op exception est relevée si le type de op n’est pas
compatible avec type
Voir Utilisation des
Objets et Création
new Crée un nouveau objet ou tableau.
et Utilisation des
tableaux  
instanceof op1 instanceof op2 Retourne true si op1 est une instance de op2.
98
 Operateurs Java
Le tableau ci-dessous donne la liste complète des opérateurs du langage Java.

Operateur Utilisation Description

+ +op Promotes op to int if it's a byte, short, or char
- -op Arithmetically negates op
+ op1 + op2 Adds op1 and op2; also used to concatenate strings
- op1 - op2 Subtracts op2 from op1
* op1 * op2 Multiplies op1 by op2
/ op1 / op2 Divides op1 by op2
% op1 % op2 Computes the remainder of dividing op1 by op2
Increments op by 1; evaluates to the value of op before it
++ op++
was incremented
Increments op by 1; evaluates to the value of op after it
++ ++op
was incremented
Decrements op by 1; evaluates to the value of op before
-- op--
it was decremented
Decrements op by 1; evaluates to the value of op after it
-- --op
was decremented 99
> op1 > op2 Returns true if op1 is greater than op2
>= op1 >= op2 Returns true if op1 is greater than or equal to op2
< op1 < op2 Returns true if op1 is less than op2
<= op1 <= op2 Returns true if op1 is less than or equal to op2
== op1 == op2 Returns true if op1 and op2 are equal
!= op1 != op2 Returns true if op1 and op2 are not equal
&& op1 && op2 Returns true if op1 and op2 are both true; conditionally evaluates op2

|| op1 || op2 Returns true if either op1 or op2 is true; conditionally evaluates op2

! !op Returns true if op is false

Returns true if op1 and op2 are both boolean and both
& op1 & op2 true; always evaluates op1 and op2; if both operands are
numbers, performs bitwise AND operation
Returns true if both op1 and op2 are boolean and either
op1 or op2 is true; always evaluates op1 and op2; if both
| op1 | op2
operands are numbers, performs bitwise inclusive OR
operation
Returns true if op1 and op2 are different — that is, if one
^ op1 ^ op2
or the other of the operands, but not both, is true 100
 Shifts bits of op1 left by distance op2; fills with 0 bits on
<< op1 << op2
the right side
Shifts bits of op1 right by distance op2; fills with highest
>> op1 >> op2
(sign) bit on the left side
Shifts bits of op1 right by distance op2; fills with 0 bits on
>>> op1 >>> op2
the left side
Bitwise AND if both operands are numbers;
& op1 & op2
conditional AND if both operands are boolean
Bitwise OR if both operands are numbers;
| op1 | op2
conditional OR if both operands are boolean
^ op1 ^ op2 Bitwise exclusive OR (XOR)
~ ~op Bitwise complement

101
= op1 = op2 Assigns the value of op2 to op1
+= op1 += op2 Equivalent to op1 = op1 + op2
-= op1 -= op2 Equivalent to op1 = op1 - op2
*= op1 *= op2 Equivalent to op1 = op1 * op2
%= op1 %= op2 Equivalent to op1 = op1 % op2
&= op1 &= op2 Equivalent to op1 = op1 & op2
|= op1 |= op2 Equivalent to op1 = op1 | op2
^= op1 ^= op2 Equivalent to op1 = op1 ^ op2
<<= op1 <<= op2 Equivalent to op1 = op1 << op2
>>= op1 >>= op2 Equivalent to op1 = op1 >> op2
>>>= op1 >>>= op2 Equivalent to op1 = op1 >>> op2

102
 If op1 is true, returns op2; otherwise, returns
?: op1 ? op2 : op3
op3
Voir Création et
Used to declare arrays, to create arrays, and
[] utilisation des
to access array elements
tableaux  
Voir utilisation des
. Used to form long names
objets
Voir Définition des Delimits a comma-separated list of
(params)
méthodes   parameters
Casts (converts) op to the specified type; an
(type) (type) op exception is thrown if the type of op is
incompatible with type
Voir utilisation des
objets et création
new Creates a new object or array
et utilisation
destableaux

instanceof op1 instanceof op2 Returns true if op1 is an instance of op2

103
 Expression, Instructions et Blocs

Expressions

Une expression est une combinaison de variables, d’opérateurs, et d’appels de

méthodes, qui est construite en respectant la syntaxe du langage , et dont

l’évaluation produit une seule valeur.

Les expressions sont utilisées pour calculer et affecter des valeurs aux variables.

Elles sont aussi utilisées pour aider au contrôle du déroulement de l’exécution

d’un programme

104
 Ordre de priorité des opérateurs

Soit l’expression:
4+7*2
Quel est le résultat de son évaluation? :
11 * 2 = 22 //évaluation du + en premier
ou
4 + 14 = 18 // évaluation de * en premier

Pour éviter cette ambiguité on peut utiliser les parenthèses: Par exemple :
(4 + 7) * 2 : donnera comme résultat 22 car l’expression entre parenthèse est
évaluée en premier

En absence de parenthèses l’ordre d’évaluation est déterminé par l’ordre de

priorité des opérateurs qui est établi par le langage Java et fourni dans le
tableau suivant

105
 Ordre de Priorité des opérateurs dans l’ordre décroissant
Type d’opérateurs Priorité
postfix expr++ expr--
unaire ++expr --expr +expr -expr ~ !
multiplicatif * / %
additif + -
décalage << >> >>>
relationnel < > <= >= instanceof
egalité == !=
AND bit à bit &
XOR bit à bit ^
OR bit à bit |
AND logique &&
OR logique ||
Conditionnel ?:
Affectation = += -= *= /= %= &= ^= |= <<= >>= >>>=
106
 Ordre de Priorité des opérateurs

Les opérateurs qui ont une priorité plus élevée s’évaluent avant ceux qui ont une
priorité relativement plus faible.

Donc l’expression 4 + 7 * 2 est équivalente à 4 + (7 * 2) = 18

Les opérateurs qui se trouvent sur la même ligne ont la même priorité.

Lorsqu’une expression contient des opérateurs de même priorité, les opérateurs binaires,
excepté les opérateurs d’affectation, sont évalués de la gauche vers la droite ;

Exemple : 14 / 2 * 3 = 7 * 3 = 21

par contre les opérateurs d’affectation sont évalués de la droite vers la gauche.

Exemple: y = x = 5; est équivalente à y = (x = 5)

107
 Fonctions Mathématiques

Les fonctions mathématiques classiques se trouvent dans la classe Math. Le

tableau ci-dessous fournit quelques fonctions:
Fonction Description

sqrt double sqrt(double x) : Calcule la racine carrée d’un réel positif

x
pow double pow(double x, double a): Calcule la puissance xa.
sin double sin(double x): calcule le sinus de x
cos double cos(x) : calcule le cosinus de x
exp double exp(double x): Calcule l’exponentielle de x(ex)
log double log(double x):Calcule le logarithme de x
round long double round(x) : retourne l’entier le plus proche de x

Remarque: Toutes ces méthodes sont statiques et pour les utiliser

directement sans préfix, il faut ajouter en haut de votre programme la ligne:
108
import static java.lang.Math.*;
 Questions and Exercises: Operators
Questions

1.Consider the following code snippet.

arrayOfInts[j] > arrayOfInts[j+1]
Which operators does the code contain?

2.Consider the following code snippet.

int i = 10; int n = i++%5;
a.What are the values of i and n after the code is executed?
b.What are the final values of i and n if instead of using the postfix increment
operator (i++), you use the prefix version (++i))?

3.To invert the value of a boolean, which operator would you use?

4.Which operator is used to compare two values, = or == ?

5.Explain the following code sample: result = someCondition ? value1 : value2;

109
110
 Instructions

Les instructions sont l’équivalents des phrases dans un langage naturel

Une instruction est une unité complète d’exécution.

Les expressions ci-dessous peuvent se transformer en instructions en les

terminant par un point virgule ( ;).

- Expressions d’affectation

- N’importe quelle utilisation de ++ et --

- Appels de méthodes

- Expressions de création d’objets

111
De telles expressions sont appelées des instruction-expressions

Ci-dessous, des exemples d’instruction-expressions.

uneValeur = 14.5 ; //instruction d’affectation

uneValeur++ ; //instruction d’incrémentation

System.out.println(uneValeur) ; //Appel d’une méthode

Integer integerObject = new Integer(4) /Création d’un objet

En plus des instruction-expressions, il ya deux autres types d’instructions.

- Instruction de déclaration de variables.

Exemple : double uneValeur = 14.5; //instruction déclaration

- Instruction de contrôle qui détermine l’ordre d’exécution des instructions.

Les instructions if et for sont des exemples d’instructions de contrôle.

Exemple : if (a>b) {
Max = a;
} 112
 Bloc

Un bloc est un groupe d’instructions placées entre crochet {} et peut être utilisé

n’importe où une instruction simple est autorisée. Le code qui suit présente deux

blocs qui contient chacun une seule instruction

.
if (Character.isUpperCase(aChar)) {

System.out.println("The character " + aChar + " is uppercase.");

}

else {

System.out.println("The character " + aChar + " is lowercase.");

}

113
 Instructions de contrôle d’exécution
Lorsque vous écrivez un programme, vous écrivez une suite d’instructions que vous

Stockez dans un fichier

Sans les instructions de contrôle d’exécution, l’interpreteur excutera vos instructions

dans l’ordre ou elles apparaissent dans le fichier de gauche à droite et du haut en bas

Vous pouvez utilisez les instructions de contrôle pour :

- Exécuter des instructions en fonction de l’évaluation d’une condition

- Répéter l’exécution d’un même groupe d’instructions

Autrement dit pour changer l’ordre séquentiel d’exécution des instructions du

programme

114
Par exemple, dans la partie du code ci-dessous, l’instruction if exécute l’instruction

System.out.println statement uniquement dans le cas ou la valeur retournée par

Character.isUpperCase(aChar) est égale à true.

char aChar;
...
if (Character.isUpperCase(aChar)) {

System.out.println("The character " + aChar + " is uppercase.");

115
 Instructions de contrôle d’exécution

Le langage Java fournit plusieurs instructions de contrôle d’exécution.

Elles sont fournies dans le tableau ci-dessous

Type d’instruction Mot clé

boucle while, do-while, for
sélection if-else, switch-case
Gestion des
try-catch-finally, throw
exceptions
saut break, continue, label:, return

116
 Format général d’une instruction de contrôle

Le format général d’une instruction de contrôle d’exécution est :

Instruction de contrôle details {

Instruction(s)

Techniquement, les accolades — { and } — ne sont pas obligatoires si le bloc contient

Une seule instruction.

Cependant, il est recommandé de toujours utiliser les accolades parce qu’elles rendent

le code plus facile à lire, et aident à éviter de faire des erreurs lorsqu’on modifie le

programme.
117