Apprendre Java : les frameworks et les langages JVM

Apprendre le langage Java ne veut pas dire apprendre sa syntaxe ou ses structures de base. Autrement, tout développeur C et C++ peut se voir comme un développeur Java. Apprendre Java veut dire un peu plus que la syntaxe.

Premièrement, il faut apprendre l'API Java. L'API Java fournie avec la JDK est très puissante. La majorité des applications J2SE reposent seulement sur l'API par défaut. Elle peut être considérée comme un facteur clé du succès du langage Java. Parmi les packages les plus utilisés :

1. java.lang : le package importé par défaut et qui contient les classes essentielles pour écrire un programme Java (System, String, Class, Exception, Thread, etc..)
2. javax.swing : (après AWT) pour les interface graphiques.
3. javax.net : pour la programmation réseau.
4. java.nio : (après io) pour les flux entrée/sortie.
5. java.sql : pour interagir avec les Bases de Données relationnelles.

Ainsi, nous pouvons développer une application de gestion réparties, suivant l'approche Client/Serveur avec Client lourd, basée sur une Base de Données centralisée avec support de l'importation et l'exportation des données en utilisant la J2SE standard sans ajouter d'autres API sauf le driver du SGBDR utilisé (qui ne sera plus nécessaire s'il s'agit du Derby fourni avec la JDK).

Mais est-ce tout ? Non.

Deux autres éléments essentiels dans l'apprentissage de Java sont les framework et les langages JVM.

Premièrement, nous trouvons généralement les frameworks dans le cadre de développement des applications entreprises (n-tiers) sous J2EE. Ces framework ont trouvé de la popularité avec le retard remarquable qu'a fait la bibliothèque standard J2EE dans ce domaine. En effet, sans ce retard, les frameworks Spring et Struts n'auront pas gagné du terrain. Ainsi, à une époque donnée, apprendre la J2EE était synonyme de "apprendre une framework J2EE".

Aujourd'hui cette affirmation reste valide mais pas avec la même puissance. D'un côté, la J2EE devient de plus en plus à jour; elle arrive à cacher ses inconvénients et sa lourdeur qui limitent sa productivité (présentation Adam Bien). Elle arrive aussi à proposer ses propres frameworks disponibles par défaut; nous avons remarqué aussi la qualité améliorée de ces framework (Java Server Faces en ai un exemple). De l'autre côté, les différents frameworks continuent de progresser et gardent leur avance par rapport à la plate-forme J2EE part défaut. Les nouveaux besoins et les nouvelles approches favorisent ces frameworks et compliquent la tâche de la plate-forme par défaut.

Deuxièmement, nous devons reconnaître les langages JVM; des langages de programmation basés sur la machine virtuelle de Java. Ces langages sont, généralement, compatible directement avec Java et peuvent accéder à toutes les bibliothèques disponibles sans aucun effort supplémentaire. Ils compilent leur code vers Bytecode de Java et profite ainsi de sa portabilité.

Ces langages sont proposés pour plusieurs raisons :

1. Simplifier et moderniser le langage : Java est un langage puissant mais lourd. Quelques langages sont proposés pour le simplifier et le moderniser. Groovy et Kotlin sont des excellents exemples.
2. Pour répondre à un besoin spécifique : Java est un langage général qui permet de développer différents systèmes et pour différents domaines, néanmoins, avoir un langage spécialisé qui garde la puissance de Java reste une option intéressante. Tel est le cas avec des langages comme Scala (programmation formel), SARL (programmation basée Agents) et Processing (dessins et animations).
3. Pour faciliter l'apprentissage de la programmation et du langage Java : Java est strict et nécessite un respect rigoureux des notions Objets; la chose qui n'est pas facile pour les débutants en programmation. Ainsi, quelques langage JVM sont conçu pour être facile et simple et pour cacher la lourdeur du Java. Javascool en est un excellent exemple.

 

 

La plus part de ces langages offrent leurs propres APIs. Ces APIs représentent un enrichissement remarquable à exploiter et à être pris en considération par les développeurs Java. Nous prenons, comme, exemple les chaînes de caractères sous Groovy. Ces chaînes de caractères sont implantées en utilisant la classe GString, une extension puissante de la classe String de l'API J2SE par défaut. En l'utilisant, nous pouvons, à titre d'exemple, bénéficier de :

1. La déclaration d'une chaîne de caractère sur plusieurs lignes (comme les commentaires sur plusieurs lignes) en utilisant le délimiteur """.

def maChaine = """Bonjour chèrs internautes,
Cela est un exemple sur les chaîne de caractères sur plusieurs lignes.
Merci Groovy."""

println maChaine

2. Il est possible d'effectuer des substitutions de variables en utilisant le $ associé à leurs noms dans la chaîne de caractères.

def monPrenom = "Tarek"

println "Bonjour ${monPrenom}."

Certain de ces langages ont pu prendre la place du Java. Kotlin, par exemple, est devenu le langage de développement des applications Android, malgré, qu'à la base, il n'était pas conçu pour cet objectif.

Ainsi, apprendre Java veut dire apprendre sa syntaxe, son API par défaut (J2SE et J2EE) et apprendre , selon vos besoins et votre spécialité, la framework ou le langage JVM le plus adéquat. A titre d'exemple, pour enseigner en présentiel et à distance, je me trouve orienté vers les langages Groovy, Javascool et Processing. Les frameworks, dans mon contexte professionnel, ne trouve pas assez de place à part des démonstrations très limitées pour les étudiants en Master (université de Jijel).

Editeur des diagrammes Entité/Association en une soirée grace à Processing

La facilité de dessin et de gestion des évènement permet au développeur sous Processing de préparer rapidement des prototypes ou bien des outils dans un temps record. Cette capacité est très nécessaire lorsqu'il s'agit de prouver une idée ou bien pour préparer une démonstration rapide pour votre client.

Dans cet exemple, j'ai créé rapidement un éditeur des diagramme Entité/Association sous Processing dans environs 350 lignes de code. L'éditeur ne permet pas d'annuler, de déplacer de sélectionner les objets créés. Néanmoisn, il permet de :

1. Créer des entités en faisant un clique gauche :
1. L'entité est créée à l'endroit où le clique a eu lieu.
2. L'éditeur vous demande le nom de l'entité qui ne doit pas être vide.
3. Il vous demande, par la suite, une liste d'attributs, une à la fois. La création de la liste des attributs s'arrête lorsque la chaîne vide est entrée.
2. Créer des associations en faisant un clique droit :
1. L'association est créée à l'endroit où le clique a eu lieu.
2. L'éditeur vous demande le nom de l'association qui ne doit pas être vide.
3. Il vous demande, par la suite, une liste d'attributs, une à la fois. La création de la liste des attributs s'arrête lorsque la chaîne vide est entrée.
3. Pour créer un lien, il faut dessiner une ligne d'un objet à un autre objet de différente nature (d'une entité vers une association ou bien d'une association vers une entité). Les autres liens seront refusés (l'unique vérification dans le système).

Au stade actuel, le système ne fait pas d'autres vérifications, c'est à dire, il est possible de créer deux entités avec le même nom, d'avoir deux attributs identiques et de mettre ce que vous voulez comme cardinalité. Mais, comme j'ai déjà mentionné, il s'agit d'une démo pour Processing plus qu'un éditeur.

Dans ce projet, vous pouvez voir comment différencier les bouttons de la souris en toute simplicit. Dans la méthode "mousePressed()", il est nécessaire de vérifier est ce qu'il s'agit d'un clique droit pour insérer une association ou bien d'un clique gaucheoù il faut véirifier est ce qu'il est appliqué à l'intérieur d'un objet ce qui veut dire qu'il s'agit d'un lien ou bien s'il est à l'extérieur de tout objet pour insérer une nouvelle entité.

void mousePressed(){
  if(mouseButton == LEFT){
    int entite = verifierEntites(mouseX, mouseY);
    if(entite != -1){
      creationLien = true;
      entiteSource = true;
      source = entite;
    }else{
      int association = verifierAssociations(mouseX, mouseY);
      if(association != -1){
        creationLien = true;
        entiteSource = false;
        source = association;
      }else{
        lireEntite(mouseX, mouseY);
      }
    }
  }else{
    lireAssociation(mouseX, mouseY);
  }
}

La vérification que le clique est à l'intérieur d'un objet se fait par rapport aux coordonnés et mesures de ce dernier. Ainsi dans la classe Objet, on trouve la méthode "estDedans()" :

  public boolean estDedans(int cx, int cy){
    return cx > x && cx < x + getLargeur() && cy > y && cy < y + getHauteur();
  }

La méthode qui est supposée faire toutes les vérifications concerant les noms des entitées, des associations et des attributs ne fait en réalité que lire ces valeurs sans aucune vérification; elle nécessite un effort supplémentaire :

void lireEntite(int mx, int my){
  String nom = JOptionPane.showInputDialog(null, "Donnez le nom de l'entité");
  if(nom != null && !nom.equals("")){
    Entite e = new Entite(mx, my);
    String propriete;
    int i = 0;
    do{
      propriete = JOptionPane.showInputDialog(null, "Donnez les propriétés (vide pour terminer)");
      if(propriete != null && !propriete.equals("")){
        e.addAttribut(propriete);
        i++;
      }
    }while(propriete != null && !propriete.equals("") && i < NOMBRE_MAX_ENTITES);
    e.setNom(nom);
    entites[nbrEntites] = e;
    nbrEntites++;
  }
}

Vous pouvez télécharger le code par ici.