Les principales Versions du jdk

Pour développer en java, vous devez disposer d'un JDK ( Java Developement Kit ), un kit de développement, ainsi qu'une documentation associée et un éditeur.

Pour installer un JDK sur votre machine, vous pouvez vous référer ici http://www.linux-france.org/prj/edu/archinet/DA/install-java. Vous y trouverez une procédure détaillée, contenant en fin de document un lien vers une ressource d'installation de java pour d'autres systèmes (Mac, Windows).

A la racine de l'installation se trouve le fichier src.jar qui contient les sources de la librairie. Il peut être décompressé dans un sous répertoire à créer pour l'occasion (par exemple <rep du jdk>/src).

Tel quel, le programme n'est pas exécutable.

Il doit être compilé , c'est à dire traduit en un autre langage, appelé byte code pour être compris par l'interpréteur. Au cours de cette traduction, de nombreuses et précieuses vérifications sont réalisées. Si des erreurs sont rencontrées par le compilateur (le traducteur), il ne générera pas la version compilée, charge alors au développeur de corriger sa copie. Exemple de compilation avec javac :

[tp1]$ ll
total 4
-rw-rw-r-- 1 kpu   kpu   94 nov  1 20:46 AppTp1.java
[tp1]$
[tp1]$ javac AppTp1.java 
[tp1]$
[tp1]$ ll -tr 
total 8 
-rw-rw-r--   1 kpu   kpu  94 nov  1 20:46 AppTp1.java 
-rw-rw-r--   1 kpu    kpu   257 nov  1 20:47 AppTp1.class 
[tp1]$ 

La compilation a bien fonctionné. Un nouveau fichier est apparu, avec une extension .class .

Nous utiliserons la commande java (comme la commande précédente, mais sans le c pour compilateur). En prenant bien soin de ne pas mentionner l'extension ! Exemple :

[tp1]$ java AppTp1
[tp1]$ 

Ainsi, il ne se passe rien ! Que s'est-il passé au juste ?

La commande java a fait en sorte de charger la classe AppTp1.class en mémoire, puis la méthode main est appelée. Comme elle ne comporte aucune instruction, son exécution se termine et le programme s'arrête.

Modifions notre programme afin qu'il affiche un message à l'écran :

public class AppTp1 {
  static public void main(String[] arg) {
   System.out.println ("Hello, ce n'est pas encore tout à fait");
   System.out.println ("de la programmation objet !");
  }
} 

Pour réaliser l'affichage, nous utilisons l'instruction System.out.println(...) . Au regard de la convention de nommage, et avec notre expérience de la programmation en PHP, nous pouvons affirmer sans erreur que :

Équivalent PHP : print() ou echo() .

Après avoir sauvegardé les modifications, nous devons recompiler le programme pour, de nouveau, le tester :

[tp1]$ vim AppTp1.java     # ici nous avons utiliser l'éditeur vim
[tp1]$ javac AppTp1.java   # compilation
[tp1]$ java AppTp1         # exécution
Hello, ce n'est pas encore tout à fait
de la programmation objet !
[tp1]$

Voilà, le tour est joué. Mais pourquoi avoir mentionné que ce n'est pas tout à fait de la programmation objet ?

Simplement parce que (pratiquement) aucun objet n'a été crée ! Et pourtant il y a un lien extrêmement étroit entre une classe et un objet.

Prenons un exemple en PHP. Ce programme, qui ne devrait pas vous poser de difficulté, il s'attend à recevoir 2 arguments en ligne de commande, à savoir un nom et un prénom.

<?php
require_once("utilitaires.php");
  
if (argc() == 3) {
  $nom = strtoupper(argv(1));
  $prenom = argv(2);
  echo "Bonjour " . $prenom . " ". $nom. ".\n";
}
else {
  echo "Bonjour inconnu(e).\n";
} 
?>

Exemple d'exécution :

$ php -q test.php
Bonjour inconnu(e).

Le même en Java :

public class Bonjour {
  static public void main(String[] arg) {
    if (arg.length == 2) {
      String nom;
      nom = arg[0].toUpperCase();
      String prenom = arg[1];
      System.out.println("Bonjour " + prenom + " "+ nom +".");
    }
    else {
      System.out.println ("Bonjour inconnu(e).");
    } 
  }
}

Exemple d'exploitation (le code source a été sauvegardé dans un fichier nommé Bonjour.java :

$ javac Bonjour.java
$ java Bonjour
Bonjour inconnu(e).

Les variables sont explicitement typées. Le typage d'une variable est réalisé lors de sa déclaration et non plus lors de son affectation comme en PHP. Exemple :

...
String nom;
...

Conséquence, vous devez fournir à une variable une valeur cohérente avec son type, dans le cas contraire le compilateur refusera toute traduction. Exemple :

...
String nom;
nom = toto; // ERREUR : si toto n'est pas une variable de type String
nom = 'toto'; // ERREUR : le symbole ' est réservé au type char (caractère)
nom = "toto"; // OK !
nom = 12; // ERREUR : 12 est une valeur numérique (un entier)
nom = 12.0; // ERREUR : 12.0 est un réel (double)
nom = false; // ERREUR : false et 
nom = true; //           true sont (les seules valeurs) de type boolean
nom = System.out; // ERREUR : out est un Objet de type PrintStream
...

Les fonctions sont préfixées par un identificateur suivi d'un point. Cet identificateur peut être soit le nom d'une classe soit une référence à un objet. Exemple de fonction 'static' :

...
System.exit(0); 
   // Stop l'exécution de la machine virtuelle java (JVM)
...

D'un point de vue PHP, on peut dire que exit est une fonction de la bibliothèque System.

D'un point de vue Java, exit est une fonction utilitaire (static) de la classe System.

Ces deux points de vue sont strictement équivalents.

Toute fois, les fonctions utilitaires sont marginales en Java (et dans tout langage objet). Dans la majorité des cas nous avons à faire à des fonctions membres d'un objet (instance d'une classe). Exemple :

...
String nom = arg[0].toUpperCase();
...

arg[0] référence un objet de type String en mémoire. Cet objet dispose d'un état (un ensemble ordonné de caractères) et propose certains services sous la forme de fonctions membres appelées plus généralement méthode.

	Notation objet
	Un appel de méthode se caractérise par un appel de fonction référencée par un objet : objet.fonction(), alors qu'en PHP nous n'avions vu que l'approche type 'utilitaire', de la forme fonction(données). Exemple : Tableau 1.  PHP - Procédural Java - Objet ... $nom = argv(1); $nomMAJ = strtoupper($nom); ... ... String nom = arg[0]; String nomMAJ = nom.toUpperCase(); ...

Avant d'aborder plus avant les notions d'interface, de classe et d'objet, nous allons nous familiariser avec la séquence : édition, compilation et exécution.

Au lancement d'un programme java, la fonction main de la classe nommée, reçoit une liste d'arguments. Chaque argument est de type chaîne de caractères. Dans le programme suivant, la liste d'arguments est représentée par la variable args, cette liste peut éventuellement être vide.

  
public class Application {
  static public void main(String [] args) {
    System.out.println(args);
  }
}

Une exécution donne :

[kpu@kpu tp]$ java Application
java.lang.String;@1a16869

args est une variable qui référence un objet de type "Tableau de chaînes de caractères". C'est l'adresse de cet objet qui est affichée ici (sans intérêt pour nous). Voici deux des caractéristiques d'un objet de type Tableau (array) :

Nous souhaitons afficher un message particulier lorsque qu'il n'y a pas d'argument. Pour cela nous testons la valeur de length dans une expression booléenne. Nous utilisons l'opérateur arithmétique de comparaison ==

public class Application {
  static public void main(String [] args) {
    if (args.length == 0 ) {
      System.out.println("Aucun argument.");
    }
    else {
      System.out.println("Je reçois " + args.length + " argument(s)");
    }    
  }
}

Exemple d'exécution :

[kpu@c419-12 tp]$ java Application 
Aucun argument.

[kpu@c419-12 tp]$ java Application sd
Je reçois 1 argument(s)

[kpu@c419-12 tp]$ java Application sd zz
Je reçois 2 argument(s)

La structure de décision est la même qu'en PHP.

Structure conditionnelle

La forme générale de cette structure de contrôle de flux est : if (expr. bool) { // instruction(s) si l'expr. bool est true } [ else { // instruction(s) si l'expr. bool est false } ] N'oubliez pas les parenthèses qui entourent toujours l'expression booléenne. Les accolades ne sont pas obligatoires lorsqu'il n'y a qu'une seule instruction dans un bloc (toutefois nous conseillons de ne pas les omettre, comme c'est le cas ici). La clause else (sinon) est facultative, d'où la présence des crochets dans la forme générale.

En Java, une variable est soit de type primitif soit de type référence .

De ce fait le langage Java ne peut être qualifié de langage "purement objet", bien que cette différence s'estompe avec un jdk >= 5.O.

Java traite les variables de type primitif selon une sémantique par valeur et les variables de type objet (classe, interface, tableau - array -) selon une sémantique par référence (ce n'est pas la valeur de la variable qui nous intéresse, mais l'objet référencé). Exemple :

Le fragment de code suivant n'EST PAS VALIDE :

...
int x = 2;
System.out.println(x .toString() ); // INTERDIT !! (avec jdk < 1.5.0)
// x ne référence pas un objet. 
// int n'est pas une classe d'objet, mais un type primitif 
...

Java propose 9 types primitifs, leur nom est entièrement en minuscule ( int, boolean, char, byte, float, double, long, short, void) :

3.1.1. Types primitifs

Les types primitifs ne sont pas des classes.

Figure 2. Types primitifs de Java

Chaque type primitif a son correspondant en type Objet. Alors pourquoi pas le "tout objet" ?

Les créateurs du langage Java ont souhaité conserver l'utilisation des types primitifs dans un but d'efficacité. Un point de vue remis partiellement en cause avec la version 1.5.0 du jdk...

Point de vue plus technique (peut être sauté) : Les "objets" de type primitif sont automatiquement créés sur la pile, et leur valeur confondue avec leur identificateur (sémantique par valeur). Toutes les autres entités sont de véritables objets, créés sur le tas (et non sur la pile) accessible via un ou plusieurs identificateurs; des variables de type référence (sémantique par référence).

La colonne la plus à droite du tableau des types primitifs donne le nom des classe associées à chaque type primitif. Ces classes sont porteuses d'informations telles que les limites du domaine de définition, mais aussi proposent des fonctions utilitaires de conversion relatives au type élémentaire dont elle ont la charge (et qu'elle peuvent représenter en les enveloppant, c'est pour cela qu'on les qualifie de classes wrapper).

Un objet est caractérisé par un ensemble d'opérations (méthodes) et d'attributs, retenus pour leur pertinence par rapport au domaine étudié.

Un attribut est caractérisé par un type, un nom et une valeur. Une méthode par un type, un nom et des instructions. Par exemple :

Etudiant :
  // les attributs
    (entier, age,  18)
    (réel, taille, 1.75)
    (string, nom, "Dupond")
    (booléen, stage_réalisé, faux)
    (réel, moyenne, 12)
    ...
  // les méthodes
    (booléen, passage2annee, { retourner (stage_ok et moyenne > 10) })
     ...
   

La valeur que peut prendre un attribut, une méthode, est fonction de son type. Par exemple l'opération passage2annee retournera soit false soit true.

On appelle état d'un objet, l'ensemble des valeurs de ses attributs à un instant t.

A un instant donné, un objet étudiant aura comme état par exemple {age=18, taille=1.8, nom="Toto", stage_realise=true, ...}

Nous avons vu qu'une classe est une sorte de module pouvant comportée des fonctions utilitaires (marquées static).

Une classe sert aussi, et c'est en fait son premier rôle, à représenter les caractéristiques types d'un objet. Par exemple en Java, la classe Etudiant se représente ainsi.

public class Etudiant {
   
   /**** parties cachées ****/

   // attributs 
   private String nom;
   private String prenom;
   private String login;
   private boolean stage_realise;


   /**** parties publiques ****/

   // constructeur
  /**
   *  Création d'un étudiant
   *  avec Anonymous comme valeur du nom par défaut.
   */
   public Etudiant() {
     this.nom="Anonymous";
   }

   // méthodes
   /**
   * Représentation texte de l'objet
   */ 
   public String toString() {
     String res = "*** Etudiant ***";
     res = res + "\nNom  : " + this.getNom();
     res = res + "\nPrenom : " + this.getPrenom();
     res = res + "\nLogin : " + this.getLogin();
     res = res + "\nStage : ";
     res = res + ((stage_realise) ?  "Réalisé" : "Non réalisé");
     return res;
   }

   /**
   * @return String le login
   */
   public String getLogin() {
     return this.login;
   }

   /**
   * @param unLogin le nouveau login
   */
   public void setLogin(String unLogin) {
     this.login = unLogin;
   }

   /**
   * @return String le nom
   */
   public String getNom() {
     return this.nom;
   }

   /**
   * @param unPrenom le nouveau prenom
   */
   public void setPrenom(String unPrenom) {
     this.prenom = unPrenom;
   }

   /**
   * @return String le prenom
   */
   public String getPrenom() {
     return this.prenom;
   }

   /**
   * @param unNom le nouveau nom
   */ 
   public void setNom(String unNom) {
     this.nom = unNom;
   }
}

La classe décrit les caractéristiques types des objets. C'est une sorte de moule servant à la fabrication (via l'opérateur new) des objets.

Le mot clé this désigne l'objet en cours d'exécution (création ou utilisation).

Nous allons compiler la classe Etudiant :

$ javac Etudiant.java
ll
total 8
-rw-rw-r--  1 user  user   1205 jan 17 09:28 Etudiant.class
-rw-rw-r--  1 user  user   1303 jan 17 09:27 Etudiant.java
$

La version compilée (Etudiant.class) est maintenant disponible pour utilisation.

	Comment utiliser la classe Etudiant ?
	Il existe au moins deux façons de mettre en oeuvre le concept objet : par délégation (utilisation d'objets) et par héritage (spécialisation de classes).

La délégation est LA façon la plus naturelle d'utiliser des objets.

Un programme délégue à un objet (ou à plusieurs) certaines responsabilités.

L'utilisateur d'un objet ne voit que les caractéristiques publiques (public) de l'objet. On lui fournit la version compilée et une documentation des interfaces (API). L'outil javadoc permet de générer une telle documentation. Exemple d'utilisation

$ javadoc Etudiant.java -d docs/
$ cd docs/
$ firefox index.html &

Ce qui donne :

Figure 5. Documentation utilisateur de la classe Etudiant

Un lien vers ce fichier : documentation API Etudiant

Un objet informatique est comme un objet du "monde réel" ; il naît, vit et meurt.

Son espace est la mémoire informatique (illustrée par le film Matrix)

Son temps peut être bref (quelques milli-secondes) ou très long, dépassant celui de ses concepteurs (comme dans IA, le film)

Exemple de cycle de vie d'un objet Etudiant dans un programme Java :

public class AfficheEtudiant {
 static public void main(String[] args) {
   int nbarg =  args.length;

   // création d'un objet Etudiant
   Etudiant e = new Etudiant();

   // utilisation  de l'objet créé
   if (nbarg == 3){
     // valorisation de certains de ses attributs
     e.setNom(args[0]);
     e.setPrenom(args[1]);
     e.setLogin(args[2]);
   }
   
   System.out.println(e.toString());
   
   // fin de son espace d'utilisation, l'objet va disparaître  
 }// main

}//class

L'objet est créé avec new, et le constructeur sans argument Etudiant() est appelé à ce moment là.

Avant de disparaître un état est obtenu (méthode toString()), puis affiché.

Remarque => Une application orientée objet est composée, pour l'essentiel, d'objets collaborant, comme dans la vie réelle. Par exemple, lorsque je démarre titine, ma voiture, elle (titine est un objet, instance de Voiture, démarrer est une méthode de la classe Voiture) communique avec le démarreur (un autre objet, instance de la classe Démarreur) qui, à son tour envoie des messages au carburateur (instance de Carburateur) etc.

Java est un langage fortement typé : Toute variable doit être déclarée. On ne peut déclarer deux fois la même variable dans une fonction, même si elles diffèrent par leur type.

Les objets sont connus, accessibles, via leurs référents (des variables).

Utilisation :

int [] desPoints;
float [] desNotes;
String[] desNoms;
Etudiant [] desEtudiants;

desPoints = new int[4]; 
desNotes = new float[40];
desNoms = new String[5];
desEtudiants = new Etudiant[40];

int [] desPoints = new int[]{-1,-1,-1,-1};  // création d'un tableau de 4 éléments
String [] desNoms = new String[] {"toto", "titi"}; // desNoms.length==2
Jouet [] desJouets = new Jouet[] { new Jouet() }; // desJouets.length==1

int point = desPoints[0]; // accès au premier élément 
point = desPoints[desPoints.length - 1];// accès au dernier élément

desPoints[0]=20; // affecte la valeur 20 au premier élément 
desPoints[desPoints.length - 1]=0;//et 0 au dernier élément
desNoms[0]="toto";
desEtudiants[0]= new Etudiant();

 // un damier de 20 cases x 20 cases
boolean [ ] [ ] lesCases = new boolean[20][20];

 // une bataille navale
Bateau [ ] [ ] lesCases = new Bateau[nbLignes][nbCol]; 

La classe à utiliser : Compte.class.

Une solution : TPCompte.java

L'exercice précédent a abouti à la réalisation d'une classe TPGestCompte ayant une grosse fonction main mélangeant gestion de l'interface utilisateur avec des détails d'implémentations. Or, C'EST EXACTEMENT CE QU'IL NE FAUT PAS FAIRE !

En effet, en l'état, le programme est difficilement maintenable : les interactions utilisateur (affichage du menu, saisies d'informations, affichage de résultats) sont confondues avec la logique de traitement (créer un compte, rechercher un compte, lister les comptes...).

La solution à ce problème est simple, et consiste à concevoir une classe. On pourra alors réaliser une décomposition fonctionnelle (décomposition des traitements par fonctions), au même titre que nous avons appris à le faire avec PHP. Bien entendu, la syntaxe diffère un peu, mais à peine, comme vous allez le constater.

La première chose à faire lorsque l'on conçoit une classe est de définir ses services, en particulier les services offerts au travers de ses instances.

Par exemple, les services (ce sont des opérations) offerts par des objets de type ArrayList, sont spécifiés dans l'interface List (API List). Les opérations d'ajout d'un élément, de suppression, de recherche etc. sont spécifiées ici.

Nous allons faire de même ici, en déclarant des opérations, sans leur corps, dans une structure appelée interface.

Remarque : Noter que cette déclaration peut être réalisée directement dans une classe ; c'est une solution moins souple car elle lie une seule implémentation à une interface donnée, mais satisfaisante dans bien des cas. Nous vous proposons ici, de spécifier les déclarations d'opérations dans une interface, il ne vous restera plus qu'à concevoir plusieurs classes d'implémentation en exercices.

import java.util.*;

interface IFGestCompte {

  /**  retourne la liste des comptes */
  public List getListDesComptes();

  /**  retourne null ou la référence à un compte
  *    dans la liste.
  */

  public Compte getCompte(int position);

  /**  retourne null ou la référence du compte
  *    portant le nom reçu en argument.
  */
  public Compte getCompte(String nom);

  /**  retourne vrai s'il existe dans la liste un compte
  *    ayant comme nom la valeur reçue en argument,
  *    retourne faux sinon.
  */
  public boolean existeCompte(String nom);

  /**  
  * Ajoute un compte  à la liste des comptes.
  */
  public void ajouterCompte(Compte c);

 /**  retourne la liste des comptes, avec un état détaillé
  *    pour chacun d'eux.
  */
  public String details();

}

Nous avons, par l'intermédiaire de l'interface, simplement déclaré un contrat d'utilisation. Cette structure se compile, comme une classe, mais ne peut être instanciée car les opérations n'ont pas de corps !, en d'autres termes elles ne sont pas programmées. C'est aux classes qu'appartient cette responsabilité.

Nous modifions la solution : TPCompte.java, en utilisant une classe qui implémente l'interface IFGestCompte.

import javax.swing.*;
import java.util.List;

public class AppCompte {
 static public void main(String[] args) {

   IFGestCompte gestComptes = new GestComptesArray();

   String menu = "0: Quitter";
   menu += "\n1: Création d'un compte";
   menu = menu + "\n2: Lister les comptes";
   menu = menu + "\n3: Dépôt par position";
   menu = menu + "\n4: Retrait par position";
   menu = menu + "\n5: Dépôt par nom";
   menu = menu + "\n6: Retrait par nom";
   menu = menu + "\n7: Récapitulatif des opérations";
   menu = menu + "\n.Votre choix SVP :";

   String choix; 
   choix= JOptionPane.showInputDialog(menu);
//   choix = Console.lireClavier(menu);

   while (!"0".equals(choix)) {
      if ("1".equals(choix)){
          String unNom = JOptionPane.showInputDialog("Entrez un nom de Compte");
          Compte c = new Compte(unNom);
          gestComptes.ajouterCompte(c);
      }
      else if ("2".equals(choix)){
         List liste = gestComptes.getListDesComptes();
         String res="**** Les comptes ****";
         for (int i=0; i<liste.size(); i++){
            res += "\n***********\n"+liste.get(i).toString(); 
         }
         JOptionPane.showMessageDialog(null, res);
        // System.out.println(res);
      }
      else if ("3".equals(choix)){
        String spos = 
           JOptionPane.showInputDialog("Entrez la position du compte");
        // traduire en String in int 
        int pos = Integer.parseInt(spos);
        Compte c = gestComptes.getCompte(pos);
        if (c != null){
          String smontant = 
             JOptionPane.showInputDialog("Entrez le montant du dépôt");
          double montant = Double.parseDouble(smontant);
          c.deposer(montant);
        }
       }
       else if ("4".equals(choix)){
         String spos = 
            JOptionPane.showInputDialog("Entrez la position du compte");
         // traduire en String in int 
         int pos = Integer.parseInt(spos);
         Compte c = gestComptes.getCompte(pos);
         if (c != null){
           String smontant = 
             JOptionPane.showInputDialog("Entrez le montant du retrait");
           double montant = Double.parseDouble(smontant);
           c.retirer(montant);
       }
      }
      else if ("5".equals(choix)){
        String nom = 
          JOptionPane.showInputDialog("Entrez le nom du compte");
        Compte c = gestComptes.getCompte(nom);
        if (c != null){
           String smontant = 
               JOptionPane.showInputDialog("Entrez le montant du dépôt");
           double montant = Double.parseDouble(smontant);
           c.deposer(montant);
         }
        }
        else if ("6".equals(choix)){
          String nom = 
             JOptionPane.showInputDialog("Entrez le nom du compte");
          Compte c = gestComptes.getCompte(nom);
          if (c != null){
            String smontant = 
               JOptionPane.showInputDialog("Entrez le montant du retrait");
            double montant = Double.parseDouble(smontant);
            c.retirer(montant);
         }
       }
       else if ("7".equals(choix)){
          JOptionPane.showMessageDialog(null, gestComptes.details());
        }
 
     // redemande un choix à l'utilisateur
      choix= JOptionPane.showInputDialog(menu);
     // choix = Console.lireClavier(menu);
   }
   // pour forcer la fermeture.
   System.exit(0);
 }
}

Vous constater que le programme c'est considérablement simplifié (par rapport au précédent : TPCompte.java).

Le programme délégue certaines responsabilités (recherche d'un compte dans la liste, construction de l'état détaillé de chacun des comptes...) à un objet dont la classe est GestComptesArray. Cette classe implémente l'interface IFGestCompte.

L'objectif d'une classe est d'implémenter des services. Elle transforme des opérations en méthodes : une méthode est une réalisation d'opération.

Voici une version à compléter en exercice ! (sur la base de la solution à l'exercice précédent TPCompte.java) :

import java.util.*;

public class GestComptesArray implements IFGestCompte {
  // attributs
  private Compte [] lesComptes;
  private int nbCptes;

  //constructeur
  public GestComptesArray() {
   lesComptes = new Compte[10];
   nbCptes = 0;
  }

  // méthodes
  /**  
  * Ajoute un compte à la liste.
  */
  public void ajouterCompte(Compte c){
    // TODO 
  }

  /**  retourne la liste des comptes */
  public List getListDesComptes(){
    // TODO 
    return null;
  }

  /**  retourne null ou la référence à un compte
  *    dans la liste.
  */
  public Compte getCompte(int position){
    // TODO 
    return null;
  }

  /**  retourne null ou la référence du compte
  *    portant le nom reçu en argument.
  */
  public Compte getCompte(String nom) {
    // TODO 
    return null;
  }

  /**  retourne vrai s'il existe dans la liste un compte
  *    ayant comme nom la valeur reçue en argument,
  *    retourne faux sinon.
  */
  public boolean existeCompte(String nom){
    // TODO 
    return false;
  }

 /**  retourne la liste des comptes, avec un état détaillé
  *    pour chacun d'eux.
  */
  public String details(){
   // TODO
   return "TODO";
  }
}

Vous constatez que la classe d'implémentation reprend TOUTES les opérations définies dans l'interface, à cela elle ajoute des attributs privés nécessaire pour réaliser les méthodes, ainsi qu'un constructeur pour initialiser les attributs.

Une classe d'implémentation est donc généralement composée de 3 parties : attributs, constructeurs et méthodes .

Nous avons vu les tableaux. Intéressons nous maintenant aux objets de type List car nous en aurons besoin dans l'exercice qui suit. Les objets de type List sont d'une grande souplesse, particulièrement lorsque nous ne connaissons pas à l'avance le nombre d'éléments que contiendra notre liste.

List desPoints;
List desNoms;
List desJouets;

desPoints = new ArrayList(); 
desNoms = new ArrayList();
desJouets = new ArrayList();
// ou, en cas de collection typée :  List<Jouet>
desJouets = new ArrayList()<Jouet>;

desPoints.add(new Integer(-1));
desNoms.add("toto");
desJouets.add(new Jouet("Echec truc", 45, "verre", "noir"));

// On obtient le premier élément.
// que l'on doit typer ("caster") car par défaut le type
// des éléments d'une collection est Object.
Integer i = (Integer) desPoints.get(0);
String nom = (String) desNoms.get(0);
Jouet j = (Jouet) desJouets.get(0);
// ou en cas de collection typée
Jouet j = desJouets.get(0);

// obtient le nombre d'éléments dans la liste (un int)
int n = desJouets.size();

// supprime de la liste l'élément situé à la position 0
desJouets.remove(0); 

On vous fournit un programme principal (AppCompte.java) qui réalise un certain travail avec un objet de type IFGestCompte. Vous concevez et testez deux classes d'implémentation pour cette interface : GestComptesArray et GestComptesList.

Figure 8. Diagramme UML : relations entre interface et classes d'implémentation

Bonne programmation !

Éléments de solution : GestComptesArray.java, GestComptesList.java, AppCompte.java.

Nous voulons représenter la notion d'adresse physique d'une personne sous forme d'une classe. Pour cela nous avons retenu 3 propriétés : rue, ville et codePostal de type String, uniquement accessibles en lecture et écriture via des accesseurs (getter/setter).

Dans notre système d'information, une personne est caractérisée par un nom, un prénom et un login. On vous demande de concevoir une classe Personne respectant les règles de gestion suivantes :

Vous devez :

Toute personne connue par le système d'information doit disposer au moins une adresse. Cette relation peut se représenter graphiquement par le diagramme UML suivant :

Figure 9. Un personne dispose au moins d'une adresse

On vous demande de :

La programmation objet est basée sur quatre concepts fondamentaux que sont l'encapsulation, l'abstraction, le polymorphisme et l'héritage. Jusqu'à présent nous avons utilisé l'abstraction au travers du concept d'interface, conçu par encapsulation en cachant les attributs (private), redéfini plusieurs fois la méthode toString (polymorphisme) et hérité nos classes de la classe Object sans le savoir ! Nous présentons sommairement ces concepts dans cette section, et nous nous attarderons sur la notion d'héritage et de polymorphisme.

Toute classe en Java est construite sur le même modèle, défini par autre classe, dite racine. Cette classe s'appelle Object, une convention dans les langages objet. En terme d'héritage l'autoréférence n'est pas permise, la classe racine n'a donc pas de modèle (elle n'a pas de modèle, elles est le modèle).

Prenons un exemple : la classe Jouet et un programme de test :

public class TestHeritageJouet {
 static public void main(String[] args) {
   Jouet j = new Jouet("Echec truc", 45, "verre", "noir");
   System.out.println(j.toString());
 }
}

Maintenant compilons et exécutons le programme :

$ javac TestHeritageJouet.java

Ho!... le programme compile alors que je n'ai pas défini de méthode toString dans la classe Jouet !???

Voyons quel est le comportement de cette méthode dont j'ignore l'existence.

$ java TestHeritageJouet
Jouet@f5da06
$

Ah...

Comment se fait-il que l'appel de la méthode toString() soit acceptée ? Tout simplement parce que la classe Jouet hérite de la classe Object et que la méthode toString est définie dans cette classe. En fait écrire :

public class Jouet {
  ... 
}

Equivaut à :

public class Jouet extends Object {
  ... // comme avant
}

Donc, ne pas (re)définir dans la classe Jouet la méthode toString, c'est accepter son implémentation par défaut dans Object.

	Une définition de l'héritage [Bertrand Meyer]
	L'héritage est un mécanisme permettant de définir une classe par rapport à d'autres en ajoutant toutes leurs caractéristiques aux siennes.

Certains langages (comme C++, Eiffel) autorise la définition d'une classe à partir de plusieurs autres classes. Ceci s'appelle de l'héritage multiple. Bien que parfois très pratique cette possibilité peut poser problème lorsque des caractéristiques de classes héritées portent le même nom et dans le cas d'héritage répété.

Figure 10. Héritage multiple

=> Java supporte l'héritage multiple par l'intermédiaire des interfaces uniquement.

	Une définition de l'héritage simple
	On appelle héritage simple, une forme restreinte d'héritage par laquelle une classe ne peut avoir plus d'un parent (une seule super-classe directe).

=> Java ne reconnait que l'héritage simple entre classes.

UML représente cette relation orientée selon la spécialisation tout en la nommant généralisation... Exemple :

Figure 11. Représentation de l'héritage avec UML

La classe enfant pointe vers ses parents (ancêtres immédiats). Le trait est plein et la pointe de la flèche forme un triangle non rempli.

Ce diagramme montre que Jouet hérite des méthodes equals et toString de Object (vue partielle).

Nous pouvons percevoir la relation classeObject - classesHéritant (par exemple Object - Jouet) comme une relation orientée selon deux points de vue : généralisation et spécialisation.

UML préconise l'emploi des couples ancêtre/descendant et/ou parent/enfant (UML 1.3 p.94). Les ancêtres d'une classe sont ses parents et leurs ancêtres. Les descendants d'une classe sont ses enfants et leurs descendants.

Comme pour les méthodes héritées, par défaut le constructeur d'une classe hérite du comportement du constructeur par défaut. Si vous redéfinissez un ou plusieurs constructeurs (ce qui est souvent le cas), ces constructeurs devraient appeler le constructeur hérité en premier. Exemple, nous souhaitons étendre la notion d'adresse physique à celle d'adresse Web :

Figure 13. Une adresse Web est une sorte d'adresse

Voici le code source d'Adresse :

public class Adresse {
  /** Attributs */
  private String rue;
  private String ville;
  private String codePostal;
  /** Associations */

  /** Constructeur */ 
  public Adresse() {

  }

  public Adresse(String rue, String ville, String cp) {
    this.rue=rue;
    this.ville=ville;
    this.codePostal=cp;
  }

  public String getRue() {
    return this.rue;
  }
  public void setRue(String rue){
    this.rue=rue;
  }

  public String getVille() {
    return this.ville;
  } 
  public void setVille(String ville){
    this.ville=ville;
  }

  public String getCodePostal() {
    return this.codePostal;
  }
  public void setCodePostal(String cp){
    this.codePostal=cp;
  }

  public String toString(){
    String res="";
    res+="Rue : "    + this.rue;
    res+=", Ville : " + this.ville;
    res+=", Code postal : "  + this.codePostal; 
    return res;
  }
}

Un exemple d'adresseWeb

public class AdresseWeb extends Adresse {
  /** Attributs */
  private String mel;
  private String url;

  /** Constructeur */ 

  public AdresseWeb(String rue, String ville, String cp, String mel, String url) {
    super(rue, ville, cp);
    this.mel=mel;
    this.url=url;
  }

  public String getMel() {
    return this.mel;
  }
  public void setMel(String mel){
    this.mel=mel;
  }

  public String getUrl() {
    return this.url;
  } 
  public void setUrl(String url){
    this.url=url;
  }

  public String toString(){
    String res="";
    res+=", Mel : "    + this.mel;
    res+=", URL : " + this.url;
    return super.toString() + res;
  }
}

Le constructeur de la sous-classe appelle le constructeur de sa super classe en lui passant les valeurs des arguments adéquates :

 public AdresseWeb(String rue, String ville, String cp, String mel, String url) {
    super(rue, ville, cp);
    this.mel=mel;
    this.url=url;
  }

On remarquera que, dans le constructeur, le mot clé super n'est pas suivi du nom du constructeur hérité (contrairement aux méthodes).

Exemple de construction d'objets :

public class TestAdresse {
  static public void main(String[] args){ 
    Adresse a1 = new Adresse("1 allée de la noix", "Grenoble", "38000");
    Adresse a2 = 
      new AdresseWeb("3 rue moulin", "Melun", "77000",
                     "titi@labas.org","http://www.linux-france.org");
    System.out.println(a1);
    System.out.println(a2);
  }
}

Notez que nous aurions pu également déclarer la variable a2 de type AdresseWeb.

Pour illustrer les concepts objets, nous représenterons un zoo et les animaux qui l'habitent. On souhaite pouvoir interroger le nom d'un animal et de lui demander de dormir.

Figure 14. Diagramme de classes : un zoo est composé d'animaux

Comment représenter cette classification dans un langage objet comme Java ?

Déclarons une interface (une classe abstraite pure) :

public interface Animal {

    public String getNom();   
    public void dormir();

 } 

Puis les différentes classes d'animaux (Tigre, Lion et Ours) qui implémentent cette interface.

Classe Lion :

public class Lion implements Animal {
   //attribut
   private String nom;

   //constructeur   
   public Lion (String nom) {
      this.nom = nom;
   }

   @Override
   public String getNom() {
     return this.nom;
   }

   @Override
   public void dormir() {
     System.out.println("Moi, " +this.nom + ", je dors sur le ventre.");
   }
 } 

Classe Tigre :

public class Tigre implements Animal {
   //attribut
   private String nom;

   // constructeur   
   public Tigre (String nom) {
      this.nom = nom;
   }

   @Override
   public String getNom() {
     return this.nom;
   }

   @Override
   public void dormir() {
     System.out.println("Moi, " +this.nom + ", je dors sur le dos.");
   }
 } 

Classe Ours :

public class Ours implements Animal {
   //attribut
   private String nom;

   //constructeur
   public Ours (String nom) {
      this.nom = nom;
   }

   @Override
   public String getNom() { 
     return this.nom; 
   }

   @Override
   public void dormir() {
     System.out.println("Moi, " +this.nom + ", je dors dans un arbre.");
   }
 } 

Déclarons le zoo : Il est constitué d'une collection d'objets (ce sera des objets de type Animal bien-sûr), son seul attribut, d'un constructeur qui crée des animaux (une façon de ne pas construire un zoo vide), et d'une méthode demandant à chacun des animaux du zoo de s'endormir.

package org.vincimelun.zoo;
import java.util.*;

public class Zoo {
 private ArrayList<Animal> animaux; // collection d'animaux

 public Zoo(){
    // création de la collection
    this.animaux = new ArrayList<Animal>();
      // List est une interface (classe abstraite)
      // on ne peut donc pas créer directement
      // un objet de ce type. Vector ou ArrayList sont
      // des classes qui réalisent List. Ok.
      // A ce niveau, la liste est crée, mais vide.
 }

  /**
  *  Endormir tous les animaux du zoo
  */
  public void endormirLesAnimaux() {
    Animal animal;
    // déclaration d'une variable locale.

    // les indices d'une liste commencent à zéro.
 
    for (int i=0; i < this.animaux.size(); i++) {
      animal = animaux.get(i);
      animal.dormir();
    }

  }

  /** Permet d'ajouter un animal au zoo
  *  @param animal l'animal a ajouter
  */
  public void ajouteAnimal(Animal animal) {
    this.animaux.add(animal);
  }

 }

Créons une application qui crée un zoo avec quelques animaux, et endort ses animaux :

package org.vincimelun.zoo;

import java.util.Scanner;

public class GestionZoo {
 //attribut
 private Zoo zoo;

 //constructeur
 public GestionZoo() {
   this.zoo = new Zoo();
   zoo.ajouteAnimal(new Lion("seigneur"));
   zoo.ajouteAnimal(new Tigre("gros chat"));
   zoo.ajouteAnimal(new Ours("balou"));
   zoo.ajouteAnimal(new Tigre("sherkan"));
 }

 //méthode
 public void run() {
    Scanner clavier = new Scanner(System.in);
    String choix;
    do {
      System.out.println("0=Quitter, 1=Endormir : ");
      choix = clavier.next();
      if ("1".equals(choix)) {
         zoo.endormirLesAnimaux();
      }
    } while (!"0".equals(choix));     
  }//run

 public static void main(String[] args) {
    GestionZoo app = new GestionZoo();
    app.run();
 }
}

Exemple d'exécution

$ java GestionZoo
0=Quitter, 1=Endormir : 1
Moi, seigneur, je dors sur le ventre.
Moi, gros chat, je dors sur le dos.
Moi, balou, je dors dans un arbre.
Moi, sherkan, je dors sur le dos.
0=Quitter, 1=Endormir : 0
$

La classe Zoo ne dépend pas de classes d'implémentation d' Animal , elle dépend d'une abstraction (seulement de l'interface Animal ).

Nous avons pu ainsi nous concentrer, dans la classe Zoo , essentiellement sur des traitements génériques, comme endormir les animaux. De nouvelles espèces d'animaux pourront être conçues à posteriori , tout en profitant de traitements génériques développés bien avant elles !

Avant de pratiquer les exercices qui vous permettront de vérifier cela par vous même, nous nous arrêtons la notion de static.

Le qualificatif static déonte une approche non objet, car une propriété static n'est pas associé à une instance (un objet) mais à une classe.

Le caractère static d'un propriété (un attribut ou une méthode essentiellement) dénote une propriété directement liée au module de classe dans lequel elle est définie.

Dans ce contexte, une classe joue le rôle de static dans le sens librairie utilitaire. Dit autrement, une propriété static n'est pas liée à une instance, et c'est pourquoi il est toujours préférable de la préfixer explicitement par le nom de sa classe, afoin de souligner son caractère static. Exemple :

...

double x = Math.PI * 2;
double y = -x;
...
double z = Math.abs(x);

...
 

PI est un attribut de classe (pas un attribut d'instance !), tout comme abs est une fonction utilitaire du module java.lang.Math (le package java.lang étant le package par défaut, inutile de le déclarer).

La documentation de l'API nous confirme que ces propriétés sont bien libéllées static :

Figure 15. Exemple de propriétés liées à une classe (static)

Les propriétés static sont ordinairement initialisées par des instructions placées dans un bloc static, équivalent des construteurs d'objet. Les blocs static sont exécutés au chargement de la classe.

En mémoire il n'y a au plus qu'une "instance" d'un module de classe et 0 à n instances de cette classe.

Pour ajouter une nouvelle espèce, il suffit de concevoir une sous-classe de Animal et de définir sa méthode dormir() et getNom() , sans avoir besoin de modifier la méthode endormirLesAnimaux() .

Voici les fichiers : zoo.zip.

Bonne programmation !

Travail de synthèse. Vous êtes amené à concevoir une hiérarchie de classes d'après un cahier des charges. Vous tesez votre solution en instanciant des objets et en les placant dans une liste. Le programme réalise ces tâches en interaction avec l'utilisateur.

Dans un second temps (jeu du pendu), vous finalisez un programme (première étape) que vous faites évoluer (seconde étape). Vous devez pour cela rechercher par vous mêmes dans l'API, les possibilité offertes par les objets techniques proposés (Random et StringBuffer).

On souhaite simuler une gestion de parc de véhicules d'une société de BTP. Un véhicule est caractérisé par un numéro d'immatriculation, une date de mise en circulation, un kilométrage, un modèle et une marque.

Parmi les véhicules on distingue les véhicules utilitaires (ayant un poids total à vide, une charge maximale) des véhicules des techniciens commerciaux (attitré à un commercial).

On ne cherchera pas à concevoir une interface, mais une superclasse qui factorise les caractéristiques des véhicules utilitaires et commerciaux.

On veut programmer le jeu du pendu en java. Pour cela on désire concevoir une classe JeuPendu qui réalise la logique applicative du jeu. Une première analyse nous a permis d'identifier les opérations suivantes :

Voici une première implémentation, à compléter :

package org.vincimelun.pendu;

import java.util.*;
import java.io.*;

public class JeuPendu {

  // attributs privés
  /** le mot que l'utilisateur doit découvrir */
  private String leMotSecret;

  /** le mot secret pour l'affichage.
  * StringBuffer : un type String modifiable
  */
  private StringBuffer leMotCrypte;
 
  /** pour représenter en mémoire la liste des mots */
  private List lesMots;

  // constructeur
  public JeuPendu() throws java.io.IOException {
     lesMots = new ArrayList();
     chargerMots();
     tirerUnMotAuHasard();
  }

  // méthodes

  public void chargerMots() {
    ChargeurDeMots chargeur = new ChargeurBidon();  
      lesMots.add("programmation");
      lesMots.add("java");
      lesMots.add("informatique");
      lesMots.add("langage");
  }

  /**
  * tire "au hasard" un mot de la liste des mots
  * et l'affecte à this.leMotSecret puis
  * valorise this.leMotSecret en conséquence 
  * (de même longueur que leMotSecret mais formé avec des '#')
  */
  public void tirerUnMotAuHasard() {
    Random alea = new Random();
    // TODO
  }

  /**
  * rend true si leMotCrypté est découvert, 
  * rend false sinon
  */
  public boolean leMotEstDecouvert() {
    return false;
    // TODO
  }

  /**
  * regarde si le caractère reçu en argument fait partie
  * des caractères du mot secret. Si c'est le cas, toutes
  * les occurences de ce caractère sont découvertes dans
  * le mot crypté ET la fonction rend true, sinon false.
  */
  public boolean analyser(char c) {
     boolean res = false;

    // TODO

     return res;
  }

  /** 
  * retourne le mot crypté.
  */ 
  public String getLeMotCrypte() {
     return "####";
  }

  /**
  * retourne le mot secret.
  */
  public String getLeMotSecret() {
     return "TODO";
  }
}

Voici un exemple de programme principal :

public class JeuPenduTextUI {

  static public void main(String[] args){ 
   
    JeuPendu jeuPendu = new JeuPendu();

    while (!jeuPendu.leMotEstDecouvert()) {
       String choix =
         Console.lireClavier("Entrez un caractère suivi de ENTER : ");
       jeuPendu.analyser(choix.charAt(0));
       System.out.println(jeuPendu.getLeMotCrypte());
    }
  }
}

Soit la classe Truc

class Truc {
   private String nom;
   private double prix;

   public void setNom(String nom) {
     this.nom=nom;
   }
   public void setPrix(double prix) {
     this.prix=prix;
   }
}

Et le programme suivant :

public class Test {
  static public void main(String[] args) {
    Truc t1 = new Truc();
    // dans quel état est le truc
    // référence par t1 ? ===>  REPONSE A
    t1.setNom("bidule");
    t1.setPrix(12.3);
    // dans quel état est le truc t1 ? ===> REPONSE B
  }
}

Figure 16. Répondre aux questions A et B en complétant la figure ci-dessous (2 points)

Justifier vos réponses ( 2 points )

Comment faire pour initialiser un objet à sa création ? Fournir un exemple ( 3 points )

=>une solution ici : exemple de réponses aux questions

On vous demande de concevoir une classe nommée Voiture permettant au programme ci-dessous de fonctionner.

class Application {

  public void run() {

     Voiture v = new Voiture("Titine", 7);
       // création d'une voiture nommée "Titine" de 7 chevaux
     System.out.println(v.donneVitesse());
     // affiche : 0

     v.passeVitesseSuperieure();
       // passe la première vitesse

     v.passeVitesseSuperieure();
       // passe la seconde vitesse

     v.passeVitesseSuperieure();
       // passe la troisième vitesse

     v.retrograde();
       // retourne en deuxième

     System.out.println(v.donneVitesse());
       // affiche : 2

     System.out.println(v);
       // affiche : Titine, 7 chevaux
  }
  static public void main(String[] args){
     Application app = new Application();
     app.run();
  }
}

Remarque : Ne concevez que le strict minimum (attributs, constructeur et méthodes) nécessaire au fonctionnement du programme Application .

On souhaite ajouter un attribut maxVitesse , correspondant au nombre de vitesses disponibles pour une voiture donnée (par exemple 5).

On vous demande d'aménager la classe Voiture en 2 étapes :

On vous demande d'ajouter à la classe Voiture :

Afin de vérifier le bon fonctionnement de la méthode estPointMort() , on vous demande de compléter la classe TestVoiture , et plus particulièrement de :

=>une solution ici : Voiture.java

Aujourd'hui, il est courant qu'une application de gestion fournisse une interface graphique à ses utilisateurs. Il existe deux types d'interface graphique utilisateur IGU, plus connues sous le sigle GUI pour Graphic User Interface : interface Web et interface de type window. L'une est orientée page et l'autre fenêtre. Ces deux types d'interface ont en commun les caractéristiques suivantes :

Avec Java le développeur dispose en standard de deux catégories d'outils (en dehors de HTML) pour construire des interfaces, ce sont awt et swing .

Il existe une alternative à AWT et Swing, c'est un projet initié par IBM, qui prend le meilleur de ces deux technologies : SWT ( Standard Widget Toolkit ) - voir http://www.eclipse.org/swt/ ). Nous nous concentrons ici sur Swing , le plus utilisé du moment (2003).

Une application fenêtrée comporte généralement un menu. Nous vous proposons de construire une fenêtre d'application disposant d'un menu, que vous étendrez en exercice.

Nous choisissons de concevoir une fenêtre avec une barre de menus, munie d'une commande permettant de quitter l'application.

Figure 17. Maquette de l'application exemple

JFrame est une classe de la bibliothèque javax.swing qui représente une fenêtre graphique.

L'idée est de spécialiser la classe de base JFrame en une classe qui contient les composants dont vous avez besoin. Par exemple, nous désirons concevoir une fenêtre ayant une barre de menus.

Figure 18. Réutilisation par héritage

Nous ajoutons un constructeur et une méthode d'initialisation. Voici une traduction partielle en Java :

import javax.swing.*;  public class FenetreMenu extends JFrame {
  // attributs 
  ...
  // constructeur 
  public FenetreMenu() {
    // appel un constructeur de son parent, en passant 
    // une valeur de type chaîne de caractères  
    super ("Fenetre avec une barre de menus");
    // effet : donne un titre à la fenêtre 

    // permettre de quitter l'application lorsque l'utilisateur 
    // clique sur la croix en haut à droite de la fenêtre. 
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

    this.init(); 
      // voir plus bas pour des explications concernant cette méthode. 
  }
  ...
} 

On remarquera le mot clé super , qui permet d'appeler un des constructeurs de la classe parent (rappel : un constructeur n'est pas une méthode).

Nous devons maintenant créer et configurer les composants.

Nous pouvons réaliser cela soit directement dans le constructeur, soit dans une méthode d'initialisation spécialement conçue à cet effet ( init ) et appelée dans le corps du constructeur. Afin de ne pas alourdir le constructeur, nous créons la barre de menus et ses composants dans la méthode init . Extrait :

 private void init(){
   //on a besoin de créer une barre de menus
   JMenuBar menuBar;
   // et un menu
   JMenu menuFichier;
    
   //création de la barre de menus
   menuBar = new JMenuBar();

   //construisons le premier menu
   menuFichier = new JMenu("Fichier");
   menuFichier.setMnemonic(KeyEvent.VK_F);

   // création de la commande "quitter" (un JMenuItem)
   JMenuItem mnItemQuitter = new JMenuItem("Quitter",
                       KeyEvent.VK_Q);

   mnItemQuitter.setActionCommand("Quitter");

   ...

   }

Nous avons choisi d'utiliser un constructeur JMenuItem permettant de spécifier une touche d'accès rapide (un mnemonic ) spécifiée en second paramètre. Vous noterez que la valeur du paramètre est une constante static de la classe KeyEvent , VK voulant dire Virtual Key .

Nous spécifions le nom de l' "action" auquel le composant sera lié . C'est une simple information ( String ) que le composant transmet à ses "écouteurs" lorsqu'il est activé (ce point est détaillé plus bas dans ce document).

Remarque : L'aide en ligne est la principale ressource permettant de connaître les possibilités de configuration offertes par un composant.

La barre de menus contient des menus, et les menus contiennent des commandes ( menu item ).

Ces relations sont sous la responsabilité du programmeur. Comme on peut s'y attendre, les conteneurs disposent d'une méthode nommée add permettant l'ajout de composants.

private void init() { 
   ...
   // le menu Fichier contient la commande Quitter 
   menuFichier. add (mnItemQuitter);

   // on peut placer une barre de séparation pour 
   // séparer des groupes logiques de commandes. 
   // menu.addSeparator(); 
   
   // la barre de menus contient le menu Fichier 
   menuBar. add (menuFichier);
   // plus un autre menu bidon, pour l'exemple 
   menuBar. add (new JMenu("Un autre menu"));

   ...
 } 

Deux façons de faire :

En ce qui concerne la barre de menu, il existe exceptionnellement une méthode, nommée setJMenuBar , dédiée à son placement dans la fenêtre (une barre de menus est traditionnellement située sous la barre de titre) :

private void init() {
   ...
  // fournir à la fenêtre une barre de menus 
  this. setJMenuBar (menuBar);
  ...

  // donnons une largeur et une hauteur à la fenêtre 
  this.setSize(300,200);
} 

Ce qui donne :

Figure 19. FenetreMenu à l'exécution

Une fois notre composant créé (avec new ), placé et positionné dans la vue, il ne nous reste qu'à nous occuper de la gestion de ses événements.

Bon nombre de composants sont générateurs d'événements. Par exemple, lorsque l'utilisateur clique sur un bouton, celui-ci est capable de prévenir tout autre objet qui l'écoute. Pour qu'un objet puisse être prévenu de l'événement, il doit s'abonner au composant générateur de l'événement .

La fenêtre s'abonne à la commande du menu de cette façon :

mnItemQuitter. addActionListener (this); 

this fait référence à la fenêtre en cours (celle qui sera en exécution). Par cette instruction, on abonne la fenêtre en tant qu' écouteur ( listener ) des événements générés par mnItemQuitter .

Pour que le JMenuItem accepte la fenêtre en tant que gestionnaire de ses événements, la fenêtre doit être une sorte de ActionListener (un écouteur d'événement). Pour cela la fenêtre devra implémenter l' interface ActionListener .

public class FenetreMenu 
  extends JFrame implements ActionListener {
    ... 
}

... et donc donner corps à la méthode :

public void actionPerformed(ActionEvent evt) 

... seule opération déclarée par l'interface ActionListener . C'est l'objet de l'ultime étape.

C'est dans cette dernière étape que le développeur justifie pleinement son rôle...

Il doit programmer le comportement de l'application lorsqu'un événement survient.

Par exemple, ici l'utilisateur souhaite mettre fin à l'application.

...
public void actionPerformed(ActionEvent evt) {
  String action = evt.getActionCommand(); 
  if (action.equals("Quitter")) {
    System.exit(0); 
  }
}
... 

La méthode actionPerformed est automatiquement appelée lorsque l'utilisateur sélectionne la commande Quitter.

Puisqu'une fenêtre est généralement abonnée à plusieurs composants, la méthode actionPerformed , détermine l'action (méthode) devant être déclenchée. Pour cela, elle interroge la "command action", détenue par le paramètre.

Si la command action vaut "Quitter", alors, nous savons que mnItemQuitter est à l'origine de l'événement et nous mettrons fin à l'application.

   
import javax.swing.*;
import java.awt.event.*;

public class FenetreMenu extends JFrame implements ActionListener{
 
   // une constante (mot clé final)
   // c'est un moyen très pratique d'associer un écouteur d'événement
   // à un générateur d'événement.
   static final String ACTION_QUITTER = "Quitter";
 
   // constructeur
   public FenetreMenu() { 
     // appel un constructeur de son parent
     super("Ma première interface graphique");
        // effet : donne un titre à la fenêtre

     // l'application s'arrête lorsque la fenêtre est fermée.
     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
     // initialisation de la fenêtre
     init();
   }

 private void init(){
   //on a besoin de créer une barre de menus
   JMenuBar menuBar;
   // et un menu
   JMenu menuFichier;
   
   //création dela barre de menus
    menuBar = new JMenuBar();
   //construisons le premier menu
   menuFichier = new JMenu("Fichier");
   menuFichier.setMnemonic(KeyEvent.VK_F);
   menuFichier.getAccessibleContext().setAccessibleDescription(
        "Menu permettant d'accéder à une commande pour quitter");

   //création de la commande "quitter"
   JMenuItem mnItemQuitter = new JMenuItem(ACTION_QUITTER,
                        KeyEvent.VK_Q);
   mnItemQuitter.getAccessibleContext().setAccessibleDescription(
        "Quitter le programme");

   //mnItemQuitter.setActionCommand(ACTION_QUITTER);

   // le menu Fichier contient la commande Quitter   
   menuFichier.add(mnItemQuitter);
   //menu.addSeparator();    
   // la barre de menus contient le menu Fichier
   menuBar.add(menuFichier);
   JMenu autre = new JMenu("Un autre menu");
  autre.setMnemonic(KeyEvent.VK_U);
   autre.add(new JMenuItem("une commande",KeyEvent.VK_C));
   menuBar.add(autre);
   // on l'ajoute à la fenêtre
   setJMenuBar(menuBar);

   // la fenêtre est à l'écoute d'une action sur ce menu
   mnItemQuitter.addActionListener(this);

   setSize(300,200);     
  } 
     
  public void actionPerformed(ActionEvent evt) {
     String action = evt.getActionCommand();
   
     if (action.equals(ACTION_QUITTER)) {
       System.exit(0);
     }  
  }
   
  static public void main(String[] args) {
     JFrame f = new FenetreMenu();
     f.setVisible(true);
  }

}// FentreMenu   
  

Nous avons vu, au travers d'un exemple, les 6 étapes nécessaires à la conception d'une interface graphique en Java .

	Composants Swing et Awt
	Les composants swing sont reconnaissables par le fait que leur nom commence par un J, comme par exemple JButton (pour des boutons), JTextField (zone de texte pour la saisie), JLabel (simple zone de texte), JPanel (des panneaux), etc. En règle générale, vous ne devriez jamais mélanger dans une même interface, des composants AWT et SWING.

Action Command

Nous vous conseillons d'utiliser des CONSTANTES comme valeur des action command , comme par exemple ACTION_QUITTER. static final String ACTION_QUITTER = "Quitter"; Par convention, les constantes sont spécifiées en MAJUSCULE, et sont généralement déclarées static . Il est en effet inutile de dupliquer une constante pour chaque objet. Rappelons qu'une propriété static est liée à la classe elle-même et non à chacun des objets de la classe en particulier. Du coup, tous les objets d'une même classe partagent la même propriété (si celle-ci est déclarée static). C'est pourquoi, cette dernière est très souvent une constante ( final ).

Vous trouverez chez Sun un tutoriel dédié à l'utilisation des menus. Vous apprendrez comment placer des cases à cocher, des sous-menus, des images dans un menu, c'est ici http://java.sun.com/docs/books/tutorial/uiswing/components/menu.html .

Nous nous proposons de concevoir une version graphique du jeu du pendu. Nous ne redéfinirons que la partie interaction avec l'utilisateur, la logique du jeu restant la même.

ref : http://java.sun.com/docs/books/tutorial/uiswing/layout/using.html

Un "gestionnaire de positionnement" (Layout manager) est un système qui détermine la taille et la position de composants. Par défaut, chaque conteneur a un layout manager - un objet qui gère la taille et la position des composants à l'intérieur du conteneur. Un composant peut tenter de gérer sa taille et sa position, mais au final, c'est le layout manager qui aura le dernier mot.

Les gestionnaires de positionnement les plus courants sont : BorderLayout , FlowLayout , GridLayout . Il en existe d'autres : BoxLayout , GridBagLayout ...

Lorsqu'un programme utilise des gestionnaires de positionnement, en cas de changement de dimension du conteneur principal (la fenêtre par exemple), les positions de composants, et souvent leur taille également, seront modifiées.

Bon nombre de composants d'IHM peuvent contenir une image, c'est le cas des menus, des boutons et des listes.

Java propose en standard la classe ImageIcon, qui, comme son nom l'indique, est chargée de représenter en mémoire une image. Un objet ImageIcon peut être instancier via une URL, comme l'indique un de ses constructeurs :

public class ImageIcon ... {
...
 /** constructeur
 *  Création d'un ImageIcon à partir d'une URL spécifiée.
 */
 ImageIcon(URL location) { ... }
...
}

Nous utiliserons donc ce constructeur très générique. Exemple de chargement d'une image :

 ...
 java.net.URL iconURL = 
    ClassLoader.getSystemResource("images/image_1.jpg");
 ImageIcon icon = new ImageIcon(iconURL);
 ...

Notez l'utilisation de la méthode static getSystemResource, une méthode de ClassLoader qui utilise le classpath pour trouver le fichier (nom de l'image), ainsi nous n'avons pas à spécifier le nom complet du chemin menant au fichier (the fully qualified path name).

Le plus simple pour afficher une image est d'utiliser un JLabel. En effet, ImageIcon n'est pas un composant visuel.

C'est donc un JLabel qui fera office de "conteneur" responsable de l'affichage de l'image. Un JLabel dispose d'une méthode setIcon tout à fait adaptée à nos besoins.

Voici comment nous pouvons le configurer pour les besoins de l'application.

   ...
   // création d'un tableau pouvant contenir 8 images
   ImageIcon[] images = new ImageIcon[8];

   ...

   java.net.URL iconURL = 
     ClassLoader.getSystemResource("images/image_1.jpg");
   images[0] = new ImageIcon(iconURL);
   
   ...

   // Création d'un label pour l'affichage d'une image.
   iconLabel = new JLabel();    
   iconLabel.setHorizontalAlignment(JLabel.CENTER);
   iconLabel.setVerticalAlignment(JLabel.CENTER);
   iconLabel.setText("");
     
   ...
   
   // affiche la première image du tableau images
   iconLabel.setIcon(images[0]);

   ... 

Voici une maquette de l'IHM du jeu :

Figure 23. Détails de conception de l'IHM

Il existe deux grands types de format de fichier : "texte" et "binaire". Est qualifié de "fichier texte", tout fichier composé exclusivement de caractères dédiés ou compatible avec une impression standard, un affichage en mode console.

Par exemple un code source est un fichier texte, par contre un fichier MS World 2000 n'est pas un fichier texte, car il comporte des caractères non affichables (information sur la police, objets incorporés, et autres informations plus ou moins documentées par l'éditeur)

ATTENTION : On appelle format de fichier, la structure de son contenu , et non la valeur de son extension . Un fichier portant le nom de "document.txt" est certainement un fichier de type texte, pouvant être lu par un éditeur quelconque, mais rien ne le garantit ! L'inverse est également vrai : un fichier nommé "document.jpg" est certainement un fichier de type binaire (ici une image), mais ce n'est qu'une convention.

Le format texte

Contrairement au fichier binaire, le contenu d'un fichier texte est constitué de valeurs correspondant, pour la majorité, à des codes de caractères affichables (plus certains interprétables comme \n (fin de ligne), \t (tabulation)...).

Les fichiers au format texte sont le plus souvent structurés soit par :

Exemple document.txt

[kpu@kpu seance-15]$ cat document.txt
Bonjour,
futur informaticien,
nous vous souhaitons
bonne aventure.

Version hexadécimale

[kpu@kpu seance-15]$ hexdump document.txt
0000000 6f42 6a6e 756f 2c72 660a 7475 7275 6920
0000010 666e 726f 616d 6974 6963 6e65 0a2c 6f6e
0000020 7375 7620 756f 2073 6f73 6875 6961 6f74
0000030 736e 0a20 6f62 6e6e 2065 7661 6e65 7574
0000040 6572 0a2e
0000044

Version caractère

[kpu@kpu seance-15]$ hexdump -c document.txt
0000000   B   o   n   j   o   u   r   ,  \n   f   u   t   u   r       i
0000010   n   f   o   r   m   a   t   i   c   i   e   n   ,  \n   n   o
0000020   u   s       v   o   u   s       s   o   u   h   a   i   t   o
0000030   n   s      \n   b   o   n   n   e       a   v   e   n   t   u
0000040   r   e   .  \n
0000044
 

A titre d'information, il existe un outil bien pratique, nommé file , qui analyse le contenu d'un fichier pour en extraire des informations sur son type. Exemple :

$ file document.txt
document.txt: ASCII text

$ file zoo.png
zoo.png: PNG image data, 446 x 182, 8-bit/color RGB, non-interlaced

$ file TestGE.java
TestGE.java: UTF-8 Unicode Java program text

Java considère un fichier comme un cas particulier d'un flux ( stream ).

	Flux
	Un flux est une séquence de caractères ou d'octets voyageant d'une origine vers une destinaton. Un programme qui écrit dans un fichier est à l'origine d'un flux (ou producteur ). Un programme qui lit le contenu d'un répertoire, d'un fichier, ou de toute autre ressource est considéré comme une destination (ou consommateur ), qui reçoit progressivement le contenu du flux.

Java, pour des raisons pratiques, propose deux types de flux : les InputStream/OutPutStream et les Reader/Writer . Les premiers ( Stream ) sont utilisés pour la gestion de fichiers dit binaires, les Reader/writer sont spécialisés pour la gestion de flux de caractères UNICODE (16-bit) et Local (8-bit).

Notez qu'il existe de nombreuses classes de flux spécilisées (plus de 70 !), et certaines sont dans des packages utilitaires comme java.util.zip . Sachez également qu'il existe des passerelles pour passer d'une logique de flux d'octets à celle de flux de caractères (16-bit), ce sont les classes : InputStreamReader pour convertir un InputStream en un Reader et OutputStreamWriter pour convertir un OutputStream en un Writer .

Vous trouverez ici, une traduction d'un extrait d'un tutorial chez Sun , présentant la hiérarchie des classes I/O.

Connaître les caractéristiques d'un fichier

Les caractéristiques d'un fichier peuvent être interrogées en utilisant la classe java.io.File , qui est présentée comme une représentation abstraite d'un fichier et d'un chemin de répertoire . C'est cette classe qui connait par exemple le symbole de séparation des chemins ( pathSeparatorChar ) (par exemple : sous Unix et ; sous MSWindows ). Pour en savoir plus sur cette classe, retrouvez l'API API File et des exemples ici :http://java.developpez.com/faq/java/?page=langage_fichiers

Les flux de caractères sont associés à des classes spécialisées dans la lecture des données ( reader ) et dans leur écriture ( writer ).

Les principales étapes de gestion d'un fichier sont :

1 - Ouverture d'un fichier

// ouvre un fichier en lecture
FileReader fr = new FileReader(nomFic);

// passe par un buffer pour simplifier la lecture du fichier
BufferedReader buf = new BufferedReader(fr);

2 - Exploitatin en lecture séquentielle du fichier

// déclaration d'une chaîne de caractères
// afin de stocker la chaîne courante
// à chaque tour dans la boucle.
String ligne;

// lecture de la première ligne du fichier
ligne = buf.readLine();

// tant que la fin de fichier n'est pas atteinte
while (ligne != null) {
   // faire quelque chose avec ligne
   // ...
   // à la fin du corps de la boucle, lire la ligne suivante
   ligne = buf.readLine();
}
   

3 - Fermeture fichier

fr.close(); 

1 - Ouverture d'un fichier en écriture

// ouvre un fichier en écriture (1ère version)
FileWriter out  = new FileWriter(nomFic);

/* autre version avec choix du jeu de caractères 
  (ici ISO Latin Alphabet No. 1 - ISO-LATIN-1)
OutputStreamWriter out = 
  new OutputStreamWriter(new FileOutputStream(nomFic), "ISO-8859-1");
*/

// passe par un buffer pour simplifier l'écriture dans le fichier
PrintWriter pw = new PrintWriter(out);

Exemple d'écriture dans le fichier (relativement à la position courante dans le fichier)

// déclaration d'une chaîne de caractères
// afin de stocker la chaîne à écrire
String ligne = "coucou";
// écriture de la ligne dans le fichier
pw.write(ligne);

Exemple de fermeture fichier

pw.close(); 

Ecrire un programme qui recoit un nom de fichier texte en argument du main et qui affiche :

Exploitation d'un fichier CSV, et transformation en XML : http://www.linux-france.org/prj/edu/archinet/DA/tpXML/

On souhaite gérer un fichier de contacts (contacts.txt)

Une fiche contact est caractérisée par un nom, prénom, adresse rue, code postal, ville, pays, tel et email.

Les caractéristiques d'une fiche ont placées sur la même ligne. S'il y a 2 fiches, alors le fichier contiendra 2 lignes, et ainsi de suite. Exemple :

Durand;Michel;35 rue du lavoir;38000;Grenoble;France;0123456789;mdurand@nullepart.com
Valerian;Denise;250 avenue Louise;1050;Bruxelles;Belgique;00 32 (0)2 345 67 89;vale@belgeunefois.com

On souhaite produire une application permettant dans un premier temps de présenter, une à une, les fiches contact du fichier. Voici une maquette :

Figure 25. Maquette gestion de fiches Contact

Première analyse. Nous concevrons trois classes : l'IHM (Interface Homme Machine) - une JFrame - , un contrôleur ( NavigatorContactFic ) qui détient une collection d'objets Contact , et une classe Contact représentant la structure type d'une fiche contact.

Figure 26. Diagramme de classes de l'application

La relation NavigatorContactFic --> Contact dénote une liste nommée lesContacts (un objet de type ArrayList ou Vector ). C'est un attribut privé de la classe NavigatorContactFic . Cet attribut est créé et valorisé dans le constructeur de NavigatorContactFic .

Donc, à la création, le fichier est lu et son contenu placé en mémoire sous forme d'une collection d'objets de type Contact.

Figure 27. Diagramme de communication : Demande de visualisation de la fiche suivante

La fonction première d'une boîte de dialogue est de paramétrer un service offert par le système. Cela peut être, par exemple, une fonction d'exportation de données, une sauvegarde, ou une confirmation de suppression.

Java propose en standard des fonctions de boîte de dialogue : tutoriel d'utilisation des boîtes de dialogue de JOptionPane.

Nous présentons ici une utilisation de la classe JDialog.

Nous souhaitons ajouter au programme de gestion de contacts, la possibilité d'ajouter un contact, vous programmerez la modification et la suppression en exercice.

Nous commençons par ajouter une commande accessible par un item de menu.

Figure 28. Menu ajouter un contact

Et le code associé :

// attributs de classe
static final String ACTION_AJOUTER_CONTACT = "AjouterContact";
...

//... dans init
...
JMenu menu = new JMenu("Contacts");
menu.setMnemonic(KeyEvent.VK_C);
JMenuItem mnAjouterContact = new JMenuItem(ACTION_AJOUTER_CONTACT,
   KeyEvent.VK_A);
mnAjouterContact.setActionCommand(ACTION_AJOUTER_CONTACT);
mnAjouterContact.addActionListener(this);
menu.add(mnAjouterContact);
...
menuBar.add(menu);
...

Ensuite, programmons l'événement. L'algorithme est simple, et facilement généralisable :

1: création d'un objet Contact
2: création d'un objet boîte de dialogue. On lui passe
   la référence à notre objet Contact nouvellement créé.
3: affichage de la boîte de dialogue en MODE MODAL
4: après la fermeture de la boîte de dialogue, on
   l'interroge afin de savoir s'il est utile de
   poursuivre l'action. 
4.1 : l'utilisateur n'a pas abandonné, on exploite
   l'objet dont la référence a été passée en argument de
   la boîte de dialogue. Ceci se passe en deux temps :
   4.1.1 : Demande de confirmation
   4.1.2 : Exécution ou non exécution de l'opération
4.2 : l'utilisateur a abandonné : aucune action n'est entreprise.

En voici une traduction :

if (action.equals(ACTION_AJOUTER_CONTACT)) {
   Contact c = new Contact("", "");
   DailogAjouterContact dac = new DailogAjouterContact(this, c);
   dac.setVisible(true);
   // à ce niveau d'étape, l'utilisateur a fermé la boîte de dialogue
   if (!dac.isCancel()) {
     int res = JOptionPane.showConfirmDialog(null,
       "Confirmez-vous la création ?", "Confirmation",
        JOptionPane.YES_NO_OPTION);
     if (res == JOptionPane.OK_OPTION) {
       JOptionPane.showMessageDialog(this, "L'objet " + c
           + " va être sauvegardé.");
       // faire quelque chose
     }
   }
   // else aucune action
}

Nous avons vu qu'elle reçoit en argument un objet Contact. De plus notre boîte de dialogue sera modal, c'est à dire qu'elle focalise les saisies utilisateur de l'application (elle garde le focus). Le constructeur de notre boîte appelera un des constructeurs de JDialog, classe dont elle hérite.

public class DailogAjouterContact extends JDialog implements ActionListener {
  private Contact contact;
  private boolean cancel;
...
 public DailogAjouterContact(JApplication app, Contact c) {
    super(app, "Ajouter un contact", true);
      // le premier argument référence la fenêtre à qui
      // la boîte de dialogue prend le focus.
      // le deuxième rag. est le titre de la boîte de dialogue.
      // le dernier arg. est un booléen pour activer le comportement
      // modal de la fenêtre.
    contact = c;
    cancel = true;
    init();       
    setSize(300,100);
    setLocationRelativeTo(null); 
     // centre la boîte
 }

Nous lui ajoutons quelques JTextField et deux boutons : un pour valider et un autre pour annuler :

  ...
   private JTextField nom;
   private JTextField prenom;
   private JButton btCancel;
   private JButton btValider;
  ...

La création et le positionnement sont réalisés dans le corps de la méthode init:

  private void init() {       
      JPanel panel = new JPanel();
      panel.setLayout(new GridLayout(2,0));
      panel.add(new JLabel("Nom"));
      panel.add(new JLabel("Prénom"));
      
      getContentPane().add(panel, BorderLayout.WEST);
      panel = new JPanel();
      panel.setLayout(new GridLayout(2,0));
      nom = new JTextField("Nom : ");
      prenom = new JTextField("Prénom : ");
      
      nom.setText(contact.getNom());
      prenom.setText(contact.getPrenom());
      
      panel.add(nom);
      panel.add(prenom);
      getContentPane().add(panel, BorderLayout.CENTER);
      btValider = new JButton("Valider");
      btCancel = new JButton("Abandonner");
      btValider.setActionCommand(ACTION_VALIDER);
      btCancel.setActionCommand(ACTION_CANCEL);
      btValider.addActionListener(this);
      btCancel.addActionListener(this);
      
      panel = new JPanel();
      panel.add(btValider);
      panel.add(btCancel);
      getContentPane().add(panel, BorderLayout.SOUTH);      
    }

Ce qui donne :

Figure 29. Boîte de dialogue ajouter un contact

La propriété cancel étant positionnée à vrai (true) dans le constructeur, la seule chose à laquelle nous devons faire attention est la validation.

La boîte de dialogue ne devrait retourner qu'un objet valide à l'appelant. La valeur de la propriété cancel sera placée à false, QUE SI les données saisies par l'utilisateur sont conformes. C'est alors que nous donnons les valeurs des données saisies (ou proposées) par l'utilisateur aux accesseurs de l'objet Contact pris en charge par la boîte de dialogue.

public void actionPerformed(ActionEvent e) {
  String action = e.getActionCommand();
  if (action.equals(ACTION_VALIDER)){

    if (verification()) {
      cancel = false;
      contact.setNom(nom.getText());
      contact.setPrenom(prenom.getText());
      setVisible(false);
    }
    else {
      JOptionPane.showMessageDialog(this, "Erreur de saisie");
    }
  }

  else if (action.equals(ACTION_CANCEL)){
      setVisible(false);
  }       
}

La méthode verification vérifie que le nom et le prénom ne soit pas vide :

/**
 * @return true si le nom et prenom sont renseignés
*/
private boolean verification() {
  return (!"".equals(nom.getText().trim()) &&
          !"".equals(nprenom.getText().trim()));
}

La méthode isCancel ne fait que retourner la valeur de la variable privée cancel:

public boolean isCancel() {
  return cancel;
}

Nous venons de présenter un façon simple, mais très facilement personnalisable, de concevoir et de programmer une boîte de dialogue héritant de JDialog.

Nous avons personnalisé le constructeur afin de fournir un objet Contact à la boîte de dialogue. L'action de validation (un bouton) valorise l'objet Contact à partir des composants de l'interface.

Les fichiers : gestionContacts.tgz.

Les programmes Java disposent d'un pont logiciel pour s'interfacer avec un SGBDR, représenté par une API nommé JDBC ( Java Database Connectivity ). Par l'intermédiaire de JDBC, vous pouvez programmer des créations de tables, des insertions et modifications de valeurs et aussi des requêtes, le tout dans un contexte de transactions avec gestion d'exceptions.

L'API JDBC se trouve dans java.sql et les pilotes doivent implémenter l'interface java.sql.Driver.

Il existe quatre types de pilotes jdbc :

Les éditeurs de SGBDR proposent leurs propres pilotes JDBC.

Figure 30. Exemple de pilotes

L'interaction à un système de gestion de base de données réquiert en général au moins quatre étapes :

Nous présentons ci-dessous chacune de ces étapes.

On charge généralement le pilote par son nom. Ci-dessous, un exemple de programme chargeant un pilote défini sous forme de chaînes de caractères.

final String driverPostgreSql = "jdbc.postgresql.Driver"; 
       // driver PostgreSql : http://jdbc.postgresql.org/
final String driverOdbc       = "sun.jdbc.odbc.JdbcOdbcDriver"; 
       // driver odbc inclus dans le jdk 
       // (pratique sous Windows pour SQL Server, Access...)
final String driverHsql       = "org.hsqldb.jdbcDriver"; 
       // driver Hypersonic SQL
final String driverMySQL = "com.mysql.jdbc.Driver";
     // driver MySQL : http://www.mysql.com/products/connector/

String driver = driverHsql;

Class.forName(driver).newInstance();  
  // Autochargement du driver

Les pilotes JDBC sont à télécharger directement chez les éditeurs de SGBDR. Par exemple :

Puis à rendre accessible dans le chemin des classes (classpath). Sous Eclipse, vous pouvez créer un répertoire bin dans lequel vous placez le ou les drivers en question (un fichier ayant l'extension .jar) que vous ajouter ensuite à votre buildpath (via un clic droit...)

Une fois le driver chargé en mémoire, nous obtenons (si tout va bien) une connexion via la méthode de classe getConnection() de DriverManager

 Connection con = DriverManager.getConnection(URL, "user", "passwd");
 //  URL : url de connexion de la forme jdbc:sous-protocole:sous-nom
 //     sous-protocole:identification du pilote
 //     sous-nom  :  informations nécessaires au pilote
 //                  pour la connexion (chemin, port, nom) 
 // "passwd" : Mot de passe 
 // "user"   : Nom de l'utilisateur référencé par la base 

Exemple

//final String driver = "org.hsqldb.jdbcDriver";
// final String url = "jdbc:hsqldb:/home/kpu/hsql/refuge/refuge"; 
final String driver = "com.mysql.jdbc.Driver";
  // driver disponible ici : http://www.mysql.com/products/connector/
final String url      = "jdbc:mysql://localhost/refuge";
final String user     = "sa";    
final String password = "secret"; 
Connection con = null;
try {
  Class.forName(driver).newInstance();
  con = DriverManager.getConnection(url, user, password); 
  ... 

L'exécution d'une requête SQL s'effectue via un objet de la classe java.sql.Statement . C'est l'objet Connection qui nous fournira une référence d'objet Statement (à ne pas instancier directement ). Exemple :

 Statement stat = con.createStatement();  

L'accès aux données peut être sensible ou non aux accès concurrents et la navigation dans le modèle peut être possible ou non (forward only).

 Statement stat = con.createStatement();  
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                     ResultSet.CONCUR_READ_ONLY);

// autre exemple, une source de données insensible aux changements concurrents
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
                                     ResultSet.CONCUR_READ_ONLY);

plus d'info ici

On distingue deux types de requêtes : requête d'interrogation et de mise à jour.

Pour des raisons d'efficacité (compilation de la requête côté sgbdr) et de souplesse de construction des requêtes paramétrés (concaténation et placer les valeurs entre quotes ou non), le développeur peut utiliser un objet PreparedStatement pour envoyer des instructions SQL.

L'exemple suivant illustre les deux approches (source : tutoriel jdbc) :

 
Code Fragment 1:

    String updateString = "UPDATE COFFEES SET SALES = 75 " + 
                          "WHERE COF_NAME LIKE 'Colombian'";
    stmt.executeUpdate(updateString);

Code Fragment 2:

    PreparedStatement updateSales = con.prepareStatement(
            "UPDATE COFFEES SET SALES = ? WHERE COF_NAME LIKE ? ");
    updateSales.setInt(1, 75); 
    updateSales.setString(2, "Colombian"); 
    updateSales.executeUpdate():

La deuxième version, bien que plus verbeuse, nous permet de mieux structurer nos instructions et de ne pas gérer la présence ou non de quotes encadrantes.

On constatera l'usage de méthodes setXXX selon le type de l'argument SQL attendu, et que l'appel à executeUpdate se fait sans argument.

De plus, une requête paramétrée est toujours compilée par avance côté SGBDR, ce qui accélère son traitement, surtout en cas d'appels répétés, dans une boucle par exemple.

Le programme ci-dessous utilise une base nommée Refugedb .

Cette base de données contient une table nommée ANIMAL; voici un script de création :

  CREATE TABLE ANIMAL (
    id INTEGER PRIMARY KEY, 
    categorie VARCHAR NOT NULL, 
    nom VARCHAR, race VARCHAR, 
    sexe CHAR, 
    date_nais DATE, 
    id_proprio INTEGER, 
    present BIT
  )
  INSERT INTO ANIMAL 
    VALUES (1,'CRM', 'kiki','berger','M','2000-2-21',21,false)
  INSERT INTO ANIMAL 
    VALUES (2,'CRM','rex','caniche','M','1996-12-2',11,true)
  ...
  

Lorsque l'on accède à une base de données, une gestion des exceptions s'avère nécessaire car de multiples problèmes peuvent survenir : le pilote ne peut être chargé (introuvable ?), connexion refusée, requête SQL mal formée... Voici l'exemple complet.

 1  import java.sql.*;
 2  
 3  public class TestAnimal {
 4    public void test() {
 5      final String driver = "com.mysql.jdbc.Driver";
 6      final String url = "jdbc:mysql://localhost/Refugedb";
 7      final String user = "sa";
 8      final String password ="";
 9          
10      Statement  st  = null;
11      Connection con = null;
12      ResultSet  rs  = null;
13      String    sql  = "";
14      try {
15         Class.forName(driver).newInstance();
16         con = DriverManager.getConnection(url, user, password);
17         st  = con.createStatement();
18         sql = "SELECT * FROM ANIMAL";
19         rs  = st.executeQuery(sql);
20         System.out.println("ID\tTYPE\tNOM\t\tRACE\t");
21         while (rs.next()) {
22           System.out.print(rs.getInt(1)+"\t");
23               // ATTENTION, les indices commencent à 1.
24           System.out.print(rs.getString(2)+"\t");  
25           System.out.print(rs.getString("nom")+"\t\t");  
26           System.out.println(rs.getString("race")+"\t");
27         }//while  
28       }
29       catch (ClassNotFoundException e) {
30          System.err.println("Classe non trouvée : " + driver );
31       }
32       catch (SQLException e) {
33          System.err.println("SQL erreur : "+
                 sql + "  " + e.getMessage());
34       }
35       catch (Exception e) {
36          System.err.println("Erreur : "+ e);
37       }
38   
39       finally {
40          try { if (con != null) { con.close(); } }
41          catch (Exception e) { System.err.println(e); }
42       }
43    }
44    static public void main(String[] arg) {
45       TestAnimal app = new TestAnimal();
46       app.test();
47    }
48  }

Comatibilité entre type Java et SQL, un "x" signifie que la méthode getXXX est compatible avec le type SQL correspondant.

Figure 31. Extrait de la documentation de l'API Java by Sun

Il est possible, grâce aux méthodes setXXX de mettre à jour des données sans utiliser d'ordres SQL.

Les méthode updateXXX prennent 2 arguments, le premier est la référence à la colonne concernée (index ou nom de colonne) et le second représente la nouvelle valeur à assigner au tuple courant.

   ...
   String nom = rs.getString("nom"); // kiki
   rs..updateString("race", nom.toUpperCase());
   System.out.print(rs.getString("nom")); // KIKI
   ... 
   ... [autre modification]
   ....
   rs.updateRow();  // répercution dans la base de données
   // ou rs.cancelRowUpdates()
         
   ...   
   
 

La suite sur Sun Guide JDBC...

Avec l'API JDBC, une transaction est pilotée par l'objet Connection.

Par défaut une instruction SQL est exécutée comme une transaction individuelle immédiatement validée dans la base de données.

Ce mode par défaut peut être modifié via la méthode setAutoCommit() afin de regrouper plusieurs instr. SQL, ceci est représenté par le pseudo-code suivant :

 Si la transaction est composé d'1 seule instr. SQL Alors
   Si laConnection.getAutoCommit() == false Alors
 	 laConnection.setAutoCommit(true)
   FSi
   Une instr. SQL => une transaction automatique
Sinon
   laConnection.setAutoCommit(false)
   [série d'instr. SQL]
   Si aucune erreur Alors
      laConnection.commit() 
   Sinon
      laConnection.rollback()
   Fsi
Fsi
 

Exemple de code Java avec contrôle simple sur exception :

  // Permettre le regroupement d'instructions SQL
    con.setAutoCommit(false);
    try {
      Statement stmt = con.createStatement();
      stmt.executeUpdate(
        "UPDATE COMPTE_A SET SOLDE = (SOLDE - 1000) WHERE IDCLT = 5");
      stmt.executeUpdate(
        "UPDATE COMPTE_B SET SOLDE = (SOLDE + 1000) WHERE IDCLT = 5");

      con.commit();
      out.println("Ordre de transfert réussi");
    }
    catch (Exception e) {
      // une erreur est survenue, retour en arrière 
      try { 
        con.rollback();
        out.println("Ordre de transfert annulé");
      }
      catch (Exception ignoree) { } 
    }
 

En exercice : proposer une autre version Java avec contrôle plus fin qui exploite la valeur de retour de la méthode executeUpdate.

HSQLDB est un petit système de gestion de bases de données écrit en Java, initialement développé par Thomas Mueller et hsqldb Group .

HSQLDB est très souvent utilisé pour des démonstrations, du maquettage et de petites applications ayant besoin de s'interfacer avec un système de gestion de bases de données relationnel (SGBDR). Sa taille (<300 ko), son prix (gratuit), sa portabilité (Java) et sa rapidité de mise en oeuvre sont ses principaux atouts.

Ajoutons à ces qualités la relation privilégiée de ce système avec le langage Java, et nous avons une solution bien adaptée à un apprentissage de la programmation, portable sous Windows comme sur Linux.

Il existe un projet de portage d'HSQLDB sur une autre plateforme, voir wikipedia

Téléchargez HSQLDB à l'adresse suivante http://hsqldb.sourceforge.net .

Décompressez le fichier dans un répertoire prévu à cet effet (ex: hsqldb).

Pour utiliser hsqldb, vous pouvez :

La base de données que nous allons créer est celle qui correspond à notre fichier Clients .

Nous allons donc créer notre base de données. Pour cela nous utilisons Database Manager, un des outils livrés avec hsqldb (package org.hsqldb.util ).

Vous accédez alors à la fenêtre suivante, permettant de réaliser des opérations SQL sur la base.

Figure 33. Database Manager (./runManager.sh)

Vous avez à votre disposition un fichier ( creercltsdb.sql ) permettant de créer la table client et de la valoriser avec quelques données.

Une fois le fichier rapatrié, ouvrez-le via la commande File->Open Script... de l'application. Le contenu est alors automatiquement placé dans la zone d'édition de Database Manager.

Figure 34. Database Manager (importation d'un script)

Le fichier creercltsdb.sql contient des ordres de création de tables, ainsi que des insertions. Il ne vous reste plus qu'à déclencher l'interprétation des ordres SQL en cliquant sur le bouton Execute.

Figure 35. Database Manager (après exécution)

Vérifiez le bon déroulement de l'opération en sélectionnant View -> Refresh Tree . La table CLIENTS doit apparaître dans l'arbre de gauche.

Figure 36. Database Manager (la table CLIENTS est visible)

... et en exécutant l'ordre de sélection de tous les tuples de la table clients .

Figure 37. Database Manager (select * from clients;)

Nous avons vu comment créer et utiliserune base de données pour hsqldb.

Avec Database Manager nous disposons d'un bon outil visuel pour gérer les données d'une base.

	Bon à savoir
	Vous trouverez dans le répertoire doc le fichier hSqlSyntax.html . Il contient la syntaxe SQL compatible avec hsqldb. Le répertoire demo contient le fichier TestSelf.txt qui fourmille d'exemples d'ordres SQL compatibles avec hsqldb. hsqldb.jar tient sur une disquette, n'hésitez pas à le transporter chez vous ! (que vous soyez sous Windows ou Linux).

Ce projet est à rendre à la rentrée de septembre 2005 pour les étudiants prenant l'option DA, au plus tard pour le 09/septembre/2005.

Le projet sera composé de deux parties : rapport et code