Java (langage)

Image manquante
Langage_progr.png
image:Langage_progr.png

Cet article fait partie de la série
Langages de programmation
Langages à objets
Ada 95 - C++ - C#
Common Lisp
Delphi - Eiffel - Java
Nice - Oz - Python
Simula - Smalltalk
Visual Basic
Langages impératifs
APL - ASP - Assembleur
BASIC - C - COBOL
Forth - FORTRAN - Logo
Pascal - Perl - PHP
Langages fonctionnels
Erlang - Haskell
ML/OCaml - Oz
Lisp/Common Lisp
Scheme
Langages déclaratifs
Clips - Oz - Prolog
Langages concurrents
Ada 95 - Erlang
Java - Oz
Langages balisés
HTML - SGML - XML
Dialectes XML
S-expressions
Voir aussi
Conception - Codage
Tests - Optimisations
Sommaire
1 Généralités
2 Concepts de Base

2.1 Orienté objet
2.2 Indépendance face à la plate-forme
2.3 Exécution sécurisée de code distant
2.4 Évaluation

3 Le langage

3.1 Structures de contrôle

3.1.1 Boucles
3.1.2 Structures conditionnelles
3.1.3 Traitement des exceptions

4 Versions
5 Frameworks et API
6 Version interprétée
7 Appellation
8 Programmation
9 Voir aussi
10 Liens externes
11 Bibliographie

Généralités

Image manquante
Logo_java.JPG


Java est une technologie composée d'un langage de programmation orienté objet et d'un environnement d'exécution. Préalablement nommé Oak, il a été créé par James Gosling et Patrick Naughton chez Sun Microsystems avec le soutien de Bill Joy.

Concepts de Base

Quatre buts primaires présidaient la création du langage Java. Il devait :

Orienté objet

La première caractéristique, l'orienté objet, réfère à une méthode moderne de programmation et de conception de langage. Sa principale caractéristique est de rassembler (encapsuler) en une seule entité logique (Classe) un ensemble de données (Propriétés) et les fonctions qui les traitent (Méthodes). Le code devient ainsi plus facilement réutilisable car intrinsèquement modulaire.

D'autres mécanismes tels l' héritage permettent d'exploiter toutes les caractéristiques d'une Classe précédemment écrite (la plupart du temps par quelqu'un d'autre) dans ses propres programmes sans même avoir à en connaitre le fonctionnement interne, on en voit que l'interface (les principales commandes).

Comme toujours, le but de ce paradigme de programmation est de rendre les grands projets logiciels plus faciles à gérer, à améliorer la qualité et à réduire le nombre d'échecs de projet.

Indépendance face à la plate-forme

La seconde caractéristique du langage, l'indépendance vis à vis de la plate-forme, signifie que les programmes écrits en Java doivent fonctionner sur plusieurs types de matériel informatique. Un programmeur doit pouvoir écrire un programme une seule fois et, le faire fonctionner dans n'importe quel ordinateur. Ceci est permis en compilant le code source d'un programme Java dans un pseudo-code intermédiaire appelé bytecode Java -- des instructions machine standardisées et destinées à un processeur virtuel. Le code est par la suite exécuté par une implémentation de cette machine virtuelle (JMV), un programme écrit en code natif sur le matériel cible qui traduit le pseudo-code Java en code utilisable pour le matériel concerné. De plus, des bibliothèques sont offertes pour fournir l'accès à des fonctionnalités propres à la machine cible -- comme le graphisme ou le réseau -- d'une manière unifiée. Le langage Java offre aussi le support des programmes avec plusieurs processus légers (threads).

La première implémentation du langage utilisait une machine virtuelle pour offrir la portabilité, et plusieurs implémentations le font encore. Ces dernières produisent des programmes qui fonctionnent plus lentement que les programmes compilés nativement, comme ceux écrits en C. Cette situation a conféré une réputation de lenteur aux programmes Java. Toutefois, des implémentations plus récentes de la machine virtuelle Java produisent des programmes qui s'exécutent beaucoup plus vite grâce à l'utilisation de diverses techniques.

La première technique consiste à compiler directement en code natif, comme les compilateurs traditionnels, sans passer par le pseudo-code. Cette méthode permet une meilleure performance, mais au prix de la portabilité (cf. GCJ). Une autre technique, la compilation à la volée (just-in-time ou JIT), compile le pseudo-code Java en code natif à l'exécution du programme. Les machine virtuelles plus sophistiquées utilisent également la recompilation dynamique, qui permet à la machine d'analyser le comportement du programme et de recompiler et d'optimiser les parties critiques. Ces deux techniques permettent à l'application de prendre avantage de la vitesse d'exécution du code natif tout en conservant la portabilité.

La portabilité est un but techniquement difficile à atteindre, et le succès de Java à ce but est sujet à controverse. Même s'il est en effet possible d'écrire des programmes pour les machines virtuelles Java qui se comportent de façon cohérente sur différentes plates-formes, le grand nombre de plates-formes avec des petites erreurs ou incohérences a mené à une parodie du slogan de Sun Write once, run anywhere (écrire une fois, exécuter n'importe où) en Write once, debug everywhere (écrire une fois, déboguer partout).
Les machines virtuelles développées sous licence par Microsoft ne sont pas étrangères à cette réputation. En effet l'éditeur de Redmond avait singulièrement 'adapté' ses machines virtuelles à ses besoins propres. Il a été condamné à cesser l'exploitation de la licence et à retirer les machines virtuelles non conformes de ses produits.

Exécution sécurisée de code distant

La plate-forme Java fut l'un des premiers systèmes à offrir le support de l'exécution du code à partir de sources distantes. Une applet peut fonctionner dans le navigateur Web d'un utilisateur, exécutant du code téléchargé d'un serveur HTTP. Le code fonctionne dans un espace très restrictif, ce qui protège l'utilisateur des codes erronés ou mal intentionnés. Les éditeurs d'applet peuvent alors demander un certificat pour leur permettre de signer numériquement une applet comme sécuritaire, leur donnant ainsi la permission de sortir de l'espace restrictif et d'accéder au système de fichier de l'utilisateur et au réseau.

Évaluation

Selon la plupart des gens, la technologie Java atteint raisonnablement bien ces buts. Le langage n'est pas, en revanche, sans problème. Quelques fonctionnalités du C++ que Java n'offre pas, comme des types de données spécifiques au matériel hôte, les pointeurs vers des espaces mémoire arbitraires et des techniques de programmation comme la surcharge d'opérateurs, peuvent être mal utilisés mais sont aussi des outils très puissants. (En revanche, la technologie Java offre le Java Native Interface (interface native Java ou JNI), une méthode permettant d'appeler du code natif à partir de code Java.) Quelques programmeurs se plaignent aussi du manque d'héritage multiple, une fonctionnalité puissante du C++ et d'autres langages orientés objet. Le langage Java sépare l'héritage et l'implémentation, permettant l'héritage multiple via les interfaces, mais seulement un héritage via une hiérarchie de classes. Ceci offre la plupart des avantages de l'héritage multiple tout en évitant la plupart de ses dangers. De plus, grâce à l'utilisation de classes concrètes, de classes abstraites et d'interfaces, un programmeur Java a le choix de faire une implémentation complète, partielle ou nulle d'un type d'objet qu'il définit, assurant un maximum de flexibilité dans la conception d'applications.

Certaines personnes pensent en revanche que, pour certains projets, la conception orientée objet rend plus difficile plutôt que plus facile la programmation. Cette critique, infondée surtout dès qu'un projet prend de l'ampleur, n'est pas spécifique au langage Java, mais s'applique à tous les langages de programmation orientés objet.

Une opinion répandue est que Java combine l'efficacité du Smalltalk langage dit objet à l'élégance du C++, bien que le contraire eût sans doute été préféré de bien des programmeurs.

Le langage

Voici un exemple d'un programme Hello world typique écrit en Java : 

public class HelloWorld {
     public static void main(String[] args) {
         System.out.println("Hello world!");
     }
 }

Structures de contrôle

Boucles

Structure tant que : 

while (<expression booléenne>) {
     instruction(s)
 }

Structure faire tant que : 

do {
    instruction(s)
 }
 while (<expression booléenne>);

Structure pour : 

for (<initialisation> ; <condition de poursuite> ; <expression d'incrémentation>) {
    instruction(s)
 }

Structures conditionnelles

Structure si simple : 

if (<expression booléenne>) {
    instruction(s)
 }

Structure si... sinon : 

if (<expression booléenne>) {
     instruction(s)
 }
 else {
     instruction(s)
 }

Avec else if, des constructions si... sinon arbitrairement complexes peuvent être construites. 

if (<expression booléenne>) {
     instruction(s)
 }
 else if (<expression booléenne>) {
     instruction(s)
 }
 else if (<expression booléenne>) {
     instruction(s)
 }
 else {
     instruction(s)
 }

Structure cas de ... : Un valeur discrète est un type que l'on peut énumerer (exemple : 1,2,3.. ou 'a','b','c'...) 

switch (<expression discrète>) {
    case <expression discrète constante>:
         instruction(s)
         break;
    [...]
    default:
         instruction(s)
         break;
 }

La commande break sort immédiatement la boucle en cours (for, while, do), et permet de sortir d'une clause contenue dans un switch.

Une expression continue termine l'itération en cours et continue à la prochaine. Elle s'écrit comme suit : continue

L'énoncé return termine une méthode.

Avec return uneValeur, uneValeur sera renvoyée à la méthode appelante.

Traitement des exceptions

try {
       instruction(s)
 }
 catch (<type d'exception> <variable>) {
       instruction(s)
 } 
 [...]
 finally {
       instruction(s)
 }

Le bloc de code "finally" sera exécuté quel que soit le résultat lorsque le programme sortira du bloc "try-catch".

Voici un exemple de capture d'une exception: 

try {
      //<-- Créer un "stream pour écrire dans un fichier. Le fichier
      //n'est pas spécifié puisque ce n'est pas essentiel pour 
      //l'exemple.
      FileOutputStream fos = new FileOutputStream(...);
 
      fos.write(a); //'a' aurait reçu une valeur ultérieurement
 }
 catch (IOException e) {
      e.printStackTrace();
 }

Cet exemple permet d'illustrer le mécanisme des exceptions en Java. Dans le cas d'une erreur d'entrée/sortie dans le bloc "try", l'exécution reprend dans le bloc "catch" correspondant à cette situation (exception de type "IOException"). Dans ce bloc "catch", la variable "e" référence l'exception qui s'est produite. Ici, nous invoquons la méthode "printStackTrace()" qui affiche dans la console des informations sur l'exception qui s'est produite : nom, motif, état de la pile d'appels au moment de la levée de l'exception et, éventuellement, numéro de ligne auquel l'erreur s'est produite. Il ne s'agit ici que d'un exemple, l'action à mettre en œuvre lorsqu'une exception survient dépend du fonctionnement général de l'application et de la nature de l'exception.

Versions

Java est une marque déposée de Sun Microsystems. Kits de développement Java (Java development kit ou JDK) publiés par Sun, utilisables gratuitement :

Le langage est stable depuis le JDK 1.0; les bibliothèques de classes fournies se sont agrandies et ont changé en partie. À partir de la version 1.2, les JDK ont été renommés en J2SDK (Java 2 Software Development Kit, kit de développement de logiciels Java 2) et on appelle souvent ces versions Java 2.

Du fait de l'accroissement des bibliothèques et des changements entre version, la compatibilité est assurée dans un seul sens : les programmes Java compilés avec une version antérieure du JDK (par exemple 1.2) continueront à fonctionner avec un JRE plus récent (par exemple 1.5), mais le contraire n'est pas vrai. Ceci contribue à remettre aussi en question la slogan de Sun Write once, run anywhere (écrire une fois, exécuter n'importe où) du fait de l'hétérogénéité des versions de Java déployées dans le monde.

Frameworks et API

Sun fournit un grand nombre de frameworks et d'API afin de permettre l'utilisation de Java pour des usages très diversifiés. On distingue essentiellement 4 grands frameworks :

On trouve toutefois de nombreuses autres technologies, API et extensions optionnelles pour Java :

Version interprétée

Il y a une version interprétée de Java appelée beanshell, qui peut être utilisée comme un langage de script shell. L'interpréteur peut aussi être embarqué dans une application Java pour la rendre scriptable.

Appellation

Oak ("Chêne") est le nom qui est donné à Java dans un premier temps. Mais comme celui-ci est déjà utilisé on lui donne le nom de Java en l'honneur du nom argotique (en amérique du Nord) du breuvage le plus consommé par les programmeurs, c'est-à-dire le café, dont une partie de la production vient de l'île de Java

Programmation

La programmation peut se faire pour des exemples simples avec le compilateur javac, mais pour avoir plus de confort il est préférable d'utiliser un environnement de développement intégré ou IDE, certains sont gratuits.

Voir aussi

Liens externes

Bibliographie

See also: Java (langage), 1995, 2001, 2002, 23 mai, APL (langage), Active server pages, Ada (langage), Ant (Apache)