Chapitre II :

Eléments de base du langage

java

A.Hammache 20
Plan du Chapitre

Introduction et historique

JDK, JRE et packages de base

Structure d’un programme Java

Types de données

Opérateurs

Instructions

Tableaux et chaines de caractères

A.Hammache 21
 Origine du langage
 Développé par SunSoft (SUN) pour réaliser des systèmes embarqués
 Projet « Oak »
 Évolution gérée par JavaSOFT (SunSoft)
 Repris par Oracle
 Quelques liens
 http://
 http://www.developer.com/
 http://www.javaworld.com/
 http://tips.iworld.com/
 Livres
 La programmation objet en Java : Michel Divay, Dunod , 2006.

A.Hammache 22
 Java est simple
Simplicité relative par rapport au C++

1. Certains concepts du C++ à l’origine de

nombreux bugs ont été supprimés
 Pointeurs
 Surcharge des opérateurs

2. Des études comparatives de développement

montrent une diminution du coût de
développement de 30 à 35 %.

A.Hammache 23
 Java est un langage objet
 Java reprend des caractéristiques de différents langages à
objets
 La syntaxe de C++
 La gestion dynamique de la mémoire de SmallTalk

1. Toute ligne de code JAVA se trouve obligatoirement dans

une méthode à l’intérieur d’une classe

2. Java implémente les concepts de l’orienté objet

 Encapsulation
 Héritage
 Polymorphisme

A.Hammache 24
 Java est robuste et sûr
 Contrôle de typage « fort »

 Le compilateur vérifie que les erreurs sont traitées par le développeur

 Si une erreur retournée par une méthode n’est pas traitée, le programme ne
compilera pas

 La gestion de la mémoire n’est pas à la charge du développeur

 Garbage Collector (ramasse-miettes)
 Pas de pointeurs

 Un débordement d’index dans un tableau provoque une erreur

 La mémoire n’est pas écrasée

A.Hammache 25
 JAVA est portable
 Un code source Java est compilé pour générer un code assembleur virtuel : le
bytecode

1. Ce code est conçu pour :

 Etre rapidement interprété
 Etre optimisable au moment de son exécution
 Etre facilement traduit en instructions assembleur lors de son exécution
 Etre compact
o en moyenne, une instruction bytecode = 1,8 octet
 Etre vérifiable

2. Le bytecode est exécuté par un logiciel : la Machine Virtuelle

3. La machine virtuelle est dépendante de la plate-forme: pour chaque plate

forme (Windows, linux, etc.) il existe une machine virtuelle.

A.Hammache 26
Comment il fonctionne …!

A.Hammache 27
 Exemple
Bytecode
0: iconst_2
1: istore_1
2: iload_1
Programme source java 3: sipush 1000
6: if_icmpge 44
outer:
9: iconst_2 10: istore_2 11: iload_2
for (int i = 2; i < 1000; i++) {
12: iload_1
for (int j = 2; j < i; j++) {
13: if_icmpge 31
if (i % j == 0) continue outer;
16: iload_1
}
17: iload_2 18: irem
System.out.println (i);
19: ifne 25
}
22: goto 38
25: iinc 2, 1
28: goto 11
Compilation 31: getstatic #84;
(javac) 34: iload_1
35: invokevirtual #85;
38: iinc 1, 1
41: goto 2
44: return
A.Hammache 28
 Les indispensables (JDK / JRE)
 Le JRE= Java Runtime Environment
Il contient :
 la machine virtuelle
 Un ensemble de classes de base regroupées en packages
 Interface utilisateur, conteneurs, gestion des threads, réseau, etc.

Le JDK = Java Development Kit

Il contient :
 JRE
 Des exécutables (outils) : compilateur (javac) , débuggeur, (jdb)
générateur de documentation (javadoc), etc.

A.Hammache 29
 Les packages de base
AWT et Swing
 boutons, listes, menus, etc.
Réseau
 Sockets (serveurs, clients), Web (URL), Applet…
Entrée-sortie
 Fichier, Pipe, accès direct, etc.
Classes de base
 Date, Chaîne de caractères
RMI
 Remote Method Invocation

A.Hammache 30
 Les packages de base
JDBC
 Accès aux bases de données relationnelles
Beans
 Composant Java
Sécurité
 Cryptage, identification, signature
Internationalisation
 Format de date/heure
 Messages localisés
 Caractères UNICODE 2
Utiles
 Collection, Compression

A.Hammache 31
 Les environnements de développement
 Ils offrent des fonctions avancées :
– Éditeur évolué (couleur, autocorrection, présentation, etc.)
– Assistance syntaxique
– Générateur de code
– Débugage
– Environnement d’exécution
– …

A.Hammache 32
Constitution d’un programme java
 Un programme Java est composé d’un ensemble de classes
 Les classes sont regroupées en package
 Une classe regroupe un ensemble d’attributs et de méthodes

Package n
Package 1

Classe 1
Attributs

Méthodes

A.Hammache 33
 Premier programme en Java
public class Exemple{
public static void main (String argv[])
{
System.out.println("MON PREMIER PROGRAMME JAVA ");
}
}

 public class Exemple: nom de la classe

 public static void main: nom de la fonction principale (point d’entrée d’un
programme java)
String argv[]: permet de récupérer les arguments transmit au programme au
moment de son exécution
 System.out.println("MON PREMIER PROGRAMME JAVA "): méthode
d’affichage dans une fenêtre console

A.Hammache 34
 Étapes de mise en oeuvre
1. Edition (saisie): saisir le programme source java avec un
éditeur.
 Le nom de fichier doit être le même que le nom de la
classe (nom de fichier= Exemple.java).
2. Compilation: produire le bytecode à partir de fichier source
(.java) en utilisant la commande javac
 javac Exemple.java
Génération d’un fichier bytecode Exemple.class
3. Exécution: exécuter le bytecode obtenu en utilisant la
commande java
 java Exemple
• ne pas mettre .class pour l’exécution.

A.Hammache 35
 Briques de base de java

 Les briques de base du langage: Nous traitons Java d'abord

comme un langage de programmation classique. Nous
aborderons les objets ultérieurement.
 Les composantes de bases sont :
 Ce qui permettent de stocker des données (types):
variables, constantes, etc.
 Les expressions qui permettent de manipuler les données:
affectation, comparaison, etc.
 Les instructions pour construire les algorithmes: test,
boucle, etc.
 Les objets

A.Hammache 36
 Les commentaires
 Les commentaires: Ils permettent de clarifier le code. Ils ne sont pas pris en
compte par le compilateur.
 Il existe trois types de commentaires en Java :

Type de commentaire Exemple

commentaire abrégé // commentaire sur une seule ligne

int N=1; // déclaration du compteur
commentaire multi lignes /* commentaires ligne 1
commentaires ligne 2 */

commentaire de documentation automatique /**

* commentaire de la méthode
* @param val la valeur à traiter
* @since 1.0
* @return Rien
* @deprecated Utiliser la nouvelle méthode XXX
*/
A.Hammache 37
 Les types de données en Java
 Types arithmétiques
Entiers byte 8 bits signé (-128 , 127)
short 16 bits signé (-32768 , 32767)
int 32 bits signé (-2147483648 , 2147483647)
long 64 bits signé (-9223372036854775808,
9223372036854775807)
Réels float 32 bits signé (1.4E-45 , 3.4028235E38)
double 64 bits signé (4.9E-324 ,
1.7976931348623157E308)

 Type caractère

char 16 bits non signé UNICODE

 Type booléen
boolean 1 bit deux valeurs possibles : true ou false
A.Hammache 38
 Les identificateurs
 A chaque objet, classe, variable, constante est associé un nom (identificateur).
L’identificateur peut se composer de tous les caractères alphanumériques et
des caractères _ et $.
 Le premier caractère doit être une lettre, le caractère de soulignement
(_) ou le signe dollar ($).
 Java est sensible à la casse: ( id <>iD)
 Un identificateur ne peut pas appartenir à la liste des mots réservés du langage
Java . Cette liste est la suivante:

abstract const final int public throw assert continue finally

interface return throws boolean default float long short transient
break do for native static true byte double goto
new strictfp try case else if null super void
catch enum (Java 5) implements package s witch volatile
Char extends import private synchronized while class false
instanceof protected this

A.Hammache 39
 Déclaration de variables
 La Syntaxe de la déclaration:
type maVariable; // maVariable est un identificateur
 Exemples
int p ; // p est une variable de type entier
double x ; // x est une variable de type flottant
char c; // c est une variable de type caractère
boolean b ; // b est une variable de type booléen
int X,Y,Z ; // Il est possible de déclarer plusieurs variables de même type en les
// séparant par une virgule.
 La syntaxe de la déclaration et de l’initialisation d’une variable :
type maVariable=valeur; // Déclaration et initialisation de la variable
 Exemples
boolean result = true;
char capitalC = ‘C’;
byte b = 100;
short s = 10000;
int i = 100000;
int decVal = 26; // Le nombre 26 en décimal
int octVal = 032; // Le nombre 26 en octal
int hexVal = 0x1a; // Le nombre 26 en hexadécimal
double d1 = 123.4;
double d2 = 1.234e2; // notation scientifique
float f1 = 123.4f; A.Hammache 40
 Déclaration de constantes
 Java définie une constante grâce au mot clé final: elle ne peut être
initialisée qu'une seule fois de façon statique (à la compilation) ou
dynamique. Une fois la valeur affectée, elle ne peut plus être
modifiée.

 La syntaxe de la déclaration d’une constante

final type CONSTANTE; // CONSTANTE est un identificateur
 Exemple:
final int C=20; // Constante entière ayant une valeur 20
C= 15; // erreur de compilation

A.Hammache 41
 Les opérateurs
 Un opérateur applique une fonction sur des opérandes
(variables ou valeur) => valeur de retour

 La valeur de retour d’un opérateur dépend de l’opérateur,

mais aussi du type de ses opérandes

 Les différents opérateurs sont:

 L’opérateur d’affectation
 Les opérateurs arithmétiques
 Les opérateurs unaires
 Les opérateurs de comparaison
 Les opérateurs logiques

A.Hammache 42
 L’opérateur d’affectation
L’opérateur « = » permet d’affecter la valeur
de l’expression qui est à droite à la variable qui
est à gauche.
 Exemple
class Test {
int calculer () {
int i = 0; // Affecter la valeur 0 à la variable i
int j = 6; // Affecter la valeur 6 à la variable j
i = (j + 5) * 3; // Affecter la valeur de l’expression à i
return i + j;
}
}

43 A.Hammache
 Les opérateurs arithmétiques

S’appliquent sur les types entiers ou réels

+, - , * , / , % (modulo) , += , -= , *= , /=
 Exemples
int x, y, z;
y = 2;
z = 3;

x = y * z ; //x vaut 6
x += 2 ; //x vaut 8 (équivalente à x=x+2;)
y = x / 4 ; //y vaut 2
y =x % 2 ; //y vaut 0

En terme de performance, il est recommandé

d’utiliser la notation raccourcie (+=,*=,-=)

A.Hammache 44
 Les opérateurs unaires
S’appliquent sur un seul opérande de type entier ou réel:
-, --, +, ++
 Exemple
int x, y;
x = 3;

y = -x ; //y vaut -3
y = ++x ; //y vaut 4, x vaut 4
y = x-- ; //y vaut 4, x vaut 3

La pré et la post-incrémentation diminuent le nombre de

lignes de bytecode générées
y = ++x ;  x=x+1; y=x;
y = x-- ;  y=x; x=x-1;
A.Hammache 45
 Les opérateurs de comparaison

S’appliquent sur des entiers, réels et booléens:

== (égal) , != (différent), < (inférieur), <= (inférieur ou
égal), > (supérieur), >= (supérieur ou égal).
Ces opérateurs retournent une valeur du type
booléen
 Exemple
{
boolean droitDeVote;
int age;
…………
droitDeVote = (age >= 18) ;
}

A.Hammache 46
 Les opérateurs logiques

S’appliquent au type boolean

 ! (not) , && (and) , II (or)
 &, I
Retournent un type boolean
& renvoie «true» si les deux expressions
renvoient «true»
&& a le même comportement mais n’évalue pas
la seconde expression si la première est «false»
| renvoie «true» si l’une des deux expressions
renvoie «true»
|| a le même comportement mais n’évalue pas la
seconde expression si la première est «true»

A.Hammache 47
 Un opérateur spécial : l’opérateur ?

la syntaxe:
expression1? expression2: expression3;
expression1 est évaluée en premier (retourne une
valeur booléenne). Si sa valeur est true, expression2
est calculée, sinon expression3 est calculée.
 Exemple
int x = 3, y = 4, max;
max = (x > y)? x: y; //Ceci revient à dire que max=y;

Dans ce code, max reçoit la valeur de x ou de y, selon

que x est supérieur à y ou non.

A.Hammache 48
 La priorité des opérateurs
 Java définit la priorité des opérateurs comme suit (du plus prioritaire au moins
prioritaire )
les parenthèses ()
les opérateurs d'incrémentation ++ , --
les opérateurs de multiplication, division, et modulo *, /, %

les opérateurs d'addition et soustraction +,-

les opérateurs de décalage << , >>
les opérateurs de comparaison < , > , <= , >=
les opérateurs d'égalité == , !=
l'opérateur OU exclusif ^
l'opérateur ET &
l'opérateur OU |
l'opérateur ET logique &&
l'opérateur OU logique ||
les opérateurs d'assignement (affectation) = , += , -=

A.Hammache 49
 Les conversions de type (1/2)
Il y a 4 contextes possibles de conversion:
 Conversion explicite (cast)
 Conversion implicite:
o Affectation
o Appel de méthode
o Promotion arithmétique

Certaines conversions (cast) provoquent une perte

de valeur
 float en int, int en short, short en byte

Le type boolean ne peut pas être converti en entier

A.Hammache 50
 Les conversions de type (2/2)
Exemple
double f =3.14 ;
int i,j ;
short s ;

i = (int)f; // float  int (conversion explicite)

float ff = (float)3.14;

i = s; // short  int (affectation)

// Appel de la méthode int obj.m(int i)

obj.m(s); // short  int (appel de méthode)

f = i / (double)j; // conversion explicite de j

// promotion arithmétique de i

A.Hammache 51
 Les Instructions
Java propose un ensemble d'instructions qui permettent
d'organiser et de structurer les traitements. L'usage de ces
instructions est similaire à celui rencontré dans d'autres langages.
Ces instructions sont :
 Les tests conditionnels (if else, switch case);
 Les boucles (for, while);
 Les débranchements (break, continue).

A.Hammache 52
 Test conditionnel (if …else)
 la syntaxe : Exemple
class Test {
public static void main
if (condition) { (String args[]) {
Bloc d’instruction int compteur ;
} lire(compteur);
else { if (compteur == 0)
System.out.println("Début
Bloc d’instruction de la partie");
} else if (compteur ==10)
System.out.println("Fin
de la partie");
else if ((compteur >0)
 condition est de type booléen &&(compteur<10))
System.out.println("Partie en
 le if ne nécessite pas de then cours");
 si Bloc d’instruction a une seule }
instruction alors pas besoin des {} }

A.Hammache 53
 Test conditionnel Switch …case
 Syntaxe : Exemple
switch (expression) { class Test {
public static void main (String args[])
case constante1 : {
instr11;
char c = (char)System.in.read();
instr12; switch(c) {
break; case ‘o’ : case ‘O’ :
case constante2 : System.out.println("Oui");
... break;
default : case ‘n’ : case ‘N’ :
... System.out.println("Non");
} default :
break;
 Le « switch » ne s’applique qu’au
type entier ou caractère. System.out.println("Mauvaise
réponse");
 Si un case ne contient pas de break break;
alors les traitements associés au }
}
case suivant sont exécutés. }
 Il est possible d'imbriquer des
switch
A.Hammache 54
 Boucles while
 Syntaxe Exemple
while ( condition)
{ class Test {
... // code à exécuter dans la boucle public static void main
} (String args[]) {
int n = 10;
Condition est de type booléen. int somme = 0;
Le code est exécuté tant que la int i= 1;
condition est vraie. Si avant
l'instruction while, la condition est while( i<=n){
somme += i;
fausse, alors le code de la boucle ne i++;
sera jamais exécuté. }
 Autre syntaxe System.out.println(" la
somme des "+n+" premiers
entiers est : "+somme);
do { }
... // code à exécuter dans la boucle
} while ( condition)

Dans ce cas le code est exécuté au Résultat:

moins une fois. la somme des 10 premiers entiers est : 55
A.Hammache 55
 Boucle for
 Syntaxe : Exemple
for ( initialisation; condition; modification)
{ class Test {
... public static void
main(String args[]) {
}
int n = 10;
int somme = 0;
Condition est de type booléen
 Dans l'initialisation, on peut déclarer for(int i=1; i<=n; ++i)
somme += i;
une variable qui servira d'index et qui
sera dans ce cas locale à la boucle System.out.println(" la
Il est possible d'inclure plusieurs somme des "+n+" premiers
traitements dans l'initialisation et la entiers est : "+somme);
}
modification de la boucle: chacun des
}
traitements doit être séparé par une
virgule.

Résultat :
la somme des 10 premiers entiers est : 55
A.Hammache 56
 Les débranchements

break: permet de quitter immédiatement une

boucle ou un branchement (switch …case).
continue: s'utilise dans une boucle pour passer
directement à l'itération suivante.
break et continue peuvent s'exécuter avec des
blocs nommés. Il est possible de préciser une
étiquette pour indiquer le point de retour lors de
la fin du traitement déclenché par le break.
Une étiquette est un nom suivi de deux points
qui définit le début d'une instruction.
A.Hammache 57
 Exemples
int x = 0; for ( int x = 0 ; x < 6 ; x++)
while (x < 6){ {
System.out.println(x); if(x == 4)
continue; //revient au début de la
x++; //boucle avec x=5
if (x == 4) System.out.println(x);
break; }

}
Résultat:
0
Résultat:
1
0
2
1
3
2
3 5
A.Hammache 58
 Les tableaux : description

 Nombre fixe d’éléments. Taille fixée à la construction.

 Les éléments sont de même type (type de base ou classe).

 Les tableaux sont alloués dynamiquement par l’opérateur

« new ».

 Un tableau est détruit lorsqu’il n’est plus référencé.

 Les tableaux multidimensionnels sont des tableaux de

tableaux.
A.Hammache 59
 Les tableaux : déclaration
Les tableaux peuvent être déclarés avec les
syntaxes suivantes :
type [] nom ;
type nom [];

 Exemples :
int table[];
double [] d1,d2 ;

A.Hammache 60
 Les tableaux : initialisation

L’attribut « length » renvoie la dimension du

tableau.
L’indice des éléments du tableaux varie de 0 à
« tableau.length –1 ».
Initialisation statique :
int[] monTableau = {1, 2, 3};

Initialisation dynamique :
int[] param = new int[10];

for (int i = 0; i < param.length ; i++)

param[i]= i;
61 A.Hammache
 Les chaines de caractères
Les chaînes de caractères sont manipulées par la
classe String (ce n’est donc pas un type de base).
 Exemples :
String str = ”exemple de chaine de caractères” ;
String chaine = ”Le soleil ” + ”brille” ; // Opérateur de
//concaténation
La valeur initiale d’une variable du type String est null
(ainsi que pour toutes les variables dont leur type est
une classe d’objets).
String n’est pas un type primitif. Il s’agit d’une classe
du paquetage java.lang.
A.Hammache 62
 TP
Avant de programmer en Java
Le JDK de Oracle(Java Development Kit) est l’outil essentiel pour programmer en
Java. Il permet la compilation, le débogage et l’exception d’applications et d’applets
Java. Après avoir installé le JDK, il faut définir un chemin de recherche des
exécutables « PATH ».
Pour le faire, Lancer une session DOS et taper :

Set Path=C:\JDK\bin ou bien directement Path=C:\JDK\bin

(Donne la valeur C:\JDK\bin à la variable d’environnement path) Ou encore
Set Path=%Path%;C:\JDK\bin
(Ajoute le chemin C:\JDK\bin à la valeur de la variable d’environnement path)
Ceci ne fonctionne que si C:\JDK\ est le répertoire d’installation du JDK. Si ce n’est
pas le cas, remplacer-le par votre vrai répertoire.

A.Hammache 63
Lecture des données à partir du clavier

Utilisation de la classe Scanner définie dans le

package «java.util»
Etapes :
1. Inclure le package : import java.util.*;
2. Créer un objet de la classe scanner (sc) :
Scanner sc=new Scanner(System.in);
3. Lire les données avec la méthode (nextXXX)
 lire un entier : int a = sc.nextInt();
 lire un double : double d=sc.nextDouble();

A.Hammache 64
 Exemple
import java.util.*; // inclure le package

public class exemple{

public static void main(String[] args) {
Scanner sc=new Scanner(System.in); // création d’un
//objet de type scanner
int a=sc.nextInt(); // lecture d’un entier
double d=sc.nextDouble(); // lecture d’un double
}
}

A.Hammache 65
A.Hammache 66