Les Interfaces

Je ne parlerais pas des interfaces graphiques mais des interfaces de java qui permettent de définir un “contrat”. Une classe qui veut implémenter une interface se doit donc proposer une implémentation pour chacune des méthodes défini dans l’interface. Comme le but de cette série d’article n’est pas d’apprendre à développer en java, je vais passer directement à ce qu’il est nécessaire de savoir pour passez la certification scjp.

Dans une interface les méthodes déclarées sont implicitement public et abstract donc si vous écrivez :
void clonable();
le compilateur traduira par :
public abstract void clonable();
Les 2 notations sont valides et vous pouvez même faire des variantes (inutiles) :
abstract void clonable();
public void clonable();

Et pour finir voici le récapitulatif règles pour qu’une interface soit correcte :

• Les variables(qui sont en faite des constantes) d’une interface doivent être public,final et static.
• Les méthodes ne peuvent être ni static, ni final, ni private.
• Une interface peut étendre (extend) seulement d’autres interfaces et ne peut pas en implémenter (implements).
• Pour les variables déclarés dans une interface il est conseillé d’utilisé la notation des constante (CONSTANTE_PATATE).

La déclaration des classes en détail

Pour commencer voici les 4 points clés communs à la déclaration des classes, qu’elles soient concrète,  abstraite, et des classes spécifiques de type enum :

1. Une seul classe publique par fichier source.
2. S’il le fichier source contient une classe publique alors leur nom doivent être identique (public Class Patate {} -> Patate.java).
3. S’il la classe appartient à un package alors il sera déclaré en premier.
4. Les imports doivent être declarés entre le package (s’il est défini) et la déclaration de la classe.

Note : Pour le choix du nom du package, Sun préconise l’utilisation des noms de domaine inversé (com.jisser.programme.action).

Il existe 2 variétés de modificateur de classes, les modificateurs d’accès (visibilité) et les autres ceux qui ne modifient pas l’accès.

Il y a 4 modificateurs d’accès pour les classes.

• public : pas de limitation d’accès à la classe, elle est accessible depuis n’importe quelle autre classe de n’importe quel package.
• default (quand rien n’est précisé lors de la déclaration ) : Limite la visibilité de la classe au package auquel elle appartient.
• protected et private : ne sont pas utilisé que dans des cas particuliers comme les classes internes.

Ensuite il reste les modificateurs final, abstract, strictfp :

• strictfp : permet de spécifier que cette classe est conforme à la norme IEEE 754, afin que les nombres à virgule flottante soit indépendant de la plateforme.
• final : son utilisation est plutôt rare. Il permet de bloquer la possibilité d’héritage sur une classe. Donc une classe final ne pourra jamais être modifié ca permet de s’assurer que personne ne pourra redéfinir ou étendre le comportement de la classe.
• abstract : une classe abstraite ne peut pas être instanciée. Elle doit être étendue. La classe abstraite Patate pourrait être étendu par PatateCharlotte. Une classe doit être marquée abstraite si au moins une de ses méthodes est aussi marquée abstraite.

Note : il est impossible d’avoir une classe avec les modificateurs final et abstract en même temps.

Regles et conventions de nommage

Pour préparer la certification scjp, j’ai décidé de faire une série d’articles qui aborderont brièvement les points à connaître. Un peu comme les fiches de révision des étudiants…

Règles pour les noms des classes, interfaces, méthodes et variables :

• ne doivent pas être un mot-clefs (example : try, new, enum, …)
• ne doivent pas commencer par un caractère spécial (sauf _ ou un caractère de devise comme $) ou un chiffre.

Note : La convention de sun est disponible ici pour les courageux.

Pour le nommage des classes :

• il est recommandé d’utiliser un nom (Patate,Facture,…).
• il faut mettre la première lettre de chaque mot en majuscule (Patate,FactureEau,…).

Pour les interfaces :

• il est recommandé d’utiliser un adverbe (Comparable, Clonable, …).
• il faut mettre la première lettre de chaque mot en majuscule (Patate,FactureEau,…).

Pour le nommage des méthodes :

• il est recommandé d’utiliser un verbe plus un nom (getPrix,setType, …).
• il faut commencer par une lettre en minuscule puis mettre la première lettre de chaque mot en majuscule (getPrixEau, …).

Pour le nommage des variables :

• il faut commencer par une lettre en minuscule puis mettre la première lettre de chaque mot en majuscule (prixEau, varietePatate).

Pour le nommage des constantes :

• on utilise seulement des caractères en majuscule (CATEGORIE_A, …).
• on utilise le caractère _ comme séparateur (TYPE_COLOR_RGBA, TYPE_COLOR_GRAY).

Voila nous avons fait le tour des principales régles et conventions rien de très compliqué a retenir.

Design Pattern Observer

A quoi sert le design pattern observer (Observé/Observateur) ?
Concretement ça permet à l’objet Observé d’informer les Observateurs lorsqu’il y a un changement.
Oui mais pourquoi l’utiliser ?
Ca évite de faire de “l’attente active”, du coup pas consommation inutile des ressources pour aller verifier qu’il y a bien eu un changement.
En plus c’est propre et déjâ implémenter en java.

//Fichier ChronoObservable.java
import java.util.Observable;

public class ChronoObservable extends Observable {
  private long time;

  public ChronoObservable() {
    super();
  }

//setTime met à jour l'attribut time ensuite il passe en état "Changed" et informe les observateurs avec notifyObservers().
//note : si vous utilisez notifyObservers() sans setChanged() cela n'aura aucun effet.
  public void setTime() {
    this.time = System.currentTimeMillis();
    this.setChanged();
    this.notifyObservers();
  }

  public long getTime() {
    return time;
  }
}
//Fin de Fichier

//Fichier AfficherChrono.java
import java.util.Observable;
import java.util.Observer;

public class AfficherChrono implements Observer {

  //la méthode update est éxécutée lors de la récéption d'une notification d'un objet Observé
  public void update(Observable o, Object arg) {
    System.out.println("changement du chrono");
  }

  public static void main(String[] args) {
    AfficherChrono Afficher = new AfficherChrono();
    ChronoObservable Chrono = new ChronoObservable();
    //On ajoute un observateur à la liste des observateurs du ChronoObservable.
    Chrono.addObserver(Afficher);

    //petite boucle pas trop utile pour montrer que les appels à setTime() éxécutent bien la méthode update de l'observateur.
    for (int i=0;i<=100;i++) {
      try {
        Thread.sleep(200);
      } catch (Exception e) {
        e.printStackTrace();
      }
      Chrono.setTime();
    }
  }
}
//Fin de Fichier

Changement de décors

Hop je fais une tentative de résurection de mon bac à sable.
Première étape changement de thème pour améliorer la lisibilité.
Deuxieme étape publier !

Micro Projet Hiragana (v0.09)

Et bien ça traine pas mal en ce moment…
Je pensais présenter la suite des captures des interfaces graphique en java, mais SWT m’a posé quelques problèmes sous Linux et Jface ne veut rien savoir sous prétexte qu’il ne trouve pas IProgressMonitor (ce qui est certainement du a la version d’éclipse que j’utilise et qui n’est pas très propre).

SWT : Standard Widget Toolkit. La bibliotheque SWT utilise les composants natif du système d’exploitation pour la gestion des interfaces graphiques par l’intermédiaire de JNI (Site officiel).

JFace : C’est un toolkit de manipulation de SWT.

Suite a cette série de test j’ai décidé d’utiliser Swing pour la partie graphique de ce micro projet car :

• Le besoin de performance n’est pas vital.
• La compatibilité est un plus.
• L’interface reste identique sur tous les systèmes.
• Permet d’utiliser le modèle MVC.

Micro Projet Hiragana (v0.08)

Après une période professionnelle chargée, je peux enfin souffler afin de vous présenter brièvement les différentes api et framework permettant le développement d’interface graphique en java, c’est a dire :

• AWT
• Swing
• SWT
• JFace
• JavaFX

AWT : Abstract Windowing Toolkit cette api est  totalement indépendante du matériel. Elle est moins utilisée actuellement au profit de Swing.

Hello World avec AWT sous windows XP et Debian

SWING : C’est une surcouche s’appuyant sur AWT et java2D. Les performances sont un peu moins bonnes que celle d’AWT, ce qui parait logique puisque Swing s’appuie dessus. Les interfaces graphiques créées sont très similaire pour tous les systèmes d’exploitation.

Hello World avec SWING sous windows XP et Debian

Micro Projet Hiragana (v0.07)

Après avoir vu la classe Hiragana nous passons à la classe Hiraganas. Son fonctionnement n’est pas encore figé et risque d’évoluer mais ça va nous permettre d’avancer sur les autres parties de l’application. La classe Hiraganas a pour objectif de fournir des collections d’objet Hiragana, pour le moment nous nous limiterons a une collection complète.
Il existe plusieurs type de collection pour faire court (Framework Collection) :

• Collection (non ordonnée)
• List (utilise un index, permet les doublons)
• Map (utilise une clé)
• Queue (Fonctionnement de type FIFO ou LIFO)
• Set (pas de doublon, peut etre ordonnée)

Dans ce cas nous utiliserons des HashSet car :

• pas de doublon a gerer
• parcour linéare
• pas de besoin d’index

Le Constructeur est charger d’initialiser la collection d’Hiragana de référence. Pour ce faire il initialise un document DOM avec la méthode initDoc,et le parcours à l’aide de la méthode privé nextHiragana. A chaque noeud hiragana rencontré il instancie un objet Hiragana grâce à la méthode getCurrentHiragana puis l’ajoute à la collection hiraganaFullCollection. Enfin la méthode getHiraganaFullCollection permet de récuperer La Collection complète des Hirigana présent dans le ficher xml.

import java.util.HashSet;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import java.io.File;
import java.io.FileNotFoundException;

public class Hiraganas {
  private HashSet hiraganaFullCollection;
  private final String myXmlFilePath="hiragana.xml";
  private Document myXmlDoc=null;
  private DocumentBuilder docBuilder;
  private DocumentBuilderFactory docFactory;
  private Node iteratorNode;

  public Hiraganas() throws Exception {
    hiraganaFullCollection = new HashSet();
    myXmlDoc = initDoc(new File(myXmlFilePath));
    this.iteratorNode = nextHiragana(myXmlDoc.getFirstChild());
    while (!(this.iteratorNode == null)) {
      hiraganaFullCollection.add(getCurrentHiragana(this.iteratorNode));
      this.iteratorNode = nextHiragana(this.iteratorNode);
    }//end while
  }// end constructor

  private Document initDoc(File xmlFile) throws Exception {
    if (!xmlFile.canRead()) {
      throw new Exception("File " + xmlFile.getName() + " no readable");
    }//end if
    docFactory = DocumentBuilderFactory.newInstance();
    docBuilder = docFactory.newDocumentBuilder();
    return docBuilder.parse(xmlFile);
  }//end initDoc

  private Hiragana getCurrentHiragana(Node currentNode) throws Exception {
    return new Hiragana(currentNode);
  }// end getCurrentHiragana

  private Node nextHiragana(Node currentNode) {
    Node nextNode = null;
    if (currentNode == null) { return nextNode; }

    if (currentNode.getNodeName().equals("hiragana")) {
      nextNode = currentNode.getNextSibling();
    }//end if

    if (currentNode.getNodeName().equals("hiraganas")) {
      nextNode = currentNode.getFirstChild();
    }//end if

    while (!(nextNode == null) && !(nextNode.getNodeName().equals("hiragana"))) {
      nextNode = nextNode.getNextSibling();
    }//end while
    return nextNode;
  }//end nextHiragana

  public HashSet getHiraganaFullCollection() {
    return hiraganaFullCollection;
  }//end getHiraganaFullCollection
}

Micro Projet Hiragana (v0.06)

Peu de nouveauté cette fois, je me contente juste de la classe de base Hiragana. Son constructeur prend en paramètre un noeud (node) et le parcours afin d’instancier correctement les attributs. En cas de problème avec le constructeur, il jette simplement une exception générique, par exemple si le noeud passé est null ou porte un nom différent de celui attendu. Une fois initialisé les valeurs peuvent seulement être lu par les “getters”.

import org.w3c.dom.Node;
import java.lang.Exception;

//classe Hiragana
public class Hiragana {
  private Integer id;
  private String image;
  private String romanji;
  private String sound;
  private Integer level;

  //constructeur
  public Hiragana(Node nH) throws Exception {
    if (nH == null) {
      throw (new Exception("Null Node"));
    }// end if
    if (!nH.getNodeName().equals("hiragana"))
    {
      throw (new Exception("Bad Node"));
    }// end if

    id = Integer.getInteger(nH.getAttributes().getNamedItem("id").getNodeValue());
    Node child = nH.getFirstChild();

    while (!(child.getNextSibling() == null)) {

      if (child.getNodeName().equals("image")) {
        image = child.getAttributes().getNamedItem("uri").getNodeValue();
      }//end if

      if (child.getNodeName().equals("romanji")) {
        romanji = child.getFirstChild().getNodeValue();
      }//end if

      if (child.getNodeName().equals("level")) {
        level = Integer.getInteger(child.getFirstChild().getNodeValue());
      }//end if

      if (child.getNodeName().equals("son")) {
        sound = child.getAttributes().getNamedItem("uri").getNodeValue();
      }// end if

      child = child.getNextSibling();
    }//end while
  }//end constructeur

  //getters
  public Integer getId(){ return this.id; }
  public String getImage(){ return this.image; }
  public String getSound(){ return this.sound; }
  public String getRomanji(){ return this.romanji; }
  public Integer getLevel(){ return this.level; }
}

Micro Projet Hiragana (v0.05)

Comme nous avons appris à ouvrir un fichier xml et créer un DOM avec celui-ci on va maintenant voir comment naviguer dedans. Nous commencons par importer les interfaces Node et NamedNodeMap qui vont permettre de récupérer les différents noeuds constituant le fichier xml.

Un appel de myDoc.getFirstChild() permet de récupérer le 1er noeud enfant du document, à savoir dans notre cas “hiraganas”. On le stock dans currentNode puis on récupère aussi son premier noeud enfant. Contrairement à ce que l’on pourrait croire le noeud récupérer n’est pas “hiragana” mais un noeud de type Text contenant “nt” qui correspond au retour a la ligne et la tabulation utilisé après la balise. Avec childNode.getNextSibling() nous allons enfin pouvoir récupérer le premier noeud “hiragana”. On effectue un test pour déterminer si le noeud possède des attributs si c’est le cas on récupère une liste des attributs. Dans notre cas nous allons afficher le nom et la valeur de l’attribut id.

Nous venons de faire le tour des fonctions primaire de navigation dans un document xml ce qui devrait nous permettre de construire une collection d’hiraganas.

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import java.io.File;

public class xmlReader {

  public static void main(String[] args) {
    Document myDoc=null;
    DocumentBuilder docBuilder;
    DocumentBuilderFactory docFactory;
    Node currentNode,childNode,nextChildNode;
    docFactory = DocumentBuilderFactory.newInstance();

    try {
      docBuilder = docFactory.newDocumentBuilder();
      myDoc = docBuilder.parse(new File("hiragana.xml"));
    } catch (Exception e) {
      System.out.println("Exception : " + e.getLocalizedMessage());
    }//end try catch

    //first
    currentNode = myDoc.getFirstChild();
    System.out.println("node name : " + currentNode.getNodeName());

    //child
    childNode = currentNode.getFirstChild();
    System.out.println("first child node name : " + childNode.getNodeName());

    //nextChildNode
    nextChildNode = childNode.getNextSibling();
    System.out.println("next child node name : " + nextChildNode.getNodeName());

    //getAttributes
    if (nextChildNode.hasAttributes()) {
      NamedNodeMap attributeList;
      attributeList = nextChildNode.getAttributes();
      System.out.println("name : " + attributeList.getNamedItem("id").getNodeName());
      System.out.println("id : " + attributeList.getNamedItem("id").getNodeValue());
    }//end if

  }//end main
}//end xmlReader