[Link]

com
labo-sun@[Link]

Méthodes de programmation
BIEN PROGRAMMER EN JAVA

Auteur : Cyril Joui

Version n° 1.0 – 14 octobre 2004
Nombre de pages : 26

Ecole Supérieure d’Informatique de Paris

23. rue Château Landon 75010 – PARIS
[Link]
 Méthodes de programmation - Bien 2 / 26
programmer en Java

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 3 / 26
programmer en Java

Table des matières

1. INTRODUCTION ............................................................................................................................................. 5
2. CONVENTION DE NOMMAGE.................................................................................................................... 6
2.1. PACKAGES .................................................................................................................................................... 6
2.2. CLASSES........................................................................................................................................................ 6
2.3. INTERFACES .................................................................................................................................................. 6
2.4. VARIABLES ................................................................................................................................................... 6
2.5. CONSTANTES ................................................................................................................................................ 7
2.6. FICHIERS JARS ............................................................................................................................................... 7
3. NORMES ........................................................................................................................................................... 8
3.1. PACKAGES .................................................................................................................................................... 8
3.1.1. Abstraction de data : abstraction.......................................................................................................... 8
3.1.2. Classes d’exceptions : exception........................................................................................................... 8
3.1.3. Objets métiers : bo ou business............................................................................................................. 8
3.1.4. Data manager : datamgr....................................................................................................................... 9
3.1.5. Module graphique: gui (Graphical User Interface).............................................................................. 9
3.2. CLASSES........................................................................................................................................................ 9
3.2.1. Abstraction : XxxAbstract ..................................................................................................................... 9
3.2.2. Business Object : XxxBo ....................................................................................................................... 9
3.2.3. Configuration : XxxConfig .................................................................................................................... 9
3.2.4. Implémentation par défault : XxxDefault.............................................................................................. 9
3.2.5. Classe de conversion : XxxConverter ................................................................................................. 10
3.2.6. Classe d’exception : XxxException ..................................................................................................... 10
3.2.7. Fabrique / usine : XxxFactory ............................................................................................................ 10
3.2.8. Fabrique / usine de factory : XxxFactoryBuilder................................................................................ 10
3.2.9. Implémentation : XxxImpl ................................................................................................................... 10
3.2.10. Lanceur : XxxLauncher....................................................................................................................... 10
3.2.11. Interface de liaison de module : XxxModule....................................................................................... 10
3.2.12. Modèle de données : XxxModel........................................................................................................... 11
3.2.13. Singleton : XxxSingleton ..................................................................................................................... 11
3.2.14. Classe / interface template : XxxTemplate .......................................................................................... 11
3.2.15. Classe utilitaire : XxxTools ................................................................................................................. 11
3.2.16. Classe de vue : XxxView ..................................................................................................................... 11
3.2.17. Gestion de vue : XxxVm ...................................................................................................................... 12
3.3. LES METHODES ........................................................................................................................................... 12
4. METHODES DE PROGRAMMATION....................................................................................................... 13
4.1. CONCEPTS ................................................................................................................................................... 13
4.1.1. Héritage .............................................................................................................................................. 13
4.1.2. Comparaison....................................................................................................................................... 14
4.1.3. Multitâches.......................................................................................................................................... 14
4.1.4. Mémoire .............................................................................................................................................. 15
4.1.5. Sécurité................................................................................................................................................ 16
4.1.6. Optimisation........................................................................................................................................ 16
4.2. FAIRE DES TESTS ET AUTOMATISER DES TACHES ......................................................................................... 17
4.2.1. Assertions ............................................................................................................................................ 17
• Présentation ........................................................................................................................................ 17
• Utilisation............................................................................................................................................ 18
4.2.2. JUnit.................................................................................................................................................... 19
• Présentation ........................................................................................................................................ 19
• Utilisation............................................................................................................................................ 19
4.3. ANT : LE « MAKE » FAÇON JAVA ................................................................................................................. 22
4.3.1. Présentation ........................................................................................................................................ 22

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 4 / 26
programmer en Java

4.3.2. Installation .......................................................................................................................................... 22

4.3.3. Exemple d’utilisation .......................................................................................................................... 22
• Balise project ...................................................................................................................................... 24
• Balise property .................................................................................................................................... 24
• Balise target ........................................................................................................................................ 24
4.3.4. Créer sa propre tâche ......................................................................................................................... 25
• Principe de codage : convention JavaBean ........................................................................................ 25
• Exemple d’utilisation : MyEcho .......................................................................................................... 25

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 5 / 26
programmer en Java

1. Introduction
Les conventions ne sont pas nées de la programmation mais existent depuis bien longtemps. C’est la
programmation qui est venue à elles. En effet, chaque société avait pour habitude de re-développer sa
charte de codage, document interne fixant avec précision comment nommer une méthode ou un
attribut, ou encore comment présenter son code.
Mais dans un souci de standardisation, des conventions « générales » sont apparues. En effet, le
développement des communautés de développement, les groupes de discussion et toutes les
communications imaginables entre les développeurs ont conduit à des chartes de qualités afin que tout
code soit facilement et rapidement compréhensible. Des études ont même été effectuées afin
d’optimiser les conventions en matière de « coding » pour prendre en compte les limites du cerveau
humains (appelées : effet Stroop : [Link]

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 6 / 26
programmer en Java

2. Convention de nommage
Voici l’ensemble des conventions de Sun vis-à-vis du nommage des différents éléments en Java.

[Link]
Le nom d’un package doit respecter les conventions suivantes :
• Tout en minuscules
• Utiliser seulement [a-z], [0-9] et le point ‘.’ et rien d’autre !
• Sun indique que tout package doit avoir comme « root » un des packages suivants : com,
edu, gov, ou les deux lettres identifiants du pays (ISO Standard 3166, 1981)
Voici quelques exemples de packages :
[Link].application1
[Link]

[Link]
Le nom des classes doit respecter les conventions suivantes :
• Première lettre en majuscule
• Majuscule pour les premières lettres de chaque mot, puis minuscules
• Le nom doit être simple et descriptif
• Eviter les acronymes sauf les plus communs tels : Xml, Html, Url …
• N’utiliser que les lettres [a-z] [A-Z] [0-9] (éviter les tirets, underscores …)
Voici quelques exemples de classes :
class ApplicationTest1;
class LaboJavaWork;

[Link]
Le nom des interfaces doit respecter les mêmes conventions que celui des classes.
Remarque : on peut préfixer les interfaces par ‘I’ afin de les distinguer plus rapidement dans le code
les classes abstraites des interfaces, etc.
On s’arrangera, si possible, de terminer le nom de celle-ci par « -able » (ex : Serializable)
Voici quelques exemples d’interfaces :
interface IFunctionDelegue;
interface Jumpable;

[Link]
Les noms de variables doivent respecter les conventions suivantes :
• Première lettre en minuscule

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 7 / 26
programmer en Java

• Majuscule pour les premières lettres de chaque mot, puis minuscules

• Donner un nom simple et descriptif
• Ne pas commencer les noms par des ‘$’ ou des ‘_’ même si cela est possible.
• Variables d’une seule lettre seulement pour un usage local voir très local.
o int : i, j, k, x, y, z, m et n
o char : c
o boolean : b
o …
Remarque : Il est possible de commencer le nom d’une variable par ‘_’ seulement lorsque celle-ci est
une variable d’instance ; cela évite l’utilisation du pointeur ‘this’.
Voici quelques exemples de variables :
int i;
char c;
float monFloat;

[Link]
Les noms des constantes doivent respecter les conventions suivantes :
• Tout en majuscules
• Séparer les mots par un underscore ‘_’
• Donner des noms simples et descriptifs
Voici quelques exemples de constantes :
public static final String FICHIER_PARAMS = "[Link]";
static final int MIN_LARGEUR = 300;

[Link] jars
Les noms des fichiers jars doivent respecter les conventions suivantes :
• Tout en minuscules
• Séparer les mots par un tiret ‘-’
• Donner des noms simples et descriptifs
• Utilisez seulement les lettres [a-z] [0-9]
Voici quelques exemples de fichiers jars :
[Link]
[Link]

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 8 / 26
programmer en Java

3. Normes
Les normes que nous vous présentons ici sont utilisées par une très grande majorité. Cependant ce ne
sont pas des normes définies par Sun. En effet, ils n’existent pas réellement de normes pour la gestion
de projet, nomenclatures des éléments … Mais il faut garder en tête qu’il est beaucoup plus facile de
se repérer dans un espace de nommage bien défini plutôt que de partir à l’aveuglette.
C’est donc pour cela que nous allons vous donner ici un ensemble de normes qui nous semblent justes.
Libre à vous de modifier les noms, l’ordre ou la composition des termes.

[Link]
La programmation objet a été créée dans l’optique de développement de module. Le développement
d’une application se doit donc d’avoir une orientation modulaire. En effet ce type de développement a
l’avantage d’optimiser le travail en équipe (une personne s’occupe d’un module, une autre d’un
autre…).
Cependant la notion de module doit être présente à tous les niveaux pour avoir un développement le
plus complet et optimisé possible. C’est pour cela qu’un module doit être découpé en module qui
peuvent eux-mêmes être découpés en modules plus petits…
Voici les principaux avantages à cela :
• Mieux séparer les concepts
• Meilleure abstraction
• Meilleure réutilisation
• Interchangeabilité
• Facilité de maintenance du code
Le seul inconvénient est que l’intégration de ce concept n’est pas toujours évidente.
Nous allons voir les différents types de packages (et sous-packages) de base qui vous permettront de
classer vos classes avec normalisation.

3.1.1. Abstraction de data : abstraction

Ce package ne contient que des interfaces. Comme son nom l’indique ce package est assez souvent
séparé du reste du système à des fins de sécurité et confidentialité.

3.1.2. Classes d’exceptions : exception

En Java, il convient d’utiliser ses propres exceptions afin d’avoir un meilleur contrôle de ses objets et
des méthodes appliquées ou applicables à ceux-là.
Ces classes peuvent tout à fait être mis dans un package total appart car elles ne doivent, en théorie, ne
pas avoir beaucoup de dépendances.

3.1.3. Objets métiers : bo ou business

En Java on privilège la découpe des entités en objet métier, toujours à des fins d’évolution et de
maintenance.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 9 / 26
programmer en Java

Ces entités seront des classes représentant les données de votre projet (ex : Personne, Etudiant,…)

3.1.4. Data manager : datamgr

Les « Data manager » sont les modules de traitement des données. Ce package sera donc racine de
tous les modules non graphiques qui s’occupent que du traitement de data. Comme par exemple les
parseurs, convertisseurs …

3.1.5. Module graphique: gui (Graphical User Interface)

gui est le package racine de tous les modules graphiques. Afin de mieux les séparer on peut utiliser
des interfaces même si cela la tâche plus difficile au développeur (cf. MVC : Modèle Vue Contrôleur).

[Link]
Il existe un très grand nombre de types de classes dans la programmation orienté objet. C’est pour cela
qu’il faut envisager un classement strict et alphabétique afin de se repérer toujours plus facilement.
Voici donc un ensemble de types de bases avec leur description et leur nomenclature. Dans tous les
exemples « Xxx » représente le nom de la classe.
Remarque : lorsqu’on utilise la contraction, il faut bien la respecter du début jusqu’à la fin.

3.2.1. Abstraction : XxxAbstract

Les classes abstraites sont les racines de différentes implémentations.

3.2.2. Business Object : XxxBo

Classe d’objet métier.

3.2.3. Configuration : XxxConfig

Une classe ou interface de configuration est une classe qui contient une configuration (par exemple
ConsoleConfig). Nous utilisons le préfixe contracté Config afin de réduire la taille du nom de la
classe.

3.2.4. Implémentation par défault : XxxDefault

Ceci représente une implémentation par défaut d’une interface ou d’une classe abstraite.
Ceci finalise le concept à 3 niveaux d’abstraction :
• Xxx : abstraction sous forme d’interface
• XxxAbstract : implémentation abstraite d’une interface
• XxxDefault : implémentation par défaut d’une classe abstraite ou interface

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 10 / 26
programmer en Java

3.2.5. Classe de conversion : XxxConverter

Classe qui est utilisée pour convertir des données, des formats de fichiers…

3.2.6. Classe d’exception : XxxException

Une bonne pratique consiste à programmer ses propres types d’exception.

3.2.7. Fabrique / usine : XxxFactory

L’utilisation de classe « factory » est inscrite dans des « design patterns » particuliers. Les interfaces
de ce type n’auront, en générale, qu’une méthode : newXxx(…).
La classe associée à ce type permettra de créer des objets spéciaux non accessibles directement.

3.2.8. Fabrique / usine de factory : XxxFactoryBuilder

C’est une classe qui permet de créer des « factory » (dans ce cas là, la factory sera définie via une
interface).
Ce type doit contenir une méthode : static IFactory newFactory();
Avec « IFactory » représentant l’interface de la factory à retourner.

3.2.9. Implémentation : XxxImpl

Classe implémentant telle ou telle interface.

Exemple : interface LabelIcon → class LabelIconImpl

3.2.10. Lanceur : XxxLauncher

Classe ayant un « main » qui permet de lancer l’application.

Beaucoup de personnes mettent la méthode main directement dans leur classe principale (Classe
dérivant de JFrame par exemple lorsqu’ils font une application graphique).
Ceci n’est pas une bonne méthode de programmation. Il vaut mieux utiliser une classe de lancement
qui s’occupera des initialisations, et appelle à la première classe de l’application.

3.2.11. Interface de liaison de module : XxxModule

Interface permettant de lier les modules.

Comme nous l’avons vu plus haut, le développeur doit chercher au maximum à externaliser les
modules qu’il créée et à les rendre le plus exportable et réutilisable possibles.
Pour que son module soit le plus indépendant possible d’un système nous pouvons utiliser des classes
de liaison.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 11 / 26
programmer en Java

Cas classiques d’utilisation :

• Module GUI : (pattern MVC : Modèle Vue Contrôler) module ayant une interface graphique
représentant les données et pouvant réagir avec le système.
o XxxViewManager : le manager du module
o XxxView : la vue
o XxxModel : le modèle, contient toutes les données utiles
o XxxLink : les liens avec le système (de type action par exemple pour les évènements)

• Plugins : module indépendant permettant d’élaborer des applications modulables.

3.2.12. Modèle de données : XxxModel

Interface permettant d’accéder à des données. Utilisation principalement avec MVC.

3.2.13. Singleton : XxxSingleton

Classe dérivant du pattern Singleton (une seule instance de cette classe).

Condition pour que la classe soit bien un singleton :
• une méthode : static getInstance() : retourne l’instance par défaut du singleton
• une méthode : static getInstance(…) : dans le où on gère une liste d’instance du même type
• un constructeur private ou protected (si on pense avoir plusieurs implémentation du
singleton)
• une méthode : initWith(XxxSingleton) : permet d’initialiser le singleton à partir d’une
implémentation parente du Singleton. Cela peut être utile lorsque l’on veut pouvoir avoir
plusieurs implémentations du même singleton.

3.2.14. Classe / interface template : XxxTemplate

Une interface template définit les méthodes qui permettent par exemple à un objet d’être représenté
par un template.
Cas d’utilisation principal : les plugins.

3.2.15. Classe utilitaire : XxxTools

Une classe utilitaire (Tools pour Outils) sera en général :

une classe abstraite
contient que des méthodes static

3.2.16. Classe de vue : XxxView

Les classes de vue sont utilisées dans le pattern MVC.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 12 / 26
programmer en Java

3.2.17. Gestion de vue : XxxVm

Les classes de gestion des vues sont également utilisées dans le pattern MVC.

[Link] méthodes
Les méthodes n’échappent pas aux normes. Celles-ci sont très utilisées dans les design-patterns qui
souvent les désignent par leur nom « technique ».
• Getter - getXxx() : Object
Méthode qui retourne la valeur du membre privé : Xxx.
• Setter - setXxx() : void
Méthode qui permet d’assigner une valeur au membre privé Xxx.
• Getter - isXxx() : boolean
Getter spécifique aux membres booléen.
• Getter – getAllXxx()
Getter spécifique aux collections d’items.
• Création d’objet – createXxx() – newXxx()
Méthode qui crée un objet
• Mise à jour – updateXxx()
Met à jour d’un attribut par une valeur.
• Ajout – addXxx()
Ajoute une valeur (à une collection).
• Création et Ajout – addNewXxx()
Crée une nouvelle valeur et l’ajoute.
• Ajout un ensemble – addAllXxx()
Ajoute un ensemble de valeurs.
• Suppression removeXxx()
Supprime une valeur d’une collection.
• Suppression removeAllXxx()
Supprime l’ensemble des éléments d’une collection.
• Conversion - toXxx()
Convertit l’objet en cours vers un autre objet désigner par Xxx.
• Validation checkXxx()
Permet de vérifier la valeur d’un attribut.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 13 / 26
programmer en Java

4. Méthodes de programmation
[Link]

4.1.1. Héritage

• Invocation d’une méthode non finale dans un constructeur.

Une méthode non finale peut être surchargée dans une sous-classe. Si un constructeur appelle une
méthode non finale alors il y a risque d’erreur subtile.
public class A {

public static void main(String [] args) {

new B();
}

public A() {
setAttribute();
}

public void setAttribute() {

[Link]("setAttribute A");
}
}

class B extends A {

public B() {
super();
initB();
}

public void initB() {

[Link]("Init B");
}

public void setAttribute() {

[Link]("setAttribute B");
}
}

Si vous exécutez ce morceau de code, vous pourrez voir que l’appel à setAttribut() dans le
constructeur de la class A appelle en fait la méthode setAttribute() (surchargée) de la classe B.
Ceci est une subtilité en Java. En effet l’ouverture au polymorphisme se fait dès l’appel du premier
constructeur en Java (contrairement au C++). Ceci explique pourquoi la méthode initB() est appelée
après setAttribute() (de la classe B). Imaginez que vous ayez besoin d’initialiser des variables avant
tout appel de setAttribute(). Dans ce cas précis vous risquez de lever une exception de type
NullPointerException.
Pour résoudre ce problème il suffit de n’appeler que des méthodes « finale » dans un constructeur.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 14 / 26
programmer en Java

4.1.2. Comparaison

• Comparaison de chaîne et valeur « null »

Pour comparer deux chaînes de caractères on utilise assez fréquemment : [Link]("Valeur").Que

se passe-t-il si obj est null ? Le test vous renvoie un NullPointerException.
Une première solution est de rajouter un test préalable :
((obj != null) && ([Link]("Valeur"))
La deuxième et préférable solution est, au lieu de tester si l’objet à la même valeur qu’une chaîne, de
tester que la chaîne à la même valeur que l’objet :
"Valeur".equals(obj)
Cette solution est plus puissante et plus rapide. Si obj est null le test renverra false sans faire de test
supplémentaire.
De ce fait, si vous souhaitez assimiler null à "" (chaîne vide) vous devrez donc faire un test spécifique.

• Comparaison de chaîne à l’aide de ==

Java propose deux types de comparaison : vérifiant l’identité des instances ou vérifier la valeur des
instances. Il n’est pas toujours facile pour le développeur de savoir laquelle est laquelle !
La comparaison par référence (==) permet de vérifier que deux références pointent sur le même objet
mais pas s’ils ont les mêmes valeurs.
C’est avec equals() que l’on peut vérifier que deux instances ont la même valeurs.
Remarque : Attention à l’utilisation de equals(), la version par défaut (de la classe Object)
transforme la vérification de valeur par la vérification d’identité.
La classe String redéfinit cette méthode. Cependant si vous faites : str == «», ce test ne vérifie pas que
la chaîne str est vide ! Cela vérifie que str pointe vers la même référence qu’une chaîne vide. Ce qui
peut entraîner des erreurs.
La solution est d’utiliser :
[Link]("")
ou
"".equals(str)

4.1.3. Multitâches

• Erreur avec les conteneurs

Les conteneurs (Vector, Hashtable …), jusqu’au JDK 1.0, étaient tous compatibles avec le multitâche.
Cependant pour des raisons de performances les versions suivantes ont préféré laisser le programmeur
gérer cette subtilité. Cela peut donc entraîner de lourdes erreurs qui sont assez difficiles à identifier. La
solution à préconiser est d’utilisez un type de conteneur compatible avec le JDK 1.0 ou d’utilisez la
méthode : synchronizedMap(Map m) comme dans cet exemple :
private static HashMap cache = [Link](new HashMap());

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 15 / 26
programmer en Java

4.1.4. Mémoire

• Short en java

Java utilise le short pour réduire l’espace mémoire utilisé par la JVM et non pour optimiser les
calculs. En effet, la JVM ne possède pas d’arithmétique en short mais doit les convertir en int faire le
calcul et reconvertir le résultat en short.
Solution : n’utilisez les shorts que lorsque votre application doit avoir un impact au niveau mémoire
plus qu’au niveau performance.

• Les constantes

En Java, les constantes sont définies par le mot clé final cependant il est bien plus préférable de les
déclarer en static final. En effet, cela permet d’économiser une place non négligeable en mémoire car
une constante, comme son nom l’indique, ne changera jamais tout au long du programme c’est donc
pour cela qu’elle est marquée final de plus elle est commune à toutes les instances de sa classe
parente, c’est donc pour cela qu’il faut ajouter le mot clé static.

• Les String

Les instances String sont immuables, c'est-à-dire qu’elles ne peuvent évoluer après leur construction.
Il n’est donc pas nécessaire de construire une instance à partir d’une autre comme ceci :
String str = new String("chaine1");

Il est donc plus performant de faire directement :

String str = "chaine1";

• La concaténation de String avec StringBuffer

Les méthodes de StringBuffer retourne « this » il est donc possible d’enchaîner les invocations. On
trouve parfois des constructions de chaînes comme cela :
public class StringBufTest {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer();
[Link]("chaine1");
[Link]("chaine2");
[Link]("chaine3");
}
}

Cela entraîne des pertes de performance car le compilateur doit générer un code pour effacer de la pile
l’objet retourné par append puis rechercher la valeur de la variable buf la replacer sur la pile …
La solution est d’appeler append en cascade :
public class StringBufTest {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer();
[Link]("chaine1")
append("chaine2")
append("chaine3");
}
}

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 16 / 26
programmer en Java

4.1.5. Sécurité

• Les classes utilitaires

Il est parfois utile de gérer une classe qui ne contient que des méthodes static car ce sont des méthodes
« Outil » (qui ne sont pas rattachées à une instance particulière). Afin d’interdire toute instanciation de
cette classe, il est préférable de mettre le constructeur en private.
public class Outil {
private Outil() {}

public static void outil1() {

[Link]("Outil1");
}

public static void outil2() {

[Link]("Outil2");
}
}

• Libération des ressources

Dans un programme il faut toujours prévoir de libérer les ressources en particuliers tout ce qui est flux
d’entrées/sorties. Si vous ne le faites pas, cela peut conduire à terme au plantage de votre application.
Le schéma à utiliser dans tous les cas est celui-ci :
import [Link];
import [Link];
import [Link];
import [Link];

public class Flux {

public static void main(String[] args) {
InputStream stream = null;
try {
stream = new FileInputStream("[Link]");
} catch (FileNotFoundException e) {
} finally {
if (stream != null)
try {
[Link]();
} catch (IOException e) {
} finally {
}
}
}
}

4.1.6. Optimisation

• Utilisation des types génériques

Java propose, par exemple, différents conteneurs répondant à des interfaces. L’intérêt de cette
approche est de pouvoir sélectionner plus tard le type d’implémentation que l’on veut utiliser lors de
l’exécution par exemple.
import [Link];

public class GenericiteBad {

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 17 / 26
programmer en Java

private Hashtable data = new Hashtable();

public void setData(Hashtable data) {

[Link] = data;
}

public Hashtable getData() {

return [Link];
}
}

Pour tirer profit de ce concept, il est important de n’utiliser que les types de base dans vos classes pour
tout ce qui est des conteneurs.
import [Link];
import [Link];

public class Genericite {

private Map data = new HashMap();

public void setData(Map data) {

[Link] = data;
}

public Map getData() {

return [Link];
}
}

[Link] des tests et automatiser des tâches

Lorsque l’on programme, il est toujours intéressant de savoir si telle ou telle méthode fonctionne
correctement. Beaucoup de développeurs débutants utilisent des « [Link]("DEBUG"); » à
des fins de « debug ».
Ceci est une très mauvaise habitude car lors du déploiement de l’application et surtout de grandes
applications, si ces « debugs » n’ont pas été enlevés cela entraîne de graves ralentissements et
lourdeurs dans l’application.
Pour parfaire à cela il existe des outils de débuggage. Nous allons présenter les deux principaux et les
plus utilisés :
• les assertions
• le framework JUnit

4.2.1. Assertions

• Présentation

La définition d’une assertion est : « proposition que l’on avance comme vraie ». Cela veut donc tout
dire. Vous n’utiliserez les assertions que pour savoir si une vérité est vraie lors de l’exécution de
l’application.
L’assertion vous permettra d’afficher un message de debug dans la console lorsque l’assertion ne sera
pas validée.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 18 / 26
programmer en Java

• Utilisation

L’utilisation de debug doit se faire avec parcimonie sinon vous ne vous repèrerez plus.
La syntaxe d’une assertion est :
assert condition : Object;

Une exception sera lancée si la condition est à false. Comme nous l’avons vu les assertions sont à
utilisées lorsque vous présumez d’une vérité sans que celle-ci soit triviale.
Nous allons maintenant spécifier les différents cas dans lequel nous pouvons utiliser les assertions :

• Invariants logiques

Ce type d’invariant se retrouve, par exemple, dans un « switch » avec le cas : « default ».
switch (suit) {
case [Link]:
...
break;

case [Link]:
...
break;

case [Link]:
...
break;

case [Link]:
...
default :
assert false : "Default impossible !";
}

• Invariants de contrôle de flux

Ils permettent d’être sûr que l’application ne dépassera un certain stade au niveau d’une méthode ou
autre.
void foo() {
for (...) {
if (...) {
return;
}
}
// Impossible d’atteindre ce point
assert false : "Impossible d'arriver ici : foo méthode";
}

Les assertions vous permettent donc d’être certains que le programme ne passe pas par un endroit qu’il
ne devrait pas atteindre soit par la suite d’un ensemble de bloc conditionnel soit avant la fin d’une
méthode dont vous êtes sûr qu’une expression return sera activé avant.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 19 / 26
programmer en Java

4.2.2. JUnit

• Présentation

JUnit est un framework OpenSource qui est directement issu des concepts de « l’eXtreme
Programming » (concepts évolués de gestion de projet). Cet outil est très utilisé sur Internet et un
ensemble d’important d’application gravite autour.
Nous étudierons ici les rudiments pour l’utilisation de JUnit dans des cas très simples. Ce composant
est très bien commenté et la lecture de documentations vous permettra d’avancer très vite avec son
utilisation.

• Utilisation

Il y a 3 grandes étapes pour utiliser JUnit :

1. Associer à chaque classe que vous voulez tester, une classe de test héritant de
[Link] (en lui ajoutant le suffixe : « Test »)
2. Coder les méthodes d’initialisation, de destruction et de tests (une par fonctionnalité de la
classe à tester)
3. Lancer les tests depuis les outils JUnit
Voici un exemple détaillé afin de mieux appréhender son utilisation.
La classe que nous allons tester s’appelle : ClassATester et son implémentation est :
package labosun;
public class ClassATester {

/**
* Constantes
*
*/
private static final float TAUX_EURO_FRANC = 6.55957f;

/**
* Membres
*
*/
private float tauxEuroFranc;

/**
* Constructeur de base
*
*/
public ClassATester() {
tauxEuroFranc = TAUX_EURO_FRANC;
}

/**
* Constructeur qui prend en paramètre
* la valeur du taux à utiliser
*
*/
public ClassATester(float tauxEuroFranc) {
[Link] = tauxEuroFranc;
}

/**
* Méthode qui retourne la valeur passée en paramètre

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 20 / 26
programmer en Java

* @param b
* @return
*/
public static boolean getBoolean(boolean b) {
return b;
}

/**
* Méthode qui convertit des euros en francs
* @param euro
* @return
*/
public float euroToFranc(float euro) {
return euro * [Link];
}
}

Cette classe est très simple et celle qui permet d’effectuer les tests l’est aussi :
package labosun;

import [Link];
import [Link];
import [Link];

public class ClassATesterTest extends TestCase {

/**
* Métohde appelée lors de l'initialisation de l'application
*/
protected void setUp() {

/**
* Métohde appelée lors de la sortie / destruction
*/
protected void tearDown() {

/**
* Constructeur qui doit absolument prendre un
* argument de type string
* @param param
*/
public ClassATesterTest(String name) {
super(name);
}

/**
* Méthode qui permettra de tester la méthode getBoolean
* de la classe ClassATester
*
*/
public void testgetBoolean() {
// Permet de tester que getBoolean retourne
// true si on lui donne true en paramètre
assertEquals([Link](true), true);
// Cet appel va indiquer un problème lors
// du test (on passe true et vérifie le résultat à false)
//assertEquals([Link](true),false);
}

/**
* Méthode qui vérifie que euroToFranc est bien fonctionnelle

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 21 / 26
programmer en Java

*
*/
public void testeuroToFranc() {
// Vérifie que 1 euro = 6.55957 francs
// Cas constructeur de base
assertEquals(new ClassATester().euroToFranc(1f), 6.55957f, 0);
// Cas constructeur paramétré
assertEquals(new ClassATester(6.55957f).euroToFranc(1f), 6.55957f, 0);
}

/**
* Construit automatiquement la suite des tests
* à effectuer via l'introspection java
* Cependant il est tout à fait possible de gérer
* le lancement des tests manuellement
* @return
*/
public static Test suite() {
return new TestSuite([Link]);
}
}

Remarque : JUnit n’est pas inclut dans les librairies de base ! Il vous faudra donc ajouter le jar :
« [Link] » à vos librairies pour que la compilation s’effectue correctement.
Sous Eclipse : (clic droit projet -> Java Build Path -> Librairies -> Add external jars)
Maintenant que nous avons nos deux classes il faut pouvoir lancer les tests afin de récupérer un
rapport. JUnit fournir une application en mode graphique pour la lancer il vous suffit d’exécuter :
« java [Link] [Link] ». Si vous n’arrivez pas à le lancer
directement depuis le jar, décompresser celui-ci avant.
Une fois les tests lancés vous pouvez cliquer sur « Test Hierarchy » pour voir le résultat de vos
différentes méthodes testées. Voici le résultat obtenu avec les classes précédentes.

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 22 / 26
programmer en Java

[Link] : le « make » façon Java

4.3.1. Présentation

Vous connaissez certainement l’outil « make » sous UNIX, « ant » est de la même ligné et permet la
compilation et le déploiement d’application java très facilement. Cet outil est très performant, évolutif
et très maniable, c’est donc pour cela qu’il est très utilisé pour les projets importants. Il est écrit en
Java ce qui lui permet d’être très portable.
Son exécution tient dans le fait qu’il parse un fichier XML (makefile) le plus souvent appelé :
« [Link] » et qu’il execute un ensemble d’instruction qu’on lui spécifie dans ce fichier.
La compréhension de l’outil nécessite seulement deux mots :
• Task (tâche) : une tâche au sein d’un makefile représente une instruction au sein d’un
programme. Cette tâche est définie par son nom et différents arguments qu’on lui passe
(dossier des classes à compiler par exemple). Par exemple, la tâche « copy » permet de copier
un fichier (ou un ensemble de fichier), la tâche jar permet de créer un jar …
• Target (cible) : un target est un point d’entrée dans un makefile (sous unix vous pouvez
utiliser make test, make clean …). Il est caractérisé par son nom (test, clean, compile …) et
vise à accomplir une étape spécifique dans le processus de production. Nous pouvons
« assimiler » cela aux fonctions dans un langage de programmation.

4.3.2. Installation

Ant étant un outil à part du JDK, il vous faudra l’installer. Ceci est très simple car il suffit de
décompresser le fichier contenant cet applicatif ([Link]).
Le dossier décompressé contient de nombreux sous dossier dont « bin » qui contient les scripts de
lancement de ant.

4.3.3. Exemple d’utilisation

Nous allons étudier le cas d’une compilation, compression en jar et génération de la javadoc via ant et
utilisez Eclipse pour lancer l’exécution.
Sous Eclipse créé un nouveau projet : AntTest et un package labosun contenant une classe First (la
plus simple possible).
Ajoutez un fichier nommé : [Link] qui servira à la définition du makefile.
Voici le code XML à insérer dans ce fichier :
<project name="AntTest" default="default" basedir=".">

<property name="src" location="./" />

<property name="build" location="build" />
<property name="jarname" value="[Link]" />

<target name="init">
<mkdir dir="${build}"/>
</target>

<target name="compile" depends="init"

description="Etape de compilation du projet avec dépendance de la
tâche init">

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 23 / 26
programmer en Java

<javac srcdir="${src}" destdir="${build}">

</javac>
</target>

<target name="clean" description="Etape de ménage">

<delete dir="${build}" />
</target>

<target name="deploy" depends="compile" >

<echo message="Déploiement en jar" ></echo>
<jar jarfile="${jarname}" >
<fileset dir="${build}" includes="**" ></fileset>
</jar>
</target>

<target name="main">
<antcall target="deploy"></antcall>
</target>
<target name="default">
<antcall target="compile"></antcall>
</target>

</project>

Nous allons maintenance commenter et expliquer les différentes balises utilisées :

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 24 / 26
programmer en Java

• Balise project

La balise project est celle qui occupe le « premier niveau ». Elle définit les informations concernant le
projet que nous allons traiter par Ant.
Détail de ses différents attributs :
• name : nom pour le projet
• default : tâche à exécuter par défaut (si aucune tâche spécifique à été indiquée)
• basedir : dossier de base du projet par rapport auquel tous les paths relatifs sont redéfinis.

• Balise property

La balise property vous permet de gérer des propriétés dans votre projet. Une propriété peut être un
chemin vers un fichier, une variable, une URL, un fichier de « properties ».
Détail de ses différents attributs :
• name : nom de la propriété
o location : permet de spécifier un chemin relatif/absolu vers un fichier. Si le chemin est
relatif il sera automatiquement basé sur la valeur de « basedir » du projet lors de son
utilisation.
• file : le nom du fichier de « properties » à charger
• url : url vers laquelle il faut lire un fichier de « properties »
• classpath : classpath dans lequel il faut aller quand Ant cherche une ressource.
Exemples :
<!-- Définition d’une “variable” -->
<property name="[Link]" value="dist"/>

<!-- Chargement d’un fichier de properties -->

<property file="[Link]"/>

<!-- Chargement d’un fichier de properties via Url -->

<property url="[Link]

Remarque : un fichier de properties est constitué comme ceci :

propriete1=valeur1
propriete2=valeur2

• Balise target

La balise target est comme mentionnée dans la présentation, la balise qui permet de définir un point
d’entrée à Ant. C’est également dans cette balise que l’on ajoutera les actions à faire pour cette cible.
Détail de ses attributs :
• name : nom de la cible
• depends : dépendance vers une autre cible (il faut d’abord effectuer ces cibles avant
d’exécuter celle-ci). On sépare les différentes dépendances avec des virgules : A, B, C
• if : permet de n’effectuer cette tâche que si une propriété est initialisée. Exemple : <target
name="module1" if="NomPropriétéInitialisée" />

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 25 / 26
programmer en Java

• unless : permet de n’exécuter ce target si la propriété n’est pas initialisée. Exemple : <target
name="module2" unless="NomPropriétéNonInitialisé" />
• description : permet d’indiquer une petite description au target

Vous avez pu remarquer un ensemble de balises incluses dans target qui permettent d’exécuter des
instructions. Voici la liste de celles utilisées dans notre script :
• mkdir : permet de créer un dossier
• delete : permet de supprimer un dossier
• javac : permet de compiler des fichiers java (remarquez l’utilisation des attributs : destdir et
srcdir qui permette de spécifier les dossiers sources et de destinations)
• echo : affiche un message lors du lancement du script
• jar : crée une archive jar dont le nom est spécifié par l’attribut jarfile. Pour indiquer
l’ensemble des fichiers à inclure dans celle-ci vous pouvez utiliser la balise fileset
• fileset : spécifie un ensemble de fichiers avec l’attribut dir pour indiquer le dossier de base et
l’attribut includes pour spécifier les types de fichiers à inclure (utilisez ** pour tous les
inclure).

4.3.4. Créer sa propre tâche

Ant est un outil sans limite car il permet de développer votre propre tâche. Il existe déjà de multiple
tâche qui ont déjà été crées, cependant si votre recherche est négative il vous suffira de quelques lignes
pour mettre en place votre propre tâche.

• Principe de codage : convention JavaBean

Une tâche personnalisée (ou Custom Task) est très simple à coder. En effet, elle ne réclame qu’une
correspondance entre les attributs spécifiés dans le fichier Xml et les différentes méthodes mises à
disposition dans votre classe (setter). On peut parler de mapping.
Voici les caractéristiques obligatoires à respecter :
• chaque attribut de votre classe doit être privée et doit mettre à disposition un setter (méthode
publique setXxx) permettant de positionnner la valeur de l’attribut Xxx de votre classe.
• votre classe doit hériter de [Link].
• le code correspondant à l’exécution de votre tâche doit être placé dans la méthode : publique
execute().

• Exemple d’utilisation : MyEcho

Nous allons, afin de mettre en pratique ce que l’on vient de voir, créer une tâche personnalisée qui se
nommera : « MyEcho ». Celle-ci ne fera reprendre que le principe de la tâche existante : « echo ».
Voici le code simplissime de notre classe :
package [Link];

import [Link];
import [Link];

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
 Méthodes de programmation - Bien 26 / 26
programmer en Java

public class MyEcho extends Task {

private String message;

public void setMessage(String message) {

[Link] = message;
}

public void execute() throws BuildException {

[Link]([Link]);
}
}

Cette classe ne pose aucun problème particulier et respecte, en outre, les conventions listées plus haut.
Vous voici en la possession d’une tâche personnalisée.

Nous allons maintenance nous attarder sur son utilisation dans Ant. Tout se passe dans le fichier
makefile xml.
Voici donc celui utilisé pour tester notre tâche :
<project default="default" basedir=".">
<taskdef name="MyEcho" classpath="."
classname="[Link]" />
<target name="default">
<MyEcho Message="Hello avec Ant" />
</target>
</project>

Un seul nouveau tag est utilisé ici : « taskdef ». Il permet d’indiquer à Ant que nous souhaitons définir
une tâche personnalisée. Son utilisation est simple, il vous suffit de spécifier le classpath (endroit où
sont stockés les fichiers .class) et le classname : nom de votre classe (avec le nom de package). Et
finalement le nom que vous attribuez à votre nouvelle tâche par l’attribut name.
L’utilisation (appel) se fait via le pattern :
<NomPersonnalise attribut1="valeur1" attribut2="valeur2" … >

[Link]
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs