[Java 5] Réflexion sur les énumérations type-safe

**rozwel** · 04/12/2004, 08h09

Bonjour,

J'ai lu avec avidité la doc de Lionel ROUX sur les nouveautés de Tiger mais il me manque quelques infos pour convertir mes bonnes vieilles classes pleines de final static en jolies énumérations typesafe.

En particulier j'ai une de ces classes qui définit une interface de vocabulaire RDF pour Jena (pour ceux qui connaissent) et qui pour l'instant ressemble à peu près à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
public class MD{
	//URI for vocabulary elements
	protected static final String uri = "http://www.epseelon.org/metadoc/elements/1.0/";
 
	//Return URI for vocabulary elements
	public static String getURI(){
		return uri;
	}
 
	/**
         * Uniquement la pour initialiser les membres suivants.
         */
	private static Model model = ModelFactory.createDefaultModel();
 
	/**
         * Ressources du modèle
         */
	public static Resource Element = model.createResource(uri + "Element");
	public static Resource Document = model.createResource(uri + "Document");
 
	/**
         * Propriétés du modèle
         */
	public static Property workzones = model.createProperty(uri, "workzones");
	public static Property parents = model.createProperty(uri, "parents");
}

Mon problème c'est que tant que l'énumération porte sur des entiers ça va je suis pas troublé, ça ressemble à ce que je connaissais en C.
Mais j'ai pu constater avec bonheur que les enum Java permettaient de faire beaucoup plus que ça : http://java.sun.com/developer/techni...2se15langfeat/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
public class Example {
  public enum MainMenu {FILE, EDIT, FORMAT, VIEW}
 
  public static void main(String[] argv) {
    for (MainMenu menu : MainMenu.values()) 
      System.out.println(menu);    
  }
}

Ce que je ne comprends pas c'est comment ils font pour initialiser les valeurs de FILE, EDIT, FORMAT et VIEW, et donc par extension comment je peux faire pour initialiser mes ressources et mes propriétés.

Et comme la documentation ne foisonne pas encore (je vais me jeter sur la première bible des nouveautés de J2SE5 dès qu'elle sort), je comptais un peu sur l'expérience des plus téméraires d'entre vous qui, comme moi, auront déjà entamé la migration mais qui, contrairement à moi auront trouvé l'astuce

Merci d'avance

rozwel

**adiGuba** · 04/12/2004, 09h34

Salut,

Je n'ai pas trop compris ton problème...
Tu gères tes enumération comme des objets...
Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
MainMenu choix = MainMenu.EDIT;
 
switch (choix) {
	case FILE: /* ... */ break;
	case EDIT: /* ... */ break;
	case FORMAT: /* ... */ break;
	case VIEW: /* ... */ break;
}

a++

**rozwel** · 04/12/2004, 16h24

Ce code là en fait, c'est pas le mien, c'est celui de la "doc" de Sun.
Et j'ai relu et rerelu cet article et je me rends compte qu'en fait je me suis mis dedans parce que contrairement à ce que je croyais avoir compris, cet exemple ne montre pas qu'une valeur d'enum peut être un objet. Donc je vais encore fouiller les constructeurs d'enum...

**rozwel** · 04/12/2004, 17h02

J'ai trouvé une solution à mon problème qui ne semble pas offrir de gain substanciel en terme de sécurité pour l'instant (pas vraiment d'utilisation de l'aspect typesafe) mais qui a le mérite énorme d'offrir un code beaucoup plus clair et surtout d'éviter la duplication de code et ça, moi je dis, c'est une grande avancée. C'est dingue les portes que ça ouvre. Je sais que c'est pas très sage de migrer maintenant alors que les nouveautés de Tiger ne sont pas encore matures, mais tant pis j'anticipe. Voilà ce que ça donne...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
public class MD{
	//URI for vocabulary elements
	protected static final String uri = "http://www.epseelon.org/metadoc/elements/1.0/";
 
	//Return URI for vocabulary elements
	public static String getURI(){
		return uri;
	}
 
	/**
         * Uniquement la pour initialiser les membres suivants.
         */
	private static Model model = ModelFactory.createDefaultModel();
 
	/**
         * Ressources du modèle
         */
	public enum Resources{
		ELEMENT("Element"),
		DOCUMENT("Document"),
		WORKZONE("Workzone"),
		BOX("Box");
 
		private Resource resource;
 
		Resources(String name){
			resource = model.createResource(uri + name);
		}
 
		public Resource getResource(){
			return resource;
		}
	}
 
	/**
         * Propriétés du modèle
         */
	public enum Properties{
		WORKZONES("workzones"),
		PARENTS("parents"),
		SELECTED_WORKZONE("selectedWorkzone"),
		NAME("name"),
		IMAGE("image"),
		BOXES("boxes"),
		POSITION("position"),
		CONTENT("content"),
		FILTER("filter"),
		VOCABULARIES("vocabularies");
 
		private Property property;
 
		Properties(String name){
			property = model.createProperty(uri, name);
		}
 
		public Property getProperty(){
			return property;
		}
	}
}

Et là tout de suite c'est beaucoup plus clair je trouve.
Voilà, un petit exemple pour montrer ce qu'on peut faire avec les enum...

Et pour l'appel, ça peut se passer comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
res.addProperty(RDF.type,MD.Resources.DOCUMENT.getResource());

Ce qui a le mérite de préciser les choses sémantiquement et donc d'améliorer la lisibilité, même si ça allonge un peu le code par rapport à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
res.addProperty(RDF.type,MD.Document);

Ah ce Jimmy, quel homme !
Au passage gros merci à Lionel ROUX pour son excellente doc.[/code]

**rozwel** · 04/12/2004, 17h39

Finalement, après réflexion et essais, je crois que les enums sont surtout utiles pour l'aspect typesafe et donc pour des types ordinaux.

Après, chercher à tout prix à intégrer les nouveautés comme je l'ai fait sur du code qui n'est pas forcément adapté n'est pas l'idéal.

Là l'appel devenait long et redondant et ne justifiait pas le gain en duplication de code. Je suis donc revenu à la première solution et en tire la conclusion que les enum ne doivent pas remplacer tous les "public final static" mais uniquement les "public final static int".

Qu'en pensez-vous, avez-vous déjà trouvé une utilité plus poussée aux enums avec autres chose que des int ? Quel est le gain ?

**adiGuba** · 04/12/2004, 20h34

Le mot clé enum ne doit pas remplacer tous les static final...
Les énumérations permettent de définir des listes d'éléments finis qui définissent différentes possibilitées possibles, mais ne devrait pas servir à simplement regroupé des valeurs statiques...

En effet, les enum n'ont pas vocation à remplacer tous les static final. En fait le problème vient du fait que les static final étaient utilisés pour 'simuler' le enum du C/C++, comme tu peux le voir dans la FAQ :
http://java.developpez.com/faq/java/...GE_enumeration

Mais les enum de Java sont bien plus puissante étant donné que les différents éléments de l'énumérations ne sont pas seulement des int mais des objets (avec eventuellement des attributs et des méthodes), comme tu peux le voir dans le dernier exemple de l'article de Lionel Roux :
http://lroux.developpez.com/article/...e=page_2#Lenum

a++

[Java 5] Réflexion sur les énumérations type-safe

Langage Java

Discussions similaires

Partager

Partager