Université Sidi Mohamed Ben Abdellah

Faculté des Sciences Dhar El-Mehraz Fès

Département d’Informatique

Introduction au Langage Java

Par Noureddine Chenfour

1997-2020

Introduction au Langage Java, par N. Chenfour - p. 1

 Chapitre 1. Environnement
de développement Java

1.1 Introduction
Java est un langage de programmation à objets développé par Sun
Microsystems. Sa première version a été publiée en 1995.

Le langage Java est un langage qui dérive du C/C++ tout en imposant un

seul mode de programmation : par les objets. Java dispose d’un mécanisme
de gestion de mémoire très puissant. En effet, tous les objets gérés par un
programme Java sont créés dynamiquement. De plus, périodiquement ou à
chaque fois qu’on a besoin de la mémoire un processus de gestion de
mémoire « Garbage-Collector » (ou ramasse-miettes) est exécuté
automatiquement pour récupérer la mémoire qui n’est plus référencée par
le code. Java est aussi un langage permettant le multithreading avec prise
en charge native de la synchronisation des processus d’une part à l’aide des
primitives de synchronisation telles que « wait() » et « notify »; et d’autre
part à l’aide du mécanisme des moniteurs implémenté par l’intermédiaire
du modificateur « synchronized ».

Java dispose d’une gigantesque bibliothèque de classes spécialisées dans

différentes technologies et différents domaines (de la gestion des chaînes
de caractères jusqu’au cryptage et sécurité des réseaux en passant par des
bibliothèques graphiques, bibliothèque mathématique, accès aux bases de
données JDBC, etc…)

Introduction au Langage Java, par N. Chenfour - p. 2

1.2 Environnement de développement

1.2.1 Langage Java

Il existe deux modes de programmation en Java : le mode Applications et

le mode Applets (qui est devenu ces dernières années plus ou moins
obsolète).

Le mode applications est le mode ordinaire des différents langages de

programmation.

Le mode applets permet de créer des applications pouvant être incorporées

dans des pages Web. Les applets sont en fait des applications particulières
dont le déroulement est prévu sur une page Web (le conteneur est une page
Web et non une fenêtre ordinaire). Le programme applet est ainsi interprété
est exécuté par le navigateur qui doit tout d’abord récupérer le programme
de la même manière qu’il récupère par exemple un fichier image avant de
l’afficher.

1.2.2 Portabilité du langage Java

Le mode de compilation Java constitue la première particularité de ce

langage. En effet, un programme Java (extension .java) est traduit par le
compilateur Java (programme javac.exe) non pas en langage machine
(programme exécutable) mais en un pseudo code intermédiaire appelé
Bytecode indépendant de toute machine ou plate-forme. Le bytecode ainsi
généré (sous forme de fichier d’extension .class) peut ensuite être
interprété sur n’importe qu’elle machine ou plate-forme. Il suffit que celle-
ci dispose d’un programme de traduction adéquat. Celui-ci constitue en fait
ce qu’on appelle « Machine Virtuelle Java » (ou JVM : Java Virtual
Machine). L’un des composants de la machine virtuelle Java est le
programme java.exe permettant d’exécuter directement un programme
.class (en faisant appel à d’autres bibliothèques nécessaires à l’exécution).

La machine virtuelle Java, quant à elle, dépend alors de la plate-forme ou

la machine sur laquelle elle tourne. En fait, Sun MicroSystems (Oracle

Introduction au Langage Java, par N. Chenfour - p. 3

aujourd’hui) publie sur son site différentes machines virtuelles destinées à
différentes plates-formes de développement.

Le schéma de développement et d’exécution d’un programme Java est alors

le suivant :

On écrit un programme java sauvegardé dans un fichier d’extension .java

(exemple Test.java : supposé contenir une classe nomée Test)

On compile ensuite le programme pour générer le Byte Code associé :

C:\ … > javac Test.java

Un fichier Test.class est alors créé.

Exécution du programme résultant :

C:\ … > java Test

Il est à remarquer qu’un même programme Java est en principe organisé

sous forme d’une architecture de classes utilisant l’une l’autre. Le
compilateur Java génère alors un fichier .class associé à chacune des
classes du programme est non au programme lui même. Si ainsi le
programme Test.java contient deux classes nommées C1 et C2 (et pas de
classe Test), le compilateur, qui se base sur le principe de la compilation
séparée, génère deux fichiers de classes : C1.class et C2.class (et pas de
fichier Test.class). Ce qu’il faut alors exécuter par la suite est la classe
principale (c à d : celle contenant une méthode main) par exemple C1 :

C:\ … > java C1

1.2.3 Le JDK (Java Developpement Kit)

1.2.3.1 Définition

Le JDK est l’ensemble des programmes nécessaires pour le développement

d’applications Java. Il regroupe ainsi les programmes javac.exe, java.exe,
jar.exe, javadoc.exe, ainsi que d’autres classes et utilitaires de
développements.

Introduction au Langage Java, par N. Chenfour - p. 4

1.2.3.2 Evolution

Depuis 1995 jusqu’à aujourd’hui le JDK n’a cessé d’évoluer et d’être étendu
de version en version : 1.0, 1.1, 1.2, 1.3, 1.4, ...

 La version 1.0 (lancée en 1995 et constituée de quelques 212 classes

et interfaces) a subi quelques évolutions jusqu’à ça dernière version :
1.0.2. Cette notation 1.s.b est interprétée avec le chiffre b indiquant
des corrections de bugs ou des petites modifications alors que le
chiffre au milieu s indique des modifications de spécification ou des
améliorations de taille (ajout de classes et interfaces).
 Le JDK 1.1, Février 1997 (504 classes et interfaces) a subi lui même
beaucoup de modifications jusqu’à sa dernière version 1.1.8.
 Le JDK 1.2 (1692 classes et interfaces) annoncé en décembre 1998 a
évolué avec sa dernière version 1.2.2. Nom de code Playground
 Le JDK 1.3, Mai 2000 (76 packages et 1839 classes et interfaces).
Nom de code Kestrel.
 Le JDK 1.4, Février 2002 (Nom de code Merlin, avec 139 packages et
2723 classes et interfaces)
 Le JDK 1.5, Septembre 2004, appelé aussi JDK 5, nom de code Tiger,
avec 166 packages et 3279 classes et interfaces.
 Java 6.0 (Nom de code Mustang), Décembre 2006 : 3777 classes et
interfaces)
 Java 7.0 (Nom de code Dolphin), Juillet 2011 sous licence GPL
(première version « open source ». après le rachat de Sun
Microsystems Par Oracle (le 20 Avril 2009 et finalisé le 27 Janvier
2010)
 Java 8.0, Mars 2014
 Java 9.0, Septembre 2017
 Java 10.0, Mars 2018 (Une nouvelle version tous les 6 mois)
 Java 11.0, Septembre 2018
 Java 12.0, Mars 2019
 Java 13.0, Septembre 2019
 Java 14.0, Mars 2020
 Java 15.0, Septembre 2020

Introduction au Langage Java, par N. Chenfour - p. 5

1.2.3.3 JavaTM 2
Nous remarquons toutefois que Sun a voulu changer la nomination du JDK
en la remplaçant à partir de sa version 1.2 par SDK (Software
Developpement Kit) ou plus précisément J2SDK pour « JavaTM 2 SDK ».
Avec Java 2 désignant le JDK 1.x (x  2). En fait Sun distingue entre deux
concepts :

La spécification proposée ou exigée par Sun indépendamment des détails

d’implémentation du langage ou la plate-forme de développement. Celle-ci
est notée : J2SE (JavaTM 2 platform Standard Edition).

Le software ou le kit qui implémente la spécification : J2SDK.

Pour terminer la remarque, on résume que JDK, SDK, Java 2, J2SDK sont
tous des termes qui désignent la même chose : le kit de développement
Java.

1.2.3.4 Installation sur le disque

Généralement le JDK (ou SDK) est délivré (ou téléchargé gratuitement à
partir du site d’Oracle) sous forme d’un programme dont l’exécution conduit
à l’installation du kit.

Si l’on prend l’exemple du JDK 15.0.1, son installation par défaut créera
l’arborescence suivante (de quelques 300 Mo) :

Tous les outils dont on a besoin pour développer (javac, java, …) se

trouveront alors dans le sous répertoire « bin » : jdk-15.0.1\bin qu’il est
possible d’ajouter au « path » pour être accessible depuis n’importe quel

Introduction au Langage Java, par N. Chenfour - p. 6

répertoire du disque. Il est aussi recommandé de créer une variable
d’environnement « JAVA_HOME » avec comme valeur le répertoire du JDK :

1.2.4 Le JRE (Java Runtime Environment)

Le JRE est un ensemble d’outils de classes et de bibliothèques (.dll et

autres) nécessaires pour l’exécution d’un programme Java. Ainsi le
déploiement ou la diffusion d’une application développée en Java nécessite
que la machine sur laquelle l’application est installée dispose d’une JVM. Le
JRE constitue une implémentation de cette machine virtuelle ainsi que tous
les outils dont a besoin toute application Java pour pouvoir fonctionner. Le
JRE est lui aussi accessible gratuitement dans le site d’Oracle. Lorsqu’il est

Introduction au Langage Java, par N. Chenfour - p. 7

installé sur le disque, il se présente sous forme d’un répertoire « JRE ». Il
est tout de même à remarquer que le JRE n’est plus fourni séparément du
JDK depuis Java 11.

1.2.5 Les Packages

Nous avons déjà mentionné que le JDK dispose de plusieurs classes prêtes
à être utilisées. Ces classes sont en effet délivrées avec le JDK. On y trouve
même la version source de ces classes dans un fichier archivé (src.zip dans
le répertoire « lib »).

Les classes accessibles sont alors organisées sous forme d’arborescences.

Ainsi par exemple la classe String se trouve dans le sous répertoire
java\lang. Ce dernier est appelé paquetage ou Package. Ainsi « lang » est
un package qui se trouve dans le package « java ». D’autres sous packages
du package java existent tels que : java.util, java.awt, etc. On remarquera
que les packages constituent un moyen à la fois logique et physique pour
l’organisation et la structuration des classes en Java.

Dans une application Java, pour utiliser une classe d’un certain package par
exemple la classe « Vector » du package « java.util », il sera nécessaire de
renseigner le nom complètement qualifié de la classe ou encore préciser le
package contenant la ou les classes à utiliser à l’aide de l’instruction
« import »:

import java.util.* ;

Ce qui signifie que toutes les classes du package sont accessibles. Ou

encore :

import java.util.Vector ;

pour n’accéder qu’à la classe Vector.

Remarques :

 Le Package java.lang est un package par défaut. Ainsi il est possible

d’utiliser toutes les classes de ce package sans avoir besoin de le
mentionner par une quelconque instruction « import ».

Introduction au Langage Java, par N. Chenfour - p. 8

  Afin d’optimiser l’espace disque occupé par les packages et les classes
qu’ils contiennent, mais aussi pour assurer une diffusion simplifié et
standardisé des applications et des bibliothèques ou APIs Java, celles-
ci sont packagées sous forme d’un fichier d’extension .jar (rt.jar). Les
classes et les packages restent comme même accessibles comme s’ils
n’étaient pas archivés. On remarque que le JDK comporte un
programme jar.exe (dans le sous-répertoire bin) avec lequel le
programmeur peut fabriquer ses propres fichiers .jar.

1.3 Eléments de base du langage Java

1.3.1 Conventions de nommage

Il n’est pas obligatoire mais il est recommandé que le programmeur

respecte un certain ensemble de règles lors de l’écriture d’un programme.
Ces mêmes règles sont d’ailleurs respectées par toutes les APIs du langage
Java lui-même, ce qui facilite la lecture du code Java et permet de prédire
l’écriture d’un nom de classe ou de méthode quelconque. Ces règles
peuvent être résumées de la manière suivante :

Les noms de packages sont entièrement en minuscule. Exemples :

 java.util

 javax.swing

 javax.xml.parsers

Un nom de classe est une séquence de mots dont la première lettre de

chaque mot est en majuscule et les autres en minuscule.

Exemples :

 String

 StringBuffer

 ComboBoxEditor

Introduction au Langage Java, par N. Chenfour - p. 9

Un nom de méthode est une séquence de mots dont le premier caractère
de chaque mot est en majuscule et les autres en minuscule sauf le premier
mot qui est entièrement en minuscule. Exemples :
 append
 toString
 setDefaultCloseOperation

Une propriété est en principe un membre privé donc non accessible

directement et par suite on peut lui choisir un nom librement. Sinon on lui
applique la même règle que celle d’une méthode.

Une constante (final) est une séquence de mots majuscules séparés par un
blanc souligné « _ »
 PI
 MIN_VALUE
 MAX_VALUE
Les primitives (types de base ou type primitif) et les mots clés sont en
minuscule :
byte, shot, int, long, float, double, char, boolean
while, for, if
this, super, try, catch, …
class, interface, extends, implements, null, true, false, …

1.3.2 Différences lexicales et syntaxiques avec le langage C++

Le langage Java a éliminé plusieurs structures du langage C/C++ dont on

peut citer :
 le mot clé const remplacé par final
 le mot clé goto
 la notion de variables globales
 les unions
 les directives : #include, #define
 les opérateurs : *, &, ->
 la désallocation
 La surcharge des opérateurs
Introduction au Langage Java, par N. Chenfour - p. 10
1.3.3 Structure générale d’un programme Java

Le squelette général d’un programme Java se présente comme suit (chaque

classe dans un fichier séparé et portant le même nom que celui de la
classe):

public class NomDeClasse1 {

// Propriétés de la classe

// Méthodes de la classe

public class NomDeClasse2 {

// Propriétés de la classe

// Méthodes de la classe

...

public class NomDeClassePrincipale {

// Propriétés de la classe

// Méthodes de la classe

public static void main(String args[]) {

// Code du programme principal

Introduction au Langage Java, par N. Chenfour - p. 11

Il est à remarquer que le compilateur Java génère un fichier de classe
(.class) différent pour chacune des classes qui constituent le programme. Il
est donc d’usage d’écrire chaque classe séparément (dans un fichier séparé
portant le même nom que celui de la classe et avec respect de la casse). Le
compilateur n’aura pas de problème pour retrouver la classe compilée (si
elle est référencée à partir d’une autre classe qui se trouve dans un autre
fichier) tant qu’on travaille dans le même répertoire (ou plus exactement
dans le même package). Dans le cas contraire (différents packages), on
utilise l’instruction import pour préciser le chemin des classes accessibles.

1.3.4 Modificateurs et visibilité

Nous remarquons que la méthode main() qui constitue le point d'entrée de

toute application est précédée par 3 mots réservés public static et void.
Le mot clé void désigne le type de retour, c’est donc une procédure. public
et static sont des modificateurs. Il existe 5 types de modificateurs très
utilisés qui peuvent être associées à une propriété ou une méthode :
modificateurs de synchronisation, de visibilité, de permanence, de
constance et d’abstraction.

1- Synchronisation 2- Visibilité 3- Permanence 4- Constance Type Nom

Synchronized Public Static final void
(seulement avec les protected int
méthodes) private …
5- Abstraction
Abstract
(seulement les méthodes qui ne sont pas synchronized, static, final ou
private )

Exemples :
 synchronized public static final void p1() {…}

 public abstract void p2() {…}

 public static int f1(){…}

Introduction au Langage Java, par N. Chenfour - p. 12

Modificateur synchronized :

Permet de mettre en place une méthode ou un bloc de programme verrouillé

par l’intermédiaire du mécanisme de moniteur. Une méthode synchronized
est une méthode dont l’accès sur un même objet est réalisé en exclusion
mutuelle. Elle sera dite « Thread-Safe ».

Modificateurs de visibilité : private, public et protected :

 Une propriété ou méthode private est inaccessible depuis l’extérieur

de la classe où elle est définie même dans une classe dérivée.

 Une propriété ou méthode public est accessible depuis l’extérieur de

la classe où elle est définie et depuis n’importe quel package.

 Une donnée ou méthode protected est protégée de tout accès

externe sauf à partir des classes dérivées dans n’importe quel
package; mais aussi depuis n’importe quelle classe du même
package.

 Il existe cependant un 4ème niveau de visibilité qui correspond à

l’absence de tout modificateur de visibilté : Il s’agit du niveau
« Default Public » ou « Package ». Les membres avec ce niveau sont
accessibles uniquement dans le même package.

Remarque :

Lorsqu’on redéfinie une méthode dans une classe fille, il est

obligatoire de conserver son modificateur de visibilité ou d’utiliser un
privilège d’accès plus fort, càd :

une méthode public reste public,

une méthode protected reste protected ou devient public,

et une méthode private reste protected ou devient public ou protected.

Modificateur static :

Le modificateur static permet de définir une propriété ou une méthode

commune à toutes les instances de la classe. Ce sont des membres de

Introduction au Langage Java, par N. Chenfour - p. 13

classe qui existent en l’absence de tout objet de la classe. Ainsi, une
propriété ou méthode « static » est associée à sa classe, et non à une
instance particulière de la classe.

Les membres « static » peuvent donc être appelés directement par

l’intermédiaire du nom de la classe. On n’a pas besoin de créer une instance
de la classe pour accéder à une méthode ou propriété « static » se trouvant
dans cette classe. L’appel est réalisé simplement à l’aide du sélecteur « . »
(le C++, utilise pour ce cas le sélecteur « :: »).

Les propriétés « static » sont appelées propriétés de classe et les

méthodes « static » sont également appelées méthodes de classe. Un
exemple concret de méthodes « static » est la méthode main() qui doit
être « static » afin de rester indépendante des autres objets que le
programme peut générer à partir de sa classe principale.

* Remarque :

Puisque les membres non statiques d’une classe sont des membres
d’objets (chaque objet a ses propres membres), en plus ils n’ont d’existence
que lorsqu’on a instancier un objet de la classe et inversement une méthode
« static » existe sans avoir besoin de créer d’instance de classe, une
méthode static ne peut donc pas accéder à une propriété non-static
ou une autre méthode non-static :

Exemple :

class Class1 {

private static int x = 20;

private int y = 30;
static void p1() {

x = x + 1 ; // correcte
y = y * 2 ; // incorrecte
p2() ; // incorrecte
}

Introduction au Langage Java, par N. Chenfour - p. 14

 void p2() { // méthode non-static

x ++ ; // correcte
y ++ ; // correcte
p1() ; // correcte
}
}
Modificateur final :

Les propriétés final sont des constantes. Ces propriétés sont généralement
définies en plus « public » et « static » afin d’être accessibles depuis
l’extérieur de la classe et directement par l’intermédiaire du nom de celle-
ci sans avoir besoin de créer une instance de la classe.

Exemple :

public class Constantes {

public static final int CONST1 = 20;

public static final double PI = 3.14;

Lorsqu’une méthode porte le modificateur final, elle ne peut pas être

redéfinie dans une classe fille.

Modificateur abstract :

Ce modificateur permet de définir une méthode abstraite. Càd une méthode

dont le corps n’est pas défini. Une classe qui comporte une méthode
abstraite doit, elle aussi, être définie abstraite. Il s’agit d’une classe de
spécification qui ne peut pas être directement instanciée. Elle nécessite
d’être étendue par une classe fille qui aura donc l’objectif d’implémenter les
spécifications de la classe abstraite mère.

Introduction au Langage Java, par N. Chenfour - p. 15

La définition de méthodes abstraites est réalisée de la manière suivante :

abstract class ClassAbstraite {

abstract typeretour methodeAbstraite(parametres) ;

Remarque :

Vue la notion d’abstraction, une méthode abstraite ne peut pas être :

- synchronized : car elle n’est pas encore définie

- static : pour la même raison (elle n’a pas encore d’existence, or une
méthode « static » existe dès la création de la classe).

- final : car cela va empêcher sa redéfinition, or une méthode abstract n’a

d’existence que lorsqu’elle est définie

- private : la redéfinition d’une méthode « private » signifie en fait la

définition d’une nouvelle méthode qui porte le même nom (et non pas le
véritable sens de la redéfinition). De ce fait on ne peut pas donner
d’existence à une méthode abstraite déclarée « private ». Ce qui interdit la
combinaison private-abstract.

1.3.5 La méthode main

La remarque que nous avons fait à propos des méthodes « static »

reste valable pour le main() qui est une méthode static. Cela impose une
grande restriction, car la méthode main() ne peut accéder qu’à des
propriétés et des méthodes « static ». Pour résoudre ce problème, il suffit
de créer un objet de la classe principale dans la méthode main. Ce qui
implique l’exécution du constructeur. Ce dernier n’est pas une méthode
static on peut alors y mettre tous les accès nécessaires aux différents
membres non-static. Le squelette d’un programme Java est souvent alors
formé de la manière suivante :

Introduction au Langage Java, par N. Chenfour - p. 16

public class NomDeClasse {
// données membres
public NomDeClasse () { // Constructeur
...
}
...
public static void main(String args[]) {
new NomDeClasse();
}
}
Exemple:

public class Class1 {

private static int x = 20;
private int y = 30;
public Class1() {
x = x + 1 ; // correcte
y = y * 2 ; // correcte
p2() ; // correcte
}
public void p2() {
System.out.println("x = " + x + ", y = " + y) ;
}
public static void main(String args[]) {
new Class1();
y = y * 2 ; // incorrecte
p2() ; // incorrecte
}
}

Introduction au Langage Java, par N. Chenfour - p. 17

1.3.6 Unités lexicales et syntaxiques de base du langage

Les unités de base du langage Java sont héritées du langage C. Ainsi le

langage Java utilise sans modification les entités et structures suivantes du
langage C :

 Affectation : =

 Opérateurs arithmétiques : +, -, *, /, %, ++, --, +=, -=, *=, /=,

%=, ...

 Opérateurs de relation : <, <=, >, >=, !=, ==

 Opérateurs sur le bit : &, |, ~, ^, <<, >>, >>>

 Instructions de choix :

if (condition) traitement1 ; else traitement2 ;

switch (…) { case ... default }

 Opérateurs logiques : &&, ||, !

 Les boucles :

for (…) {…}

while (condition) {…}

do { … } while (condition)

 Transtypage :

variable = (type) Expression ;

 Commentaires :

//...

/* ...*/

Introduction au Langage Java, par N. Chenfour - p. 18