Java

Côté client

La possibilité des navigateurs web de lancer des applets Java garantit la pérennité de l'utilisation de Java par le grand public. Les concurrents récents des applets Java sont essentiellement Macromedia Flash et, mais bientôt Xul ou XAML concurrenceront ces technologies.

Les avantages de Java comparé à Javascript sont principalement la portabilité. Plus l'interface est lourde, plus il est épuisant ou alors impossible d'adapter l'interface à l'ensemble des navigateurs du marché. Les avantages de Java comparé à Flash sont aussi valables comparé à Javascript : Java propose un style de langage plus élégant, et extrêmement bien documenté et propose en particulier un environnement de développement intégré particulièrement efficace.

Les applets sur le poste Client peuvent communiquer avec des servlets sur le Serveur, tout comme Javascript peut communiquer avec le Serveur au moyen d'. Flash utilise la technologie Flex.

La puissance de Java est fréquemment utilisée pour des applications plus consistantes comme les jeux Yahoo et plus récemment les lecteurs vidéo multiplate-formes.

Côté serveur

Côté serveur, on retrouve des classes Java qui permettent de définir des objets (classes POJO) et d'autres classes qui permettent de définir des actions sur ces objets (classes métiers). On effectue ici un travail sur les données en les modélisant sous formes d'objets. Ces objets peuvent être modifiés par des méthodes issues de classes particulièrement conçues pour effectuer des opérations. Ainsi on pourra trouver par exemple une classe pour définir une pomme comme objet (taille, poids, calibre) et une autre classe pour définir des opérations sur une pomme (acheter, vendre, manger). Avec les serveurs d'applications, on utilise des EJB pour encapsuler les classes définies auparavant. Ces éléments sont utilisés dans des architectures J2EE pour des applications multi-couches. L'avantage qu'on tire de ce travail est de pouvoir cacher au client l'implémentation du code côté serveur.

Utilisation sur le poste de travail

L'utilisation native du langage Java pour des applications sur un poste de travail restait jusqu'désormais assez rare à cause de leur manque de rapidité. Cependant, avec l'accroissement rapide de la puissance des ordinateurs, les améliorations au cours de la dernière décennie de la machine virtuelle Java et de la qualité des compilateurs, plusieurs technologies ont gagné du terrain comme par exemple Netbeans et l'environnement Eclipse, les technologies de fichiers partagés Limewire et Azureus. Java est aussi utilisé dans le programme de mathématique Matlab au niveau de l'interface homme machine et pour le calcul formel. Les applications Swing apparaissent aussi comme une alternative à la technologie. NET.

Microsoft et autres dispositifs

• Microsoft a apporté un environnement de travail de type Java, dénommé J++, avec ses dispositifs d'exploitation avant la sortie de Windows XP en 2001. Suite à décision de justice, et au vu du non-respect des spécifications de ce langage, Microsoft a dû abandonner ce dernier et créer un nouveau langage de nom C# (cf. chapitre «Indépendance vis-à-vis de la plate-forme» plus bas)
• Énormément de fabricants d'ordinateurs continuent d'inclure un environnement JRE sur leurs dispositifs Windows.
• Java apparaît aussi comme un standard au niveau du Mac OS X d'Apple autant que pour les distributions Linux. Actuellement, la majorité des utilisateurs peuvent lancer des applications Java sans aucun problème.

Passage sous licence libre

Le 13 novembre 2006, Sun annonce le passage de Java, c'est-à-dire le JDK (JRE et outils de développement) et les environnements Java EE (déjà sous licence CDDL) et Java ME sous licence GPL. En mai 2007, Sun publie effectivement OpenJDK sous licence libre. Cependant OpenJDK dépend toujours de fragments de code non libre que Sun ne détient pas. C'est pourquoi la société Redhat lance en juin 2007 le projet IcedTea qui vise à remplacer les fragments de code non libre et ainsi rendre OpenJDK utilisable sans aucun logiciel propriétaire. En juin 2008, le projet IcedTea a passé les tests rigoureux de compatibilité Java (TCK) ^[3]. On peut par conséquent dire que Java devient un logiciel libre.

Historique des versions

Le langage Java a connu plusieurs évolutions depuis le JDK 1.0 (Java Development Kit) avec l'ajout de nombreuses classes et packages à la bibliothèque standard. Depuis le J2SE1.4, l'évolution de Java est dirigée par le JCP (Java Community Process) qui utilise les JSR (Java Specifications Requests) pour proposer des ajouts et des changements sur la plate-forme Java. Le langage est spécifié par le JLS (Java Language Specification). Les modifications du JLS sont gérées sous le code JSR 901^[4]

• JDK 1.0 (23 janvier 1996 - 211 classes et interfaces) — Version initiale^[5].

• JDK 1.1 (19 février 1997 - 477 classes et interfaces) — De nombreux ajouts^[6] avec surtout :
  • une refonte complète du modèle événementiel AWT.
  • Les classes internes sont ajoutées au langage.
  • JavaBeans
  • JDBC
  • Java Remote Invocation (RMI)

• J2SE 1.2 (9 décembre - 1 524 classes et interfaces) — Nom de code Playground. Cette version et les suivantes jusque J2SE 5.0 sont rebaptisées Java 2 et la version appelée J2SE (Java 2 Platform, Standard Edition) remplace JDK pour distinguer la plate-forme de base de la version J2EE (Java 2 Platform, Enterprise Edition) et de la version J2ME (Java 2 Platform, Micro Edition). Plusieurs ajouts ^[7] dont :
  • le mot-clé strictfp
  • la réflection
  • l'API graphique Swing est intégrée.
  • Pour la première fois, la machine virtuelle Java de Sun inclut un compilateur «Juste à temps» (Just in Time).
  • Java Plug-in
  • Java IDL, une implémentation de IDL pour l'interopérabilité avec CORBA.
  • le framework Collections.

• J2SE 1.3 (8 mai 2000 - 1 840 classes et interfaces) — Nom de code Kestrel. Changements principaux^[8] :
  • HotSpot JVM inclus (La machine virtuelle HotSpot sortit en avril 1999 pour la machine virtuelle du J2SE 1.2)
  • Changement pour les RMI pour être basé sur CORBA.
  • JavaSound
  • JNDI (Java Naming and Directory Interface) inclus de base (disponible jusque là comme extension)
  • JPDA (Java Platform Debugger Architecture)

• J2SE 1.4 (6 février 2002 - 2 723 classes et interfaces) — Nom de code Merlin. Ce fut la première révision de la plate-forme sous JCP (Java Community Process) ^[9]. Les principaux changements^[10]sont :
  • le mot-clé assert (Spécifié dans JSR 41. )
  • les expressions rationnelles modélisées en s'inspirant du langage Perl.
  • Le chaînage d'exception autorise une exception d'encapsuler l'exception de base niveau d'origine. (Spécifié dans (en) JSR 51. )
  • API de journalisation (Spécifiée dans (en) JSR 47. )
  • l'API Image I/O pour lire et écrire des images dans des formats comme JPEG et PNG.
  • intégration d'un parser XML et du moteur XSLT appelé JAXP (Spécifié dans (en) JSR 5 et (en) JSR 63. )
  • intégration des extensions de sécurité JCE (Java Cryptography Extension), JSSE et JAAS.
  • Java Web Start (introduit pour la première fois en mars 2001 pour J2SE 1.3 - Spécifié dans (en) JSR 56. )

• J2SE 5.0 (30 septembre 2004 - 3 270 classes et interfaces) — Nom de code Tiger. (originellement numérotée 1.5, qui est toujours utilisé comme numéro de version interne^[11]). Développé par (en) JSR 176, Tiger ajoute un nombre significatif de nouveautés^[12] au langage :
  • Programmation générique — (Spécifié par (en) JSR 14. )
  • Metadata — aussi nommées annotations, permet au langage de construire des classes et des méthodes étiquetées avec des données additionnelles qui peuvent être utilisées comme méta-données (Spécifiée dans (en) JSR 175. )
  • Autoboxing/unboxing — conversion automatique entre des types primitifs (comme le type int) et le Wrapper de classe correspondant (comme la classe Integer) (Spécifié dans (en) JSR 201).
  • Énumérations — le mot-clé enum sert à créer une liste ordonnée de valeurs sans type. Jusque là, ceci pouvait uniquement être réalisé par des entiers constants (Spécifié dans JSR 201).
  • Varargs — la syntaxe Object … utilisée dans une déclaration de méthode sert à spécifier un nombre variable d'arguments pour cette méthode. C'est un fonctionnement équivalent à la fonction «printf» en C.
  • Imports statiques — Cette fonctionnalité permet d'utiliser les constantes d'une classe sans spécifier le nom de cette classe et sans passer par «l'anti-pattern Constant Interface» (c'est l'expression utilisée sur le site de Sun).
  • Extension du for pour les boucles — la syntaxe du for est étendue avec une syntaxe spéciale pour les itérer sur n'importe quel Itérable comme un tableau, ou une collection en utilisant la syntaxe :

void displayWidgets (Iterable<Widget> widgets) {
    for (Widget w : widgets) {
        w.display();
    }
}

Cet exemple itère l'objet Iterable widgets de la classe Widget, assignant chacun de ces éléments à la variable w et ensuite nomme la méthode display () sur l'élément w (Specifié dans JSR 201).

• Java SE 6 (11 décembre 2006 - 3 777 classes et interfaces) — Nom de code Mustang^[13]. Une version bêta est sortie le 15 février 2006, une autre bêta en juin 2006, une version «release candidate» en novembre 2006, et la version finale le 12 décembre 2006. Avec cette version, Sun remplace le nom J2SE par Java SE et supprime le . 0 au numéro de version^[14].

• Java SE 7 — Nom de code Dolphin. Une des nouveautés majeures de cette version sera l'ajout des closures (en cours de spécifications). Il s'agira de la première version sous la licence GPL. Sortie pressentie pour début 2010^[15].

En plus des changements au niveau du langage, des changements plus importants ont eu lieu au fil des années qui ont conduit des quelques centaines de classes dans le JDK 1.0 à plus de 3 000 dans J2SE 5.0. Des API entières, comme Swing ou Java2D ont été ajoutées et énormément de méthodes de l'original JDK 1.0 ont été déclarées deprecated (c'est-à-dire obsolètes et pouvant être supprimées à tout moment).

Philosophie

Lors de la création du langage Java, il avait été décidé que ce langage devait répondre à 5 objectifs :

1. utiliser une méthode orientée objet ;
2. permettre à un même programme d'être exécuté sur plusieurs dispositifs d'exploitation différents ;
3. pouvoir utiliser de manière native les réseaux informatiques ;
4. pouvoir exécuter du code distant de manière sûre ;
5. être facile à utiliser et posséder les points forts des langages de programmation orientés objet comme le C++.

Un langage orienté objet

La première caractéristique, le caractère orienté objet («OO»), fait référence à une méthode de programmation et de conception du langage. Quoiqu'il existe plusieurs interprétations de l'expression orienté objet, une idée phare dans ce type de développement est que les différents types de données doivent être directement associés avec les différentes opérations qu'on peut effectuer sur ces données. En conséquence, les données et le code sont combinés dans une même entité nommé objet. Un objet peut être vu comme une entité unique comprenant un comportement, le code, avec un certain état, les données. Le principe est de séparer les choses qui changent de celles qui ne changent pas ; fréquemment un changement au niveau d'une structure de données va impliquer un changement dans le code permettant de manipuler ces données et réciproquement. Ce découpage en entités cohérentes nommées objets permet d'avoir des fondations plus solides pour bâtir une architecture logicielle de qualité. L'objectif est de pouvoir développer des projets plus simples à gérer et de diminuer le nombre de projets aboutissant à un échec.

Un autre objectif majeur de la programmation orientée objet est de développer des objets génériques de manière à ce que le code puisse être réutilisable entre différents projets. Un objet «client» générique par exemple doit avoir globalement le même comportement dans les différents projets, surtout si ces différents projets se recoupent comme c'est fréquemment le cas dans les grandes organisations. Dans ce sens, un objet peut être vu comme un composant logiciel enfichable, permettant à l'industrie du logiciel de bâtir des projets d'envergure à partir d'éléments de base réutilisables ainsi qu'à la stabilité éprouvée tout en diminuant de manière drastique le temps de développement.

La réutilisation de code, quand elle est soumise à l'épreuve de la pratique, rencontre deux difficultés majeures : la création d'objets génériques réellement réutilisables est une notion particulièrement mal comprise et une méthodologie pour diffuser de l'information indispensable à la réutilisation de code manque cruellement. Certaines communautés du monde «Open Source» veulent contribuer à résoudre ce problème en fournissant aux programmeurs la possibilité de diffuser beaucoup de l'information sur les objets réutilisables et les bibliothèques objet.

Indépendance vis-à-vis de la plate-forme

La seconde caractéristique, l'indépendance vis-à-vis de la plate-forme, veut dire que les programmes rédigés en Java fonctionnent de manière idéalement identique sur différentes architectures matérielles. On peut effectuer le développement sur une architecture donnée et faire tourner l'application sur l'ensemble des autres.

Ce résultat est obtenu par les compilateurs Java qui compilent le code source «à moitié» afin d'obtenir un bytecode (plus exactement le bytecode Java, un langage machine spécifique à la plate-forme Java). Le code est ensuite interprété sur une machine virtuelle Java (JVM en anglais), un programme rédigé particulièrement pour la machine cible qui interprète et exécute le bytecode Java. Qui plus est , des bibliothèques standard sont apportées pour pouvoir accéder à certains éléments de la machine hôte (le graphisme, le multithreading, la programmation réseau…) précisément de la même manière sur l'ensemble des architectures. Notons que même s'il y a explicitement une première phase précoce de compilation, le bytecode Java est interprété ou alors converti à la volée en code natif par un compilateur juste-à-temps (just in time, JIT).

Il existe aussi des compilateurs Java qui compilent directement le Java en code objet natif pour la machine cible, comme par exemple GCJ, supprimant la phase intermédiaire du bytecode mais le code final produit par ces compilateurs ne peut alors être exécuté que sur une seule architecture.

La licence de Sun pour Java insiste sur le fait que l'ensemble des implémentations doivent être compatibles. Ceci a abouti à la plainte en Justice contre Microsoft après que Sun a constaté que l'implémentation de Microsoft ne supportait pas les interfaces RMI et JNI et comportait des éléments spécifiques à certaines plates-formes comparé à la plate-forme d'origine de Sun. Sun obtint des dommages et intérêt (20 millions de dollars) et l'acte de justice renforça toujours les termes de la licence de Sun. En réponse, Microsoft arrêta le support de Java sur ses plates-formes et , sur les versions récentes de Windows, Internet Explorer ne supporte pas les applets Java sans ajouter de plug-in. Cependant, Sun met à disposition gratuitement des environnements d'exécution de Java pour les différentes plates-formes Microsoft.

Les premières implémentations du langage utilisaient une machine virtuelle interprétée pour obtenir la portabilité. Ces implémentations produisaient des programmes qui s'exécutaient plus lentement que ceux rédigés en C ou en C++, si quoique le langage souffrit d'une réputation de faibles performances. Des implémentations plus récentes de la machine virtuelle Java (JVM) produisent des programmes bien plus rapides qu'jusque là, en utilisant différentes techniques.

La première technique est de compiler directement en code natif comme un compilateur respectant les traditions, supprimant totalement la phase de bytecode. On obtient ainsi de bonnes performances mais aux dépens de la portabilité. Une autre technique nommée compilation juste-à-temps (just in time, JIT) traduit le byte code en code natif durant la phase de lancement du programme. Certaines machines virtuelles plus particulièrement élaborées utilisent une recompilation dynamique pendant laquelle la machine virtuelle analyse le comportement du programme et en recompile sélectivement certaines parties. La recompilation dynamique permet d'obtenir de meilleurs résultats que la compilation statique car les compilateurs dynamiques peuvent optimiser selon leur connaissance de l'environnement cible et des classes qui sont utilisées. La compilation JIT et la recompilation dynamique autorisent Java de tirer profit de la rapidité du code natif sans perdre la portabilité.

La portabilité est techniquement un objectif complexe à atteindre et le succès de Java en ce domaine est mitigé. Quoiqu'il soit effectivement envisageable d'écrire des programmes pour la plate-forme Java qui fonctionnent correctement sur énormément de machines cibles, le nombre important de plates-formes avec de petites erreurs et des incohérences a abouti à un détournement du slogan de Sun «Write once, run anywhere» («Écrire une fois, exécuter partout») en «Write once, debug everywhere» («Écrire une fois, déboguer partout»)  !

L'indépendance de Java vis-à-vis de la plate-forme est cependant un succès avec les applications côté serveur comme les services web, les servlets et le Java Beans autant que les dispositifs embarqués sur OSGi, utilisant l'environnement Embedded Java.

Mécanisme du ramasse-miettes (Garbage Collector)

Un argument envisageable à l'encontre de langages comme le C++ est la lourde tâche d'avoir à programmer manuellement la gestion de la mémoire. En C++, la mémoire est allouée directement par le programmeur pour créer un objet et est désallouée lors de la destruction de ce dernier. Si le programmeur oublie de désallouer la mémoire, ceci peut aboutir à un manque de mémoire, et le programme consomme progressivement de la mémoire sans nettoyer derrière lui. Pire toujours, si une zone mémoire est désallouée deux fois, le programme peut devenir instable et aboutir à un plantage.

En java, ce problème est évité grâce au ramasse-miettes (en anglais Garbage collector). Les objets qui sont créés sont positionnés dans un tas. Le programme et les autres objets peuvent accéder à l'objet grâce à sa référence dans le tas. Lorsqu'il ne reste plus aucune référence vers l'objet, le ramasse-miettes détruit automatiquement l'objet devenu inaccessible, libérant la mémoire et prévenant ainsi un manque de mémoire. Les manques de mémoire peuvent néanmoins survenir lorsque un programme garde une référence vers un objet dont il n'a plus besoin ; ils continuent à exister, mais seulement à un niveau concept bien plus élevé. Mais dans la totalité, le ramasse-miettes rend la création et la destruction d'objets en Java plus simple, potentiellement plus sûre et fréquemment plus rapide qu'en C++.

Une grande faiblesse de ce dispositif étant que si deux objets se référencent entre eux sans que le programme les utilise, le ramasse-miettes ne remarque pas que ces objets ne sont plus liés à la fonction principale du programme et ne seront plus utilisés. C'est par conséquent une fuite de mémoire.

Le ramasse-miettes est transparent pour le développeur et est nommé régulièrement et automatiquement. Cependant, le programmeur peut au besoin suggérer à la machine virtuelle de lancer le ramasse-miettes avec la méthode System. gc () .

Concepts de base

Le dispositif Java est basé sur le langage Java, la machine virtuelle Java et l'API Java (ces deux derniers composants forment l'environnement d'exécution, ou JRE, pour Java Runtime Environment).

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

• Être orienté objet ;
• Être indépendant de la plate-forme du client ;
• Contenir des aides et des bibliothèques pour le réseau informatique ;
• Avoir la capacité d'exécuter du code de source extérieure de façon sécurisée.

Java est généralement compilé vers une machine virtuelle standardisée, sous forme de bytecode. Cette machine peut fonctionner avec un interpréteur, un compilateur just-in-time (à la volée), ou, le plus fréquemment, avec un mélange des deux.

Il existe des variantes de ce schéma :

• servant à compiler le langage Java nativement, c'est-à-dire de produire un exécutable capable de fonctionner hors de l'environnement Java, et même de produire un exécutable capable de fonctionner dans l'environnement CLR de Microsoft. NET, grâce à la variante J# de Java, créée par Microsoft ;
• servant à produire un exécutable Java à partir d'autres langages, comme Python à l'aide du compilateur Jython, Jabaco, ou encore Groovy.

Un langage orienté objet

La première caractéristique, l'orienté objet, se 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 aisément réutilisable, car il est intrinsèquement modulaire.

D'autres mécanismes tels l'héritage permettent d'exploiter l'ensemble des caractéristiques d'une Classe auparavant rédigée (la plupart du temps par quelqu'un d'autre) dans ses propres programmes sans même avoir à en connaître le fonctionnement interne, on n'en voit que l'interface (les principales commandes).

Ce paradigme de programmation vise à rendre les grands projets logiciels plus faciles à gérer, à perfectionner la qualité des logiciels ainsi qu'à diminuer le nombre d'échecs de projet.

Dans la version 1.5 du langage ont été rajoutés les génériques, un mécanisme de polymorphisme identique (mais différent) aux templates du langage C++ ou aux foncteurs d'Objective Caml. Les génériques permettent d'exprimer d'une façon plus simple et plus sûre les propriétés d'objets comme des conteneurs (listes, arbres…)  : le type liste est alors reconnu génériquement comparé au type d'objet contenu dans la liste.

Exécution sécurisée de code distant

La plate-forme Java fut l'un des premiers dispositifs à 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 d'une applet fonctionne dans un espace particulièrement restrictif, ce qui protège l'utilisateur des codes erronés ou mal intentionnés. Cet espace est délimité par un objet nommé gestionnaire de sécurité. Un tel objet existe aussi pour du code local, mais il est alors par défaut inactif.

Le gestionnaire de sécurité (la classe SecurityManager) sert à définir un certain nombre d'autorisations d'utilisation des ressources du dispositif local (dispositif de fichiers, réseau, propriétés dispositif, …). Une autorisation définit

1. un code accesseur (typiquement, une applet - peut-être signée - envoyée depuis un serveur web)  ;
2. une ressource locale concernée (par exemple un répertoire)  ;
3. un ensemble de droits (par exemple lire/écrire).

Les éditeurs d'applet peuvent demander un certificat pour leur permettre de signer numériquement une applet comme sûre, leur donnant ainsi potentiellement (moyennant l'autorisation correcte) la permission de sortir de l'espace restrictif et d'accéder aux ressources du dispositif local.

Le langage

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

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

Le fichier source doit s'appeler HelloWorld. java. Vous pouvez le tester avec les commandes suivantes (sous Linux)  :

javac HelloWorld.java
CLASSPATH=.
java HelloWorld

La ligne «CLASSPATH=.» est indispensable pour indiquer à Java qu'il doit aussi chercher les programmes class dans le répertoire courant. Ce chemin peut aussi être spécifié au lancement du programme par l'option -classpath (ou -cp en abrégé)  :

javac HelloWorld.java
java -cp . HelloWorld

Mots réservés, primitifs et littéraux

abstract              else                 instanceof   strictfp       while   boolean   false
assert (JDK 1.4)      enum (JDK 1.5)       interface    super                  byte      null
break                 extends              native       switch                 char      true
case                  final                new          synchronized           double
catch                 finally              package      this                   float
class                 for                  private      throw                  int
const (Non utilisé)   goto (Non utilisé)   protected    throws                 long
continue              if                   public       transient              short   
default               implements           return       try                    void
do                    import               static       volatile

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

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

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

 for(<Objet récupérant l’occurrence suivante de la collection> : <collection d’objets>){
    instruction(s)
 }

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

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

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

 switch (<expression de type numérique>) {
    case <constante de type numérique>:
         instruction(s)
         break;
    case <constante de type numérique>:
        instruction(s)
        break;
    [...]
    default:
         instruction(s)
         break;
 }

 <expression booléenne> ? <valeur si vrai> : <valeur si faux>

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

 
 FileOutputStream fos = null; 
 
 try {
      //<-- Créer un flux pour écrire dans un fichier. Le fichier
      //n’est pas spécifié puisque ce n’est pas essentiel pour 
      //l’exemple.
      fos = new FileOutputStream(...);
 
      fos.write(a); //'a' aurait reçu une valeur ultérieurement
 }
 catch (IOException e) {
      e.printStackTrace();
 }
 finally{
     //Fermer le flux, qu’il y ait une exception lancée ou pas
     if(fos != null) fos.close();
 }

 public class  hello world {
    private String text = " hello world";
 }

from java.applet import Applet

class HelloWorld(Applet):
    def paint(self, g):
        g.drawString("Hello from Jython!" 20, 30)

      Java(target = 'classes', source = 'src')
      Jar(target = 'test.jar', source = 'classes')

     % scons -Q
     javac -d classes -sourcepath src src/Exemple1.java src/Exemple2.java src/Exemple3.java
     jar cf test.jar classes