Je viens de découvrir une fonctionnalité méconnue d'Eclipse : les catégories.
Grâce à l'annotation javadoc @category, il est possible de définir des groupes virtuels de méthodes et de propriétés au sein des classes Java. Il est ensuite possible de les filtrer dans les vues Outline et Members, afin de n'afficher que ce qui vous intéresse.

Cette astuce peut être très pratique lorsque vous naviguez dans une classe imposante, et que vous cherchez à en comprendre la structure.
Pour peu que le code soit mal organisé, il se peut très bien que des méthodes métiers soient perdues au milieu des accesseurs, et que vous passiez à côté par inadvertance.

Un exemple, un exemple !

Puisque vous insistez, prenons l'exemple d'un simple POJO décrivant une Personne. Il est composé de deux constructeurs, trois propriétés et leurs six accesseurs, et une méthode métier pour calculer l'âge de la personne.

Voici ce que propose la vue Outline par défaut :

Avez-vous remarqué la méthode métier calculerAge au milieu de tous les accesseurs ? Probablement pas.
Et c'est le problème de cette vue : elle montre trop de choses, et il est difficile de s'y retrouver.

Les catégories à la rescousse !

Maintenant, appliquons des annotations @category à nos champs et méthodes.
Il n'y a pas de catégories prédéfinies, vous pouvez donc vous organiser comme bon vous semble. Vous pouvez même associer plusieurs catégories à un même élément.

Certaines catégories basiques émergent naturellement :

• Les propriétés : @category Property
• Les constructeurs : @category Constructor
• Les accesseurs : @category Accessor
• Les méthodes utilitaires (equals(), hashCode(), toString(), clone()...) : @category System

Pour ces catégories, je pense qu'il est intéressant de standardiser leur nom et d'automatiser leur génération dans le code grâce aux templates d'Eclipe. Vous trouverez donc en annexe de ce billet un fichier de templates prêt à être importé dans Eclipse (Préférences -> Java -> Code style -> Code templates).

Mais concrètement ?

Mais revenons à notre exemple.
Voici un extrait du POJO annoté :

/**
 * L'année de naissance de la personne
 * @category Property
 */
private int anneeNaissance;
 
/**
 * @category Constructor
 * @param nom Le nom de la personne 
 * @param prenom Le prénom de la personne
 * @param dateNaissance La date de naissance de la personne
 */
public Personne(String nom, String prenom, int dateNaissance) {
	this.nom = nom;
	this.prenom = prenom;
	this.anneeNaissance = dateNaissance;
}
 
/**
 * @return the anneeNaissance
 * @category Accessor
 */
public int getAnneeNaissance() {
	return anneeNaissance;
}
 
/**
 * @return L'âge de la personne (année courante - année de naissance)
 */
public int calculerAge() {
	Calendar cal = Calendar.getInstance();
	int annee = cal.get(Calendar.YEAR);
	return annee - this.anneeNaissance;
}
 
/**
 * @category System
 */
@Override
public String toString() {
	return "Personne [nom=" + nom + ", prenom=" + prenom
			+ ", anneeNaissance=" + anneeNaissance + "]";
}

La vue Outline affiche maintenant les catégories à côté des éléments :

Mais ce qui est réellement intéressant, c'est qu'il est désormais possible de filtrer l'affichage des catégories :

On peut donc masquer les constructeurs, accesseurs et méthodes systèmes. Ainsi, il ne reste plus que les informations réellement importantes :

Conclusion

Les catégories sont très pratiques pour filtrer rapidement les informations de la vue Outline.

Mais j'admets que, pour en tirer réellement parti, il est nécessaire de s'outiller afin d'automatiser leur usage. Pour cela, je vous recommande d'importer dans Eclipse le fichier de templates fourni en annexe de ce billet.