You are on page 1of 6

Segment 1: Premiers programmes Java (1/2)

1 Introduction..................................................................................................................................4
1.1 Historique ............................................................................................................................4
1.2 Caractéristiques du langage .................................................................................................4
1.2.1 Portabilité.....................................................................................................................4
1.2.2 Simplicité .....................................................................................................................4
1.2.3 Sécurité ........................................................................................................................5
1.3 Installation de l’environnement Java ...................................................................................5
1.4 Premier Programme .............................................................................................................5
1.4.1 Edition..........................................................................................................................6
1.4.2 Compilation .................................................................................................................7
1.4.3 Exécution.....................................................................................................................7

Marc Tizzano (EMN) 3


1 Introduction

1.1 Historique

En 1991 Sun Microsystem, créa un groupe de recherche chargé de développer un langage


pouvant être embarqué dans des appareils électroniques pour le grand public. Dans le
cadre de ce projet, James Gosling développa un langage appelé Oak, puis Java. Le marché
grand public ne se développant pas aussi rapidement que prévu, le langage allait être
abandonné quand Sun se rendit compte qu’il pouvait promouvoir son langage dans le
domaine d’Internet. Ce fut une véritable explosion. Sun présenta Java en mai 1995.
Depuis, plusieurs versions du logiciel se sont succédées et chacune ajouta un ensemble de
bibliothèques permettant d’écrire des programmes dans des domaines nombreux et
variés (Internet, les dessins en 2D ou en 3D, la téléphonie, la voix, le multimédia …)

1.2 Caractéristiques du langage

Que le lecteur ne soit pas inquiet si certaines de ces caractéristiques n’évoquent encore
rien pour lui. Ces caractéristiques ne pourront être pleinement comprises qu’au fur et à
mesure du déroulement du cours.
Examinons donc quelques caractéristiques du langage Java :

1.2.1 Portabilité

Avec un langage comme Pascal, C ou C++ le programme est traduit (on dit aussi compilé)
en un langage (l’assembleur) directement exécutable par l’ordinateur et donc spécifique à
la machine. Avec Java c’est différent ; le code source est traduit en un code assembleur
virtuel : le bytecode . Ce bytecode est un assembleur qui n’est lié à aucun processeur, il
n’est compris que par un programme spécial appelé interpréteur ou aussi machine
virtuelle. Java est donc un langage qui est :

1. Compilé en bytecode
2. Interprété par une machine virtuelle.

Java est donc portable. Cette caractéristique explique le succès de Java. En effet un
programme Java créé et compilé sur un ordinateur avec un système d’exploitation X
pourra être interprété avec un système d’exploitation Y. Il faut bien évidemment que la
machine virtuelle soit installée sur le système Y.
Attention cette portabilité se paie par une moins grande vitesse d’exécution ; un
programme Java s’exécute moins vite qu’ un programme C++ compilé.

1.2.2 Simplicité

Java est d’utilisation simple. En effet la gestion de la mémoire n’est plus à la charge du
programmeur. Cela veut dire que les objets ne sont jamais directement manipulés. Java

Marc Tizzano (EMN) 4


gère la création et la destruction des objets. Un programme s’exécutant en tâche de fond
libère la mémoire des objets qui ne sont plus utilisés. Ce programme s’appelle en anglais
"garbage collector" et peut être traduit par "ramasse miettes" (traduction consacrée par
l’usage), "glaneur de cellules obsolètes" (traduction poétique d’un chercheur français) ou
"ramasseur d’ordure" (traduction littérale, beaucoup moins poétique…).
Là encore cette simplicité n’est pas gratuite ; cette tâche de fond peut s’exécuter à
n’importe quel moment et interrompre la tâche principale. Si cette tâche principale est
critique les conséquences peuvent être désastreuses…

1.2.3 Sécurité

Java est un langage fortement typé. C'est-à-dire que chaque expression du langage doit
posséder un type et un seul. Le compilateur peut alors vérifier la validité d’une expression.
Ceci permet d’éviter de nombreuses erreurs qui n’auraient été découvertes que lors de
l’exécution.
De plus l’interpréteur Java va vérifier que l’indice d’accès à un élément d’un tableau est
inclus entre les bornes du tableau. Si ce n’est pas le cas, il va déclencher une erreur.

1.3 Installation de l’environnement Java

Dans le reste du cours nous supposerons que vous avez installé l’environnement java que
vous avez trouvé sur votre CD-ROM.

Environnement Windows
Vous pouvez trouver le programme permettant l’installation à l’adresse suivante :
http://java.sun.com/j2se/1.3/download-windows.html, téléchargez le en suivant les
instructions.
Attention, n’oubliez pas que vous devez ajouter au PATH actuel, le chemin vers les
exécutables Java : si votre répertoire d’installation est C:\JDK1.3, vous devez avoir
PATH=C:\WINDOWS;C:\JDK1.3\BIN;…

Si vous ne savez pas le faire, ou si votre environnement de développement n'est pas


Windows, demandez à votre tuteur comment faire.

1.4 Premier Programme

Dans ce cours nous vous demanderons de recopier tels quels des éléments de programme
qui seront expliqués plus loin ou même dans un autre cours de votre cursus. N’en soyez
pas frustré.
De plus chaque fois que l’on vous présentera un exemple, n’hésite pas à le tester,
« triturez- le ». C’est-à-dire sentez-vous libre de le recopier en changeant des morceaux de
code, puis compilez et regardez ce que cela donne. N’oubliez pas le proverbe : "C’est en
programmant que l’on devient programmeur"
Dans ce paragraphe, nous introduirons la programmation en Java par un exemple de
programme très simple. Ce programme affiche à l’écran le message suivant :
Bonjour chez vous !

Marc Tizzano (EMN) 5


Pour fonctionner un programme Java doit suivre 3 étapes :
1. Edition
2. Compilation
3. Exécution appelée aussi interprétation.
Nous allons les détailler.

1.4.1 Edition

L’étape 1 nécessite l’utilisation d’un éditeur comme le bloc note de Windows ou XEmacs.
Le programmeur introduit à l’aide de cet éditeur le texte du programme. Le nom de fichier
doit se terminer par .java comme Hello.java

1 // fichier Hello.java
2 public class Hello {
3 public static void main(String[] argv) {
4 System.out.println("Bonjour chez vous !");
5 }
6 }

Les numéros de ligne qui apparaissent sur l'exemple précédent ne font évidement pas
partie du programme que vous devez écrire.

Commentons chacune des lignes, cela nous permettra d’introduire des concepts essentiels en
java.
La première ligne commence par le symbole // qui introduit un commentaire. De tels
commentaires permettent de documenter un programme, d’expliquer ce qu’il fait. Tout ce qui
est après le symbole // est ignoré par le compilateur, et ceci jusqu'à la fin de la ligne.
A la ligne 2 débute la définition d’une classe java. Dans la suite du cours nous donnerons une
définition du concept de classe; disons qu'en première approximation une classe est un
regroupement de données et d'opérations. Le premier mot, public, définit la visibilité d’une
classe. Ce mot, comme class qui le suit sont des mots réservés, un programmeur ne peut les
utiliser pour définir ses propres concepts.
Le mot réservé class (appelé aussi mot clef) introduit le nom de la classe qui est définie. Dans
notre exemple le nom de la classe est Hello. Le nom de la classe est un identificateur. Tous
les programmes Java commence par une définition de classe. Considérons que public class
NomDeLaClasse est obligatoire.
Ce nom de classe doit être la première partie du nom de fichier qui contient la classe. Dans
notre exemple, le nom de la classe étant Hello le nom du fichier doit obligatoirement être
Hello.java. A la fin de la ligne 2 l’accolade ouvrante { commence le bloc de code définissant
la classe. Ce bloc se termine en ligne 6 par l’accolade fermante }.
La ligne 3 introduit la définition du point d’entrée de tout programme Java. Ce point d’entrée
est une suite d’instructions appelée méthode . Lors de l’exécution, l’interpréteur commence
par exécuter la première instruction de la méthode main. Cette méthode doit avoir exactement
la même signature (ou définition) que celle donnée en ligne 3. Plus exactement, si vous

Marc Tizzano (EMN) 6


développez un programme Java exécutable, vous devez définir une méthode main dont la
déclaration sera : public static void main(String[] argv){…}. Un
programme Java contient généralement plusieurs méthodes, une seule peut servir de point
d’entrée, c’est la méthode main.
La ligne 3 se termine par une accolade ouvrante { qui délimite le début du bloc d’instruction
formant la définition de la méthode main. Comme nous l’avons vu cette accolade est
appariée à une accolade fermante }, ligne 5.
La ligne 4 indique à l’interpréteur qu’il doit exécuter l’instruction :
System.out.println("Bonjour chez vous !");
Cette instruction permet :
1. d’écrire à l’écran la chaîne de caractères : Bonjour chez vous !
2. de positionner le curseur au début de la ligne suivante.

Cette instruction se compose de :


• System.out qui représente la sortie standard,
• println qui est la méthode qui permet d’afficher une ligne de texte, puis d’aller à la
ligne.
• "Bonjour chez vous ! " qui est l’argument de la méthode println. Cet argument qui est
une chaîne de caractère sera affiché tel quel lors de l’exécution.
• du point virgule ; qui est le symbole utilisé en Java pour terminer une instruction.

Nous allons maintenant décrire les étapes 2 et 3.

1.4.2 Compilation

Pour compiler le programme, à l’intérieur d’une fenêtre de commande nous tapons la ligne
de commande suivante :
javac Hello.java
S’il n’y a pas d’erreur de syntaxe, un fichier Hello.class est créé. Il contient le bytecode de
notre application.

1.4.3 Exécution

Sur la ligne de commande nous tapons :


java Hello
L’application s’exécute et comme nous l’avons expliqué, Bonjour chez vous ! est affiché.

Bug potentiel
Le nom de la classe doit être le nom de base du fichier définissant cette classe. L’extension
doit être .java. Attention le nom de la classe doit correspondre exactement au nom du
fichier, majuscule/minuscule comp ris.

Bug potentiel
Attention aux accolades et aux points virgules. Ce sont des caractères que le programmeur
débutant oublie régulièrement !

Marc Tizzano (EMN) 7


INFO01EXE01
1) Recopiez le programme Hello.java
2) Compilez- le
3) Enlevez, permutez certains mots ou caractères, remplacer les minuscules par des
majuscules ….
4) Compilez et analyser les erreurs ou exécutez le programme s’il n’y a pas d’erreur.
Vous pouvez, par exemple, enlever une accolade, remplacer main par Main etc.

Marc Tizzano (EMN) 8