ThermoLux - Projet IG3 2009

JBa EIA-FR Projet_IG3_Elements_Programmation.docx 13.02.2013 1
Projet Informatique
Éléments de programmation
E2
EIA-FR
J. BAPST
13.02.2013
INTRODUCTION
Ce document rassemble différentes informations complémentaires qui peuvent s'avérer utiles lors du
développement d'applications en Java. Ces informations sont accompagnées d'extraits de code qui
illustrent le principe de fonctionnement et dont vous pouvez vous inspirer (en les adaptant au
contexte de votre application).
CONSULTATION DE LA DOCUMENTATION DE LA PLATE-FORME JAVA
La documentation des API (Application Programming Interface) de la plate-forme Java peut être
consultée de différentes manières :
 Dans Eclipse : de manière contextuelle en pressant sur Shift+F2
Par défaut Eclipse consulte la documentation disponible en ligne sur le site de Sun (une
connexion internet est nécessaire dans ce cas) mais il est possible d'indiquer un autre
emplacement, par exemple si la documentation a été préalablement installée localement.
Consulter le document "Eclipse 4.2 : Installation et configuration" accessible depuis la page
web du cours ou sur Cyberlearn pour configurer l'accès contextuel à la documentation de la
plate-forme Java (API) et l'installation locale de cette documentation.
 Sur le Web : site de Sun (la référence) ou d'autres portails de documentation.
Hyperliens disponibles sur la page web du cours ou sur la page des liens :
jacques.bapst.home.hefr.ch/links
Dans sa configuration standard, la version 4.2 d'Eclipse utilise la version 1.7 de la plate-forme Java.
C'est donc la documentation de cette version qu'il faut consulter.
Il est important d'être à l'aise avec la consultation de la documentation de la plate-forme Java de
manière à trouver rapidement les informations nécessaires et à les exploiter efficacement.
Les possibilités de navigation sont nombreuses :
 Le lien Frames affiche la liste de l'ensemble des packages et des classes dans deux cadres
situés sur le bord gauche de l'écran (le mode No Frames permet de supprimer ces deux
cadres de navigation pour ne garder que l'information principale).
 Le lien Overview affiche la liste de tous les packages (contenu identique à celui du cadre
supérieur gauche du mode Frames).
 Le lien Tree affiche, dans le fenêtre principale, l'arborescence de tous les packages et de
toutes les classes de la plate-forme Java.
 Le lien Index affiche une liste alphabétique dans laquelle il est possible de rechercher et
d'accéder à tous les éléments (classes, interfaces, constructeurs, champs, constantes,
méthodes, exceptions, …) de la plate-forme Java.
 Le lien Deprecated affiche la liste des éléments "dépréciés" / "réprouvés" (classes, interfaces,
constructeurs, champs, constantes, méthodes, exceptions, …) c'est-à-dire les éléments qui
ont été supprimés ou, plus généralement, remplacés par d'autres dans les versions
successives de la plate-forme Java. Il est déconseillé d'utiliser ces éléments qui seront, un jour
ou l'autre, supprimés définitivement de la plate-forme Java. La documentation indique
généralement les éléments qui peuvent être utilisés en lieu et place.
 Le lien Help donne des informations générales concernant l'utilisation de la documentation.

JBa EIA-FR Projet_IG3_Elements_Programmation.docx 13.02.2013 2
SÉLECTION DU LOOK-AND-FEEL (L&F)
Si l'on utilise la libraire Swing pour la gestion de l'interface utilisateur graphique, le Look-and-Feel
(L&F) de l'application (la manière dont se présentent les composants visuels) peut être modifié sans
changer l'application elle-même grâce à la notion de Pluggable Look-and-Feel.
La méthode statique UIManager.setLookAndFeel() permet de modifier le L&F de l'application en lui
passant en paramètre le nom d'une classe (de type LookAndFeel) qui peut être chargée
dynamiquement.
Des méthodes statiques (de UIManager) permettent de rechercher deux L&F particuliers :
 getSystemLookAndFeelClassName() retourne le nom de la classe du L&F natif de la plate-forme
d'exécution (Windows dans notre cas).
 getCrossPlatformLookAndFeelClassName() retourne le nom de la classe d'un L&F
indépendant de la plate-forme d'exécution (appelé Java ou Metal).
D'autres classes de L&F peuvent également être disponibles. On trouve généralement la classe :
 com.sun.java.swing.plaf.motif.MotifLookAndFeel qui représente le L&F OSF/Motif utilisé
sur certaines plates-formes UNIX.
La méthode statique UIManager.getInstalledLookAndFeels() retourne un tableau d'informations
(de type UIManager.LookAndFeelInfo) concernant les L&F qui sont à disposition sur la plate-forme
d'exécution.
Le L&F est généralement défini avant la création de l'interface utilisateur (dans la phase
d'initialisation de l'application).
Si le L&F est modifié alors que des composants Swing sont déjà affichés (changement dynamique), il
faut forcer la mise à jour du L&F de tous les composants en invoquant la méthode statique :
SwingUtilities.updateComponentTreeUI(RootContainer)
RootContainer étant le conteneur qui est à la racine de l'arborescence qui doit être mise à jour
(généralement la fenêtre principale de l'application).
* * * * *
A partir de la version 1.6 update 10, un nouveau L&F a été introduit. Ce nouveau L&F, nommé
«Nimbus» comporte des caractéristiques intéressantes (qualité graphique, configurable, défini
vectoriellement donc redimensionnable sans pixellisation, etc.).
Exemple de code pour définir le L&F «Nimbus» en s'assurant qu'il soit disponible sur la plate-forme
cible :
//--- Try to Set the Nimbus Look&Feel
for (UIManager.LookAndFeelInfo laf : UIManager.getInstalledLookAndFeels()){
if ("Nimbus".equals(laf.getName())) {
try {
UIManager.setLookAndFeel(laf.getClassName());
}
catch (Exception e) {
try {
System.out.println("*** Nimbus Look&Feel not available" +
" (Metal used instead)");
UIManager.setLookAndFeel(
UIManager.getCrossPlatformLookAndFeelClassName());
}
catch (Exception e1) {
e1.printStackTrace();
}
}
}
}

JBa EIA-FR Projet_IG3_Elements_Programmation.docx 13.02.2013 3
VALEURS LITTÉRALES ET CONSTANTES
D'une manière générale, il est recommandé que toutes les valeurs littérales (excepté les valeurs
simples telles que 0, 1, -1) soient définies sous forme de constantes nommées et ne soient pas
écrites "en dur" dans le code source.
Pour une application donnée, il est conseillé de rassembler toutes les valeurs littérales (constantes
numériques, noms de répertoires, de fichiers, couleurs, valeurs par défaut, etc.) dans une classe (ou
éventuellement une interface) réservée exclusivement à cet usage (par exemple dans une classe
nommée Constants).
Dans les autres classes de l'application, l'importation statique permet d'utiliser ces constantes sans
avoir à les préfixer avec le nom de la classe.
public class Constants {
public static final int NB_STEPS = 500;
public static final double BASE_WIDTH = 50.0;
public static final double BASE_HEIGHT = 120.5;
public static final String IMAGE_PROJ = "\Resources\Images\Logo.jpg";
. . .
}
import static applic.Constants.*;
...
//--- Utilisation des constantes
System.out.println("Nombre de pas : " + NB_STEPS);
...
DÉTERMINATION DU RÉPERTOIRE COURANT
Il faut éviter de mettre, en dur dans le code, des chemins d'accès absolus vers les fichiers (par
exemple "D:\Test\Applic\config\myConfig.cfg").
Il est préférable de travailler avec des chemins relatifs, généralement par rapport au répertoire
courant, c'est-à-dire le répertoire dans lequel l'application est installée (emplacement où se trouve le
fichier JAR).
Pour connaître le répertoire courant (chemin d'accès complet enregistré dans une chaîne de
caractères), on peut utiliser l'instruction suivante :
//--- Répertoire courant
String currentDir = System.getProperty("user.dir");
Il est ensuite possible de compléter de chemin d'accès avec des noms de sous-répertoires (à
enregistrer de préférence sous forme de constantes).
//--- Constantes
...
public static final String CONFIG_SUBDIR = "config";
public static final String CONFIG_FILE = "myConfig.cfg";
...
//--- Ouverture du fichier en lecture
String fSep = System.getProperty("file.separator"); // File path separator
String fileName = currentDir + fSep + CONFIG_SUBDIR + fSep + CONFIG_FILE;
try {
BufferedReader r = new BufferedReader(new FileReader(fileName));
}
catch (FileNotFoundException e) {
System.out.println("ERROR : File " + fileName + "cannot be opened");
e.printStackTrace();
}

JBa EIA-FR Projet_IG3_Elements_Programmation.docx 13.02.2013 4
JFILECHOOSER - BOÎTE DE DIALOGUE POUR SÉLECTIONNER UN FICHIER
Dans la librairie Swing, le composant JFileChooser permet de créer facilement une boîte de
dialogue permettant à l'utilisateur de naviguer dans l'arborescence des disques et de sélectionner un
fichier.
La boîte de dialogue peut être créée pour ouvrir un fichier existant (showOpenDialog()) ou pour
sauvegarder un fichier (showSaveDialog()).
Le constructeur de la classe JFileChooser permet de donner un répertoire initial (point de départ
de la navigation) plutôt que le répertoire par défaut du système d'exploitation qui n'est pas forcément
idéal.
Un filtre peut être associé au composant JFileChooser dans ce cas, seul les fichiers acceptés par
le filtre sont présentés à l'utilisateur. Un filtre prédéfini existe pour filtrer les fichiers selon leurs
extensions (FileNameExtensionFilter); une liste d'extension peut être mentionnée.
L'exemple ci-dessous illustre le fonctionnement de ce composant (dans cet exemple, il n'y a pas de
fenêtre principale, la référence est mise à null et la boîte de dialogue sera centrée sur l'écran).
public class TestJFileChooser {
public static void main(String[] args) {
JFrame parentView = null; // Référence fenêtre principale (null=centré)
String fileName;
//--- Répertoire courant
String currentDir = System.getProperty("user.dir");
//--- Création d'un filtre basé sur les extensions (.jpg et .jpeg acceptés)
FileFilter filter = new FileNameExtensionFilter("JPEG file", "jpg", "jpeg");
//--- Création du JFileChooser avec répertoire courant comme point de départ
JFileChooser fChooser = new JFileChooser(currentDir);
//--- Ajout et activation du filtre
fChooser.setFileFilter(filter);
//--- Ouverture de la boîte de dialogue pour choisir un fichier
int returnVal = fChooser.showOpenDialog(parentView);
if(returnVal == JFileChooser.APPROVE_OPTION) {
fileName = fChooser.getSelectedFile().getAbsolutePath();
System.out.println("Selected file : " + fileName);
}
//--- Ouverture de la boîte de dialogue pour enregistrer un fichier
returnVal = fChooser.showSaveDialog(parentView);
if(returnVal == JFileChooser.APPROVE_OPTION) {
fileName = fChooser.getSelectedFile().getAbsolutePath();
System.out.println("Selected file : " + fileName);
}
}
}

JBa EIA-FR Projet_IG3_Elements_Programmation.docx 13.02.2013 5
FORMATAGE DES NOMBRES EN VIRGULE FLOTTANTE
Il existe plusieurs manières de formater les nombres en virgule flottante (float et double).
On peut notamment utiliser la classe DecimalFormat ou la méthode format() de la classe String
(disponible depuis la version 1.5 du SDK) ou utiliser la méthode printf() qui permet d'écrire (sur la
console ou dans un fichier texte) en donnant les indications de formatage associées.
Pattern DecimalFormat : java.sun.com/javase/7/docs/api/java/text/DecimalFormat.html
Syntaxe format() et printf() : java.sun.com/javase/7/docs/api/java/util/Formatter.html#syntax
Exemple d'utilisation de ces différentes techniques :
public static void main(String[] args) {
float v = 123.456789f;
String s;
//--- Utilisation de DecimalFormat
DecimalFormat df = new DecimalFormat("0.0##"); // Max 3 ch. après la virg.
s = df.format(v);
System.out.println(s);
//---- Utilisation de String.format()
s = String.format("v with 2 digits %.2f", v);
System.out.println(s);
//--- Utilisation de printf() pour écriture sur la console
System.out.printf("v with 3 digits %.3f %n", v);
//--- Utilisation de printf() pour écriture dans un fichier
String filename = "D:\\Temp\\Test_printf.txt"; // "En dur" pour le test
try {
PrintWriter p = new PrintWriter(new BufferedWriter(
new FileWriter(filename)));
p.printf("%.3f %n", v);
p.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
DATES ET HEURES
Le formatage des dates (et heures) peut être effectué par la classe GregorianCalendar qui se base
sur un modèle (pattern) dont la syntaxe est définie dans la documentation de cette classe
(java.sun.com/javase/7/docs/api/java/text/SimpleDateFormat.html).
L'exemple ci-dessous illustre le principe et les fonctions principales de ces classes.
//--- Création d'un calendrier avec la date et l'heure courante
GregorianCalendar cal = new GregorianCalendar();
//--- Extraction des différentes parties de la date et de l'heure
int day = cal.get(GregorianCalendar.DAY_OF_MONTH);
int month = cal.get(GregorianCalendar.MONTH) + 1; // January => 1
int year = cal.get(GregorianCalendar.YEAR);
int hour = cal.get(GregorianCalendar.HOUR_OF_DAY);
int min = cal.get(GregorianCalendar.MINUTE);
int sec = cal.get(GregorianCalendar.SECOND);
int ms = cal.get(GregorianCalendar.MILLISECOND);
System.out.println(day+"."+month+"."+year+" "+hour+":"+min+":"+sec+"."+ms);
//--- Utilisation de SimpleDateFormat pour formater la date
String fmtPattern = "dd.MM.yyyy HH:mm:ss.SSS";
SimpleDateFormat formatter = new SimpleDateFormat(fmtPattern);
String fmtDate = formatter.format(cal.getTime());
System.out.println(fmtDate);