COURS 1

- INTRODUCTION
- LES ÉLÉMENTS
TRADITIONNELS DE
JAVA
 La programmation
orientée objet
2

 Motivation de l’approche objet :

Insuffisance des approches traditionnelles de
programmation pour la mise en œuvre des
applications informatiques modernes sur le
plan de :
 la modélisation
 la qualité des logiciels (maintenance et réutilisation)

 L’approche objet :
Méthode de conception et de production de
logiciels qui vise à améliorer la qualité et la
productivité du logiciel
 Elle se caractérise par une modélisation plus
naturelle du monde réel et par l'élaboration de
logiciels souples et réutilisables.
 Elle consiste à reproduire des éléments du monde
réel par des données informatiques appelées objets.
 Les langages orientés
objets
3

 Langages à l’origine de la
programmation par objets:
 LISP, SIMULA, ADA

 Langages objets :
 Purs : SMALLTALK, EIFFEL,JAVA
 Hybrides : C++, Objective-C, O-O
Pascal
 Historique de Java
4

 But :
 Faire un langage indépendant de la CPU
 Réalisation :
 Création du langage Oak par James Gosling
en 1991 chez Sun commercialisé depuis 1995
Depuis plusieurs éditions ont été créées…

 Trois plateformes Java:

 Java Standard Edition (J2SE / Java SE) :
environnement d'exécution et ensemble
complet d'API pour des applications de type
desktop. Cette plate-forme sert de base en
tout ou partie aux autres plateformes
 Java Enterprise Edition (J2EE / Java EE) :
environnement d'exécution reposant
intégralement sur Java SE pour le
développement d'applications d'entreprises
 Java Micro Edition (J2ME / Java ME) :
environnement d'exécution et API pour le
développement d'applications sur appareils
mobiles et embarqués dont les capacités ne
permettent pas la mise en œuvre de Java SE
 Types d’applications
5

 Avec différentes éditions, les types

d'applications qui peuvent être
développées en Java sont nombreux
et variés :

 Applications desktop (poste de

travail)
 Applications web : applets ,
servlets/JSP, ...
 Applications pour appareil mobile
(MIDP) : midlets
 Applications pour appareil embarqué
(CDC) : Xlets
 Applications pour carte à puce
(Javacard) : applets Javacard
 Applications temps réel
 Qu’est ce que Java?
6

 Un langage
 Langage de programmation orientée objet
 Syntaxe proche du C et du C++

 Une architecture machine virtuelle

 Remplacement du langage machine par le
Byte- code dédié à la JVM (Java Virtual
Machine)
 La JVM est un programme écrit pour
chaque plate-forme et qui interprète le
ByteCode
 Pour exécuter une application Java sur
machine particulière il faut avoir la JVM
correspondante
 Qu’est ce que
Java? (suite)
7

 Un ensemble d’API (Application

Programming
Interface)
 API = Ensemble de librairies
nommées Packages pour faciliter la
tâche du programmeur

 Quelques packages fournis par Java:

 Java.lang : gestion des chaînes de
caractères, interaction avec l’OS
 Java.io : pour les entrées/sorties (clavier,
écran, fichier, …)
 Java.awt: pour l’interface graphique
(fenêtres, boutons, souris, etc..)
 Quelques
caractéristiques de Java
8

 Orienté objet :
 Java est un langage Objet dit
« pur »
 Il possède les qualités de ces
langages orientés objet
 Une meilleure modularité
 Une maintenance aisée des
applications
 Indépendant de la plate-
forme :
Puisque le code Java est compilé en
un ByteCode une application Java
n’est pas liée à une machine ni à un
système d’exploitation particulier.
 Quelques
caractéristiques de Java
(suite1)
9

 Simple :
Java est beaucoup plus simple que certains
langages utilisés actuellement (interdit la
manipulation de pointeurs, fournit une API
riche, syntaxe plus facile que C++)
 Robuste :
 Java est un langage fortement typé
 Il interdit la manipulation des pointeurs
  Sécurisé :
 Différentes vérifications faites par le
compilateur et la JVM
 Limitation des erreurs par la syntaxe du
langage lui même
 Quelques
caractéristiques de Java
(suite2)
10

 Multi-threads :
  thread : entité d’exécution qui peut
s’exécuter en parallèle de manière
concurrente avec d’autres threads au sein
d’une même application.
 Java a la possibilité de fabriquer et de lancer
plusieurs threads en même temps sans
qu’elles ne se bloquent. (ex : gestion de la
souris et d’une impression en parallèle)
  Distribué :
Java supporte des mécanismes de
communication à distance au moyen de son
API réseau. (ex: deux applications Java
distantes peuvent s’échanger des
fonctionnalités)
 Dynamique :
Les composants d’une application (« .class »)
sont chargés au lancement de l’application
 Exécution
d’un programme Java
11

Fichier
source
ASCII(.java)

Compilateur

Fichier
compilé
ByteCode
(.class)

JVM

Programme
Java en
exécution
 Application
12
Java Desktop
 Application indépendante ou
« standalone » :
 Elles’exécute sur une machine
isolée
 Elle est formée d’un ensemble de
fichiers de ByteCode « .class » à
interpréter
 Pour l’exécuter : une JVM + ses
fichiers « .class » + les fichiers
« .class » de l’API qu’elle utilise
 Structure générale
d’une application Java
13

Un exemple simple :
 public class Exemple1{
/* Déclaration des données globales dans la
classe */
 
// Définition des méthodes
public static void main (String [ ] args )
{
// Déclaration des données locales à la fonction

// Traitement : Affichage du message Bonjour

System.out.println (" Bonjour " );
  }
}  
 Quelques
14
commentaires!
 Une application indépendante Java possède un
point d’entrée unique la méthode (ou la fonction)
main de prototype :
public static void main (String [ ] args)
 En Java, tout se trouve dans une classe. Il ne peut y
avoir de déclarations ou du code en dehors du corps
d’une classe.
 Une classe ne contient pas directement du code.
Elle contient des déclarations de variables globales,
que l’on appelle attributs et des méthodes. Les
attributs sont visibles par toutes les méthodes de la
classe.
 Une méthode peut contenir du code et des
déclarations de variables locales qui sont visibles
uniquement dans son corps.
 Tout fichier source doit porter le nom de la classe
publique qu’il contient suivi du suffixe .java (ex :
Exemple1.java)
 Aperçu sur les outils de
développement
15

 Environnements de développement
 Sun JDK 1.1.x (Java Development Kit)
: englobe un compilateur, un
interpréteur, un applet viewer, etc…)
 IDE (Integrated Development Environment) :
Visual Age, Visual J++, …
 Java-mode emacs
 Jbuilder
 Eclipse
 ...
 Navigateurs
 Sun HotJava
 Netscape
 Internet Explorer
 …
LES ÉLÉMENTS
TRADITIONNELS DE
JAVA
 Structure lexicale
17

 Trois notations possibles :

 // Commentaire sur une seule ligne
 / * Commentaire sur une ou plusieurs

lignes */
 /** Commentaire d’explication utilisée par
javadoc sur une ou plusieurs lignes*/

 Points virgules, blocs et blancs

 Les instructions se terminent par un point virgule
‘;’
 Un bloc (ensemble d’instructions) est délimité par
{ et }
 Les blancs (espaces, tabulations et sauts de ligne)
sont autorisés entre les éléments du code source
utilisés pour des raisons de lisibilité
 Identificateurs
18

Un identificateur Java :
 désigne tout objet que le programmeur souhaite
manipuler (ex: objet, variable)
 commence par une lettre, un trait de
soulignement ‘_’, ou un signe dollar ‘$’, seuls
les caractères suivants peuvent être des chiffres
 opère une distinction majuscules/minuscules
 n’a pas de longueur maximale
Exemple s:
MaClasse, _Var, $FonctionDeRecherche1
3Var, -MaClasse, Fonction-Recherche 
 Mots-clés
19

 Les mots réservés (ou mots-clés) ce

sont des identificateurs prédéfinis et qui
ont un sens bien défini
 Les mots réservés ne peuvent pas être
utilisés comme identificateurs dans un
programme.
 Exemples:
boolean
if
else
for
class
 Types élémentaires
Les booléens
20

 Type « boolean » : permet de

représenter les 2 valeurs logiques
VRAI et FAUX :
 Les seules valeurs possibles sont true
ou false
 Un booléen n’est pas considéré
comme une valeur numérique
(comme c’est le cas en C)
 Exemples :
boolean trouve;
trouve = 1; // erreur détectée à la compilation
trouve = true; // instruction juste
 Types élémentaires
Les caractères
21

 Type « char »: permet de représenter

les caractères isolés
 Un caractère isolé en Java est un caractère
Unicode représenté sur 16 bits
 Une constante caractère doit figurer entre
deux apostrophes ‘ ’.
 Exemples :
‘ a’ // la lettre a
‘\u1052’ /* un caractère spécifique Unicode
1052 c’est le code du caractère en
hexadécimal */
 Types élémentaires
Les entiers
22

 Types « byte », «short », « int »,

« long » :

Type Taille
byte 1 octet
short 2 octets
int 4 octets
long 6 octets

 Les expressions littérales entières

sont de type « int » sauf si elles sont
explicitement suivies par la lettre ‘L’.
 Exemples: 
 9   valeur entière du type int , 9L valeur
entière du type long
 Types élémentaires
Les réels
23

 Types « float », «double »  :

Type Taille
float 4 octets
double 8 octets

 Une constante numérique est flottante si:

 Elle contient un point décimal (Ex: 2.3)
 Elle est suivie par la lettre F ou D (Ex: 2.3F)
 Les expressions littérales flottantes sont de
type double sauf si elles sont explicitement
suivies par la lettre ‘F’.
 Les variables
24

 Déclaration, affectation : (comme en C)

Exemples :
int x = 0, y = 0;
float z = 3.14F;
double t = 3.14;
char lettre ;
lettre = ‘a’;
 Expressions, Opérateurs
25

 Les constantes et les variables sont des

expressions
 Les expressions peuvent être combinées
entre elles par des opérateurs et former
ainsi des expressions plus complexes
 Quelques opérateurs:
 arithmétiques : +, -, *, /, %
 logiques : &&, ||
 de comparaison : ==, !=, <, >, <=, >=
 d’affectation : =, +=, -=, *=, %=, /=
 d’incrémentation: ++, --
 Conversion de types
26


Si dans une expression les opérandes sont de
différents types, le résultat de l’opération est
converti vers le type ‘ le plus grand ’
Exemple :
int x =2;
long z, y=4 ;
z = x *y ; // x*y est de type long
 Pour l’affectation la donnée à droite est
convertie dans le type de celle de gauche. Si
le type de la destination est plus faible
l’instruction est erronée.
Exemple :
float z = 14.33; // instruction illégale
 Conversion de types (suite)
27

 Conversion explicite :
Nom_Variable = (Type)
Expression;
Exemple :
float z ;
int x ;
z = (float) 14.33 ;
x = (int)z ; // x contient la valeur 14
 
 La structure alternative
if-else
28

 Syntaxe :
if (<expression booléenne>)
{ <instruction ou bloc >}
else
{ <instruction ou bloc>}
 Remarques :
 Le branchement en Java se fait toujours à
partir d’une expression booléenne (et non
d’une valeur numérique comme en C)
 Le partie else est optionnelle (peut être
omise s’il n’y a pas d’actions à effectuer
lorsque la condition est fausse)
 Les accolades { } sont obligatoires dès
qu’il y a plus d’une instruction dans le
bloc du if ou du else
 La structure alternative
« switch »
29

 Syntaxe :
switch (<expression>) {
case <valeur1>:
<bloc1>
break;
case <valeur2 >:
<bloc2>
break;
…
case <valeurn>:
<blocn>
break;
default :
<blocn+1> }
 Remarques :
 L’expression du « switch » doit être d’un type
compatible avec un entier int (byte, short,
char)
 Les spécifications du « break; » sont
nécessaires pour gérer les ruptures de
séquences
 La structure itérative
« while »
30

 Syntaxe :
while (<expression_ booléenne>)
{
<instruction ou bloc>
}

 Exemple : Somme des 10 premiers

entiers
int Som = 0, i = 1;
while ( i <= 10)
{
Som += i;
i++;
}
 La structure itérative
« do-while »
31

 Syntaxe :
do
{
<instruction ou bloc>
} while (<expression booléenne>);

 Exemple :
int Som = 0, i = 1;
do
{ Som += i;
i++;
} while ( i <= 10) ;
 La structure itérative
« for»
32

 Syntaxe :
for (<initialisation>; <express_ booléenne>;
incrémentation >)
{
<instruction ou bloc>
}
 Remarques:
 Il est possible déclarer une ou plusieurs variables
dans la partie initialisation de la boucle for.
 La visibilité de ces variables est alors limitée au
bloc d’instructions lié à la boucle.
 Exemple :
int Som = 0;
for (int i = 1; i <= 10; i++) {
Som+= i;
}
 Lecture des données par les
arguments du programme
33

 On peut fournir les données à un programme à travers ses

arguments
 Exemple :
class Somme {
public static void main (String [ ] args) {
int s=0;
for (int i = 0; i< 10; i++)
s+= Integer.parseInt(args [i]);
System.out.println (″La somme =″+s);}
}
L’exécution du programme à partir de la ligne de commande
java Somme 2 3 10 23 1 100 16 8 9 4

crée automatiquement le tableau de chaînes de caractères

args avec 10 éléments qui sont passés à la méthode main
:
args[0] = “2” , args[1] = “3“, args[2] = “10“, args[3] = “23“,
args[4] = “1“, args[5] = “100“, args[6] = “16“, args[7] = “8“,
args[8] = “9“, args[9] = “4“
 Affichage sur écran
34

 System.out.println : méthode permettant

l’affichage sur écran avec un saut de ligne
 System.out.print : méthode permettant
l’affichage sur écran sans saut de ligne
 Syntaxe :
System.out.print/ln ([<constante/variable>
[+<constante/variable>+…]]);
 Exemples:
 S.o.p (″Bonjour ″);
 S.o.p (″Bon\njour″);
 S.o.p (″Je dis : \ ″Bonjour\″ ″);
 S.o.p (″200″+ ″15″ );
 S.o.p (″200″+ 15);
 S.o.p (200+ 15 );
 S.o.p (″ x=″ + x );
 S.o.p ( x+y );
ATTENTION :
S.o.p : pour faire plus court mais à ne pas écrire dans vos
programmes!
 Affichage sur écran (suite)
35

Exemple:
class Somme {
public static void main (String [ ] args) {
int s=0;
System.out.println (″ Ce programme
effectue la somme de 10 éléments passés à
main ″);
for (int i=0; i< 10; i++)
{
S.o.p (″L’élément num+″i+1+″est
= ″ + args[i]);
s+= Integer.parseInt(args [i]);
}
S.o.p (″ La somme = ″ + s);
} //main
}// Somme
 Les tableaux
37

 Principe général :
 En java le type tableau est assimilable
à une classe et un tableau est un objet
de cette classe
 Une variable tableau ne représente pas
l’objet lui même mais son adresse
mémoire
 Déclarer un tableau revient à réserver
de la place mémoire pour son adresse
 Pour créer un tableau il faut lui allouer
de l’espace mémoire
 Déclaration d’un tableau à une
dimension
38

 Syntaxe :
<Type> <NomduTableau> [ ];
Ou
<Type> [ ] <NomduTableau>; // style plus standard
 Exemples:
int tabNotes [ ]; // Un tableau d’entiers
char [ ] tabLettres; // Un tableau de caractères
short t1 [100] ; // instruction illégale
 Explication :
int tabNotes [ ];

tabNotes ???????

Réservation de la variable référence allant contenir

l’adresse du tableau
 Création et initialisation d’un
tableau à une dimension

39

 Syntaxe:
<nomduTableau> = new <Type> [<Dimension>];
 Exemple :
int [ ] tabNotes ;
tabNotes = new int [100];
ou
int [ ] tabNotes =new int [100];

tabNotes 0x123 0123

 Initialisation :
 Par défaut :
À la création il y a initialisation par défaut (zéro pour
pour les entiers et les réels, false pour les booléens
et « null » sinon)
 Explicite :
L’initialisation d’un tableau lors de sa déclaration
permet de le créer
Exemple : int [ ] tab = {3, 5}; 
int [ ] tab = new int [2];
tab[0] = 3;
tab[1] = 5;
 Utilisation d’un tableau à une
dimension
40

 L’accès à un élément d’un tableau : (comme en

C)
 Le premier élément commence à l’indice 0
 Le dernier élément a pour indice n-1 (n: dimension du
tableau)
 S’il y a dépassement des limites du tableau : erreur à la
compilation
 Exemple :
int [ ] tab = new int [100];
tab[0] = 1;
tab[100] = 1; // erreur détectée à la compilation
 La taille d’un tableau est contenue dans une variable
membre : « length » on l’obtient :
<NomduTableau>.length
Exemple :
int [ ] tab = new int [100];
for (int i = 0; i < tab.length; i++)
tab[i]++;
 Déclaration et Création d’un
tableau à 2 dimensions

41

Un tableau à 2 dimensions est à interpréter comme un

tableau de tableaux
 Syntaxe :
<Type> [ ] [ ] <NomduTableau> = new <Type> [N1] [ ];
<NomduTableau> [0] = new <Type> [N20];
<NomduTableau> [1] = new <Type> [N21];
…
<NomduTableau> [N1-1] = new <Type> [N2n1-1];
 Exemple :
int [ ] [ ] triangle = new int [3][];
triangle [1] = new int [3];
triangle [1] = new int [2];
triangle [1] = new int [1];
 Cas d’un tableau rectangulaire :
<Type> [ ] [ ] <NomduTableau> = new <Type> [N1] [ N2];
Exemple :
int [ ] [ ] matrice = new int [4] [5];
 Initialisation et utilisation d’un
tableau à 2 dimensions

42

 Initialisation :
L’initialisation d’un tableau lors de sa déclaration
permet de le créer
Exemple :
int [ ][ ] matrice = {{2, 3},{1}};

int [ ][ ] matrice = new int [2][ ];
matrice [0] = new int [2];
matrice [0][0] = 2;
matrice [0][1] = 3;
matrice [1] = new int [1];
matrice [1][0] = 1;
 Utilisation :
 Les indices commencent à 0
 Le nombre de tableaux éléments peut être obtenu en
utilisant la variable membre « length »
Exemple :
int [ ][ ] matrice = {{2, 3, 4},{1}};
matrice.length vaut 2
matrice[0].length vaut 3
matrice[1].length vaut 1