ENUMÉRATION AVEC UNE VERSION DE JAVA ANTÉRIEURE À LA 1.5
sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 2010
-
6 mars 2006 à 19:01
sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 2010
-
11 mars 2006 à 11:52
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 201017 11 mars 2006 à 11:52
a se stade peut etre mais ca ne tien qu'a toi de l'ameliorer pour la rendre bien et complete ^^
allez courage ^^
++
nightlord666
Messages postés746Date d'inscriptionvendredi 17 juin 2005StatutMembreDernière intervention23 mai 200710 11 mars 2006 à 11:50
Bon je pense que tu en a balancé assez pour que je comprenne que ma source est nulle...
verdy_p
Messages postés202Date d'inscriptionvendredi 27 janvier 2006StatutMembreDernière intervention29 janvier 2019 8 mars 2006 à 10:10
Attention: la classe ClassExtFactory maintient une référence permanente aux classes qui lui ont été soumises une seule fois. Si vous souhaitez pouvoir décharger les classes soumises une fois au factory,mais plus utilisées, il faut changer le type de HashMap utilisé pour déclarer son champ "classDirectory", par exemple avec une map utilisant des "SoftReference" vers l'objet Class en clé, et vers l'objet ClassExt en valeur de cette HashMap.
Cela n'est pas nécessaire en Java5 avec les types enum, car l'objet ClassExtn'y existe pas, et les champs correspondants ont la même durée de vie que la classe enum.
Cela reste donc une optimisation possible du code ci-dessus, dans une application de type serveur d'applications où il est nécessaire de pouvoir décharger une classe de la VM en supprimant toutes ses références, afin que ces classes d'énumérations puissent être libérées par le garbage-collector.
verdy_p
Messages postés202Date d'inscriptionvendredi 27 janvier 2006StatutMembreDernière intervention29 janvier 2019 8 mars 2006 à 09:42
Dernière subtilité: en Java5, deux constantes déclarées dans le même type "enum" nesont pas forcément de la même classe, bien que les types "enum" soient déclarés "final". Cela provient du fait que des constantes peuvent surcharger leurs méthodes, et cela crée une classe anonyme interne (finale elle aussi car anonyme) spécifique à cette constante, dont la superclasse est la classe "enum" déclarée englobante.
Aussi si A et B sont deux constantes du même type "enum", on n'a pas forcément:
A.class == B.class
(en effet A et B seront de types différents si l'une ou l'autre constante surcharge une méthode de l'enum déclarée).
Tout comme dans Java5, ici "getDeclaringClass()" doit être utilisé pour vérifier que deux contantes sont déclarées dans le même type enum, ou sont compatibles pour l'affectation dans une variable déclarée de ce type. Avec cette méthode on peut garantir:
A.getDeclaringClass() == B.getDeclaringClass()
si et seulement si A et B sont deux constantes déclarées dans la même énumération.
verdy_p
Messages postés202Date d'inscriptionvendredi 27 janvier 2006StatutMembreDernière intervention29 janvier 2019 8 mars 2006 à 09:22
Dernière notes: cette façon de procéder rend aussi les classes Enum comparables, sérializables, et utilisables aussi comme clés dans une Map. Elle respecte aussi l'égalité par == ou equals(), et les constantes sont aussi affichables symboliquement. Et tout comme les "enum" de Java5, ces constantes ont aussi un ordinal associé qu'on obtient avec la méthode "int Enum.ordinal()", et un nom obtenu par "String Enum.name()"...
Evidemment il manque encore une émulation pour Reflection, impossible à réaliser avec les packages de réflexion de Java (il faudra en réécrire une partie pour émuler certainsattributs et le fait que certaines méthodes sont dans ClassExt et non dans java.lang.Class (c'est à ça que sert la classe ClassExtFactory: à faire le relaidesméthodesnormalement implantées dans java.lang.Class, sauf que làtoutes les méthodes y sont statiques, et qu'il faut passer la classe en paramètre des méthodes non statiques de "java.lang.Class", et non implicitement dans "this").
verdy_p
Messages postés202Date d'inscriptionvendredi 27 janvier 2006StatutMembreDernière intervention29 janvier 2019 8 mars 2006 à 09:00
Dernière note: en Java5, une constante enum peut avoir ses propres méthodes. Dans ce cas, une telle constante déclare une classe interne anonyme, dont il suffit de mettre le corps juste après l'appel de son constructeur:
Par exemple pour convertir:
enum T1 {
...
A {
/* déclarer les méthodes spécifiques pour A ici... */
},
...
};
on remplacera:
_VALUES = new T2[] {
...
new T2("A", 0),
...
};
simplement par:
_VALUES = new T2[] {
...
new T2("A", 0) {
/* déclarer les méthodes spécifiques pour A ici */
},
...
};
verdy_p
Messages postés202Date d'inscriptionvendredi 27 janvier 2006StatutMembreDernière intervention29 janvier 2019 8 mars 2006 à 08:51
Note: ce programme ne nécessite pas Java5 si vous supprimez les quelques lignes contenant T1 dans le programme de test. T2 compile en Java1 (v1.1.8) ou Java2 (3.1, 4.0...).
ClassExt contients des champs et méthodes présentes uniquement depuis Java5 dans java.lang.Class. On pourrait y ajouter le support des annotations ou uneemulation de la généricité, et créer avec un classloader supportant la sémantique Java5.
ClassExtFactory est une classe utilitaire permetant de lier les méthodes qui manquent dans java.lang.Class. On pourrait encore l'améliorer un peu en utilisant des SoftReference.
Avec ce code,ce n'est plus très compliqué de convertir un "enum" de Java5 en Java2. Suivez l'exemple commenté de la déclaration de T2: la seule chose à faire est de changer les noms de constantes A et B (ou d'en ajouter) et d'affecter des ordinaux à chacun dans la déclaration du tableau privé _VALUES...
verdy_p
Messages postés202Date d'inscriptionvendredi 27 janvier 2006StatutMembreDernière intervention29 janvier 2019 8 mars 2006 à 08:39
La sémantique n'est pas correcte (singletons, finalité, nom et ordinal, etc...) et ne reproduit pas le comportement de l'enum de Java5.
Une version nettement meilleure figure ci-dessous avec un exemple de déclaration de classe (T2)comparée à un enum (T1), une petite classe de test montrant l'utilisation (Test), et des classes utilitaires àmettre dans une librairie (Enum, ClassExtFactory, ClassExt):
import java.util.Map;
import java.util.HashMap;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.PrivilegedAction;
/*
** Run test, display comparable results.
*/
public final class Test {
public static void main(String[]args){
T1 x1;
T2 x2;
/**
** enum class declaration in Java5 (all declared enum classes are
** implicitly final in Java5, and extend java.lang.Enum).
*/
enum T1 { A, B };
/**
* enum class declaration in Java1 ou Java2. Fully commented because
* this should be an example showing how to emulate the previous
* declaration.
*/
final class T2 extends Enum {
/**
* These fields are compiled exactly like in Java5 enum classes.
*/
public static final T2 A, B;
/**
* In Java5 enum classes, this private field is named "$VALUES" and
* is generated intrisicly.
*/
private static final T2[] _VALUES;
/**
* The Java5 compiler builds this same method intrinsicly for enums.
*/
public static T2[] values() {
return (T2[]) _VALUES.clone();
}
/**
* The Java5 compiler builds this same method intrinsicly for enums.
*/
public static T2 valueOf(final String name) {
return (T2) Enum.valueOf(T2.class, name);
}
/**
* The Java5 compiler builds this same constructor intrisicly for enums,
* but we need to declare it ourself in this class, because it has no
* default constructor.
*/
private T2(final String name, final int ordinal) {
super(name, ordinal);
}
/**
* This initializer is exactly what the Java5 compler builds intrinsicly
* for enum classes.
*/
static {
A = (T2)new T2("A", 0);
B = (T2)new T2("B", 1);
_VALUES = new T2[]{ A, B };
};
};
/*
** Common base abstract class for all enum classes declared in Java5
** package java.lang; You can can put this class in a library package.
*/
abstract class Enum implements Comparable, Serializable {
private final String name;
private final int ordinal;
public final String name() { return name; }
public final int ordinal() { return ordinal; }
protected Enum(final String name, final int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
public String toString() { return name; }
public final boolean equals(final Object o) { return this == o; }
public final int hashCode() { return System.identityHashCode(this); }
protected final Object clone() throws CloneNotSupportedException {
return new CloneNotSupportedException();
}
public final Class getDeclaringClass() {
final Class clazz = getClass();
final Class superclazz = clazz.getSuperclass();
return (superclazz == Enum.class) ? clazz : superclazz;
}
protected final int compareTo(final Enum e){
if (e.getClass() == this.getClass() &&
e.getDeclaringClass() == this.getDeclaringClass())
return e.ordinal - this.ordinal;
throw new ClassCastException();
}
public int compareTo(final Object o) {
return ((Enum)o).compareTo(this);
}
public static Enum valueOf(final Class enumClass, final String name) {
/*
** Normally the java.lang.Class class in Java5 declares the following method:
** public java.util.Map enumConstantDirectory();
*/
final Enum value;
if ((value = (Enum)
ClassExtFactory.enumConstantDirectory(enumClass).get(name)) !=
null)
return value;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException("No enum const " +
enumClass + "." + name);
}
}
/**
* This class is just a helper that shows how the Java5 classloader
* can build a map from constant names to enum values. Actually, this
* map is built in Java5 lazily only for enum classes when the
* java.lang.Class.enumConstantDirectory() method is called, and stored
* in a new member field of the Class instance.
*/
final class ClassExtFactory {// virtually extends java.lang.Class
/**
* This map will map enum Class objects to the additional attributes
* such as the enumConstantDirectory field which is absent in Java1 or Java2.
* In Java5, those attributes are implemented natively in java.lang.Class.
* Here the only Class attribute we need to emulate is the constant directory
* and the enumConstants array which are volatile transient fields.
*/
private static Map/*<Class, ClassExt>*/ classDirectory =
new HashMap/*<Class, ClassExt>*/();
private static ClassExt getInstance(final Class clazz) {
ClassExt classExt;
synchronized (classDirectory) {
if ((classExt (ClassExt)classDirectory.get(clazz)) null) {
classDirectory.put(clazz,
classExt = new ClassExt(clazz));
}
}
return classExt;
}
public static boolean isEnum(final Class clazz) {
return getInstance(clazz).isEnum();
}
public static Object[] getEnumConstants(final Class clazz) {
return getInstance(clazz).getEnumConstants();
}
public static Map enumConstantDirectory(final Class clazz) {
return getInstance(clazz).enumConstantDirectory();
}
}
/**
* This stores extra fields missing in java.lang.Class
* with Java1 or Java2, but added since Java5.
* We can't extend java.lang.Class because it's final.
* So we will store those fields in an extension class
* mapped from standard Class objects with another helper
* class ClassExtHelper below.
*/
final class ClassExt {
/** backward reference to unextended Class object */
private final transient Class clazz;
/*===================================*/
/* Additional Class fields in Java5. */
/*===================================*/
/**
* Caches the clazz.values() returned from enum classes
*/
private volatile transient Object[] enumConstants;
/**
* Caches the map of names to values
*/
private volatile transient Map enumConstantDirectory;
/**
* The Java5 runtime adds this to the Class() constructor.
*/
ClassExt(final Class clazz) {
this.clazz = clazz; /* only for backward reference */
enumConstants = null; /* initialized lazily */
enumConstantDirectory = null; /* initialized lazily */
}
public boolean isEnum() {
return clazz.getSuperclass() == Enum.class;
}
public Object[] getEnumConstants() {
if (enumConstants == null) {
if (!isEnum())
return null;
try {
final Method values = clazz.getMethod("values", new Class[]{});
AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
values.setAccessible(true);
return null;
}
});
enumConstants = (Object[]) values.invoke(null, new Object[]{});
} catch (InvocationTargetException e) {
return null;
} catch (NoSuchMethodException e) {
return null;
} catch (IllegalAccessException e) {
return null;
}
}
return (Object[]) enumConstants.clone();
}
public Map enumConstantDirectory() {
if (enumConstantDirectory == null) {
final Object[] values;
if ((values getEnumConstants()) null) {
throw new IllegalArgumentException(
clazz.getName() + " is not an enum type");
}
final HashMap directory = new HashMap(values.length * 2);
for (int index = values.length; --index >= 0; ) {
final Object value;
directory.put(((Enum) (value = values[index])).name(), value);
}
enumConstantDirectory = directory;
}
return enumConstantDirectory;
}
}
Twinuts
Messages postés5375Date d'inscriptiondimanche 4 mai 2003StatutModérateurDernière intervention14 juin 2023111 7 mars 2006 à 09:37
Oups merdouille j'ai pas fais gaffe au final en debut :( dsl pour ce commentaire foireux :(
nightlord666
Messages postés746Date d'inscriptionvendredi 17 juin 2005StatutMembreDernière intervention23 mai 200710 7 mars 2006 à 06:51
Non on est pas obligé de faire commencer une variable par une minuscule, et en plus ce sont des constantes
Twinuts
Messages postés5375Date d'inscriptiondimanche 4 mai 2003StatutModérateurDernière intervention14 juin 2023111 6 mars 2006 à 23:39
Salut,
je rejoint sheorogath .....
de plus c'est pas super ressemblant...
juste au passage en java une variable commence par une minuscule...
nightlord666
Messages postés746Date d'inscriptionvendredi 17 juin 2005StatutMembreDernière intervention23 mai 200710 6 mars 2006 à 19:24
C'est utile dans le fait que ça n'oblige pas à mettre à jour la version de JAVA chez le client à cause d'une énumération.
OK, ce n'est pas très utile pour les PC mais pour les portables (téléphones avec J2ME) assez anciens, ça peut-être utile car je n'ai jamais reussi à mettre le mien à jour(je me demande d'ailleurs si c'est possible...)
sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 201017 6 mars 2006 à 19:01
heuu je n'arrive pas a voir l'utilité de ta source ...
11 mars 2006 à 11:52
allez courage ^^
++
11 mars 2006 à 11:50
8 mars 2006 à 10:10
Cela n'est pas nécessaire en Java5 avec les types enum, car l'objet ClassExtn'y existe pas, et les champs correspondants ont la même durée de vie que la classe enum.
Cela reste donc une optimisation possible du code ci-dessus, dans une application de type serveur d'applications où il est nécessaire de pouvoir décharger une classe de la VM en supprimant toutes ses références, afin que ces classes d'énumérations puissent être libérées par le garbage-collector.
8 mars 2006 à 09:42
Aussi si A et B sont deux constantes du même type "enum", on n'a pas forcément:
A.class == B.class
(en effet A et B seront de types différents si l'une ou l'autre constante surcharge une méthode de l'enum déclarée).
Tout comme dans Java5, ici "getDeclaringClass()" doit être utilisé pour vérifier que deux contantes sont déclarées dans le même type enum, ou sont compatibles pour l'affectation dans une variable déclarée de ce type. Avec cette méthode on peut garantir:
A.getDeclaringClass() == B.getDeclaringClass()
si et seulement si A et B sont deux constantes déclarées dans la même énumération.
8 mars 2006 à 09:22
Evidemment il manque encore une émulation pour Reflection, impossible à réaliser avec les packages de réflexion de Java (il faudra en réécrire une partie pour émuler certainsattributs et le fait que certaines méthodes sont dans ClassExt et non dans java.lang.Class (c'est à ça que sert la classe ClassExtFactory: à faire le relaidesméthodesnormalement implantées dans java.lang.Class, sauf que làtoutes les méthodes y sont statiques, et qu'il faut passer la classe en paramètre des méthodes non statiques de "java.lang.Class", et non implicitement dans "this").
8 mars 2006 à 09:00
Par exemple pour convertir:
enum T1 {
...
A {
/* déclarer les méthodes spécifiques pour A ici... */
},
...
};
on remplacera:
_VALUES = new T2[] {
...
new T2("A", 0),
...
};
simplement par:
_VALUES = new T2[] {
...
new T2("A", 0) {
/* déclarer les méthodes spécifiques pour A ici */
},
...
};
8 mars 2006 à 08:51
ClassExt contients des champs et méthodes présentes uniquement depuis Java5 dans java.lang.Class. On pourrait y ajouter le support des annotations ou uneemulation de la généricité, et créer avec un classloader supportant la sémantique Java5.
ClassExtFactory est une classe utilitaire permetant de lier les méthodes qui manquent dans java.lang.Class. On pourrait encore l'améliorer un peu en utilisant des SoftReference.
Avec ce code,ce n'est plus très compliqué de convertir un "enum" de Java5 en Java2. Suivez l'exemple commenté de la déclaration de T2: la seule chose à faire est de changer les noms de constantes A et B (ou d'en ajouter) et d'affecter des ordinaux à chacun dans la déclaration du tableau privé _VALUES...
8 mars 2006 à 08:39
Une version nettement meilleure figure ci-dessous avec un exemple de déclaration de classe (T2)comparée à un enum (T1), une petite classe de test montrant l'utilisation (Test), et des classes utilitaires àmettre dans une librairie (Enum, ClassExtFactory, ClassExt):
import java.util.Map;
import java.util.HashMap;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.PrivilegedAction;
/*
** Run test, display comparable results.
*/
public final class Test {
public static void main(String[]args){
T1 x1;
T2 x2;
x1 = T1.A;
System.out.println("A: T1 x1=" + x1 + ": ordinal=" + x1.ordinal());
x2 = T2.A;
System.out.println("A: T2 x2=" + x2 + ": ordinal=" + x2.ordinal());
System.out.println();
x1 = T1.B;
System.out.println("B: T1 x1=" + x1 + ": ordinal=" + x1.ordinal());
x2 = T2.B;
System.out.println("B: T2 x1=" + x2 + ": ordinal=" + x2.ordinal());
System.out.println();
x1 = T1.valueOf("A");
System.out.println("valueOf("A"): T1 x1=" + x1 + ": (== T1.A)=" + (x1 == T1.A));
x2 = T2.valueOf("A");
System.out.println("valueOf("A"): T2 x2=" + x2 + ": (== T2.A)=" + (x2 == T2.A));
System.out.println();
x1 = T1.valueOf("B");
System.out.println("valueOf("B"): T1 x1=" + x1 + ": (== T1.B)=" + (x1 == T1.B));
x2 = T2.valueOf("B");
System.out.println("valueOf("B"): T2 x2=" + x2 + ": (== T2.B)=" + (x2 == T2.B));
System.out.println();
}
}
/**
** enum class declaration in Java5 (all declared enum classes are
** implicitly final in Java5, and extend java.lang.Enum).
*/
enum T1 { A, B };
/**
* enum class declaration in Java1 ou Java2. Fully commented because
* this should be an example showing how to emulate the previous
* declaration.
*/
final class T2 extends Enum {
/**
* These fields are compiled exactly like in Java5 enum classes.
*/
public static final T2 A, B;
/**
* In Java5 enum classes, this private field is named "$VALUES" and
* is generated intrisicly.
*/
private static final T2[] _VALUES;
/**
* The Java5 compiler builds this same method intrinsicly for enums.
*/
public static T2[] values() {
return (T2[]) _VALUES.clone();
}
/**
* The Java5 compiler builds this same method intrinsicly for enums.
*/
public static T2 valueOf(final String name) {
return (T2) Enum.valueOf(T2.class, name);
}
/**
* The Java5 compiler builds this same constructor intrisicly for enums,
* but we need to declare it ourself in this class, because it has no
* default constructor.
*/
private T2(final String name, final int ordinal) {
super(name, ordinal);
}
/**
* This initializer is exactly what the Java5 compler builds intrinsicly
* for enum classes.
*/
static {
A = (T2)new T2("A", 0);
B = (T2)new T2("B", 1);
_VALUES = new T2[]{ A, B };
};
};
/*
** Common base abstract class for all enum classes declared in Java5
** package java.lang; You can can put this class in a library package.
*/
abstract class Enum implements Comparable, Serializable {
private final String name;
private final int ordinal;
public final String name() { return name; }
public final int ordinal() { return ordinal; }
protected Enum(final String name, final int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
public String toString() { return name; }
public final boolean equals(final Object o) { return this == o; }
public final int hashCode() { return System.identityHashCode(this); }
protected final Object clone() throws CloneNotSupportedException {
return new CloneNotSupportedException();
}
public final Class getDeclaringClass() {
final Class clazz = getClass();
final Class superclazz = clazz.getSuperclass();
return (superclazz == Enum.class) ? clazz : superclazz;
}
protected final int compareTo(final Enum e){
if (e.getClass() == this.getClass() &&
e.getDeclaringClass() == this.getDeclaringClass())
return e.ordinal - this.ordinal;
throw new ClassCastException();
}
public int compareTo(final Object o) {
return ((Enum)o).compareTo(this);
}
public static Enum valueOf(final Class enumClass, final String name) {
/*
** Normally the java.lang.Class class in Java5 declares the following method:
** public java.util.Map enumConstantDirectory();
*/
final Enum value;
if ((value = (Enum)
ClassExtFactory.enumConstantDirectory(enumClass).get(name)) !=
null)
return value;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException("No enum const " +
enumClass + "." + name);
}
}
/**
* This class is just a helper that shows how the Java5 classloader
* can build a map from constant names to enum values. Actually, this
* map is built in Java5 lazily only for enum classes when the
* java.lang.Class.enumConstantDirectory() method is called, and stored
* in a new member field of the Class instance.
*/
final class ClassExtFactory {// virtually extends java.lang.Class
/**
* This map will map enum Class objects to the additional attributes
* such as the enumConstantDirectory field which is absent in Java1 or Java2.
* In Java5, those attributes are implemented natively in java.lang.Class.
* Here the only Class attribute we need to emulate is the constant directory
* and the enumConstants array which are volatile transient fields.
*/
private static Map/*<Class, ClassExt>*/ classDirectory =
new HashMap/*<Class, ClassExt>*/();
private static ClassExt getInstance(final Class clazz) {
ClassExt classExt;
synchronized (classDirectory) {
if ((classExt (ClassExt)classDirectory.get(clazz)) null) {
classDirectory.put(clazz,
classExt = new ClassExt(clazz));
}
}
return classExt;
}
public static boolean isEnum(final Class clazz) {
return getInstance(clazz).isEnum();
}
public static Object[] getEnumConstants(final Class clazz) {
return getInstance(clazz).getEnumConstants();
}
public static Map enumConstantDirectory(final Class clazz) {
return getInstance(clazz).enumConstantDirectory();
}
}
/**
* This stores extra fields missing in java.lang.Class
* with Java1 or Java2, but added since Java5.
* We can't extend java.lang.Class because it's final.
* So we will store those fields in an extension class
* mapped from standard Class objects with another helper
* class ClassExtHelper below.
*/
final class ClassExt {
/** backward reference to unextended Class object */
private final transient Class clazz;
/*===================================*/
/* Additional Class fields in Java5. */
/*===================================*/
/**
* Caches the clazz.values() returned from enum classes
*/
private volatile transient Object[] enumConstants;
/**
* Caches the map of names to values
*/
private volatile transient Map enumConstantDirectory;
/**
* The Java5 runtime adds this to the Class() constructor.
*/
ClassExt(final Class clazz) {
this.clazz = clazz; /* only for backward reference */
enumConstants = null; /* initialized lazily */
enumConstantDirectory = null; /* initialized lazily */
}
public boolean isEnum() {
return clazz.getSuperclass() == Enum.class;
}
public Object[] getEnumConstants() {
if (enumConstants == null) {
if (!isEnum())
return null;
try {
final Method values = clazz.getMethod("values", new Class[]{});
AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
values.setAccessible(true);
return null;
}
});
enumConstants = (Object[]) values.invoke(null, new Object[]{});
} catch (InvocationTargetException e) {
return null;
} catch (NoSuchMethodException e) {
return null;
} catch (IllegalAccessException e) {
return null;
}
}
return (Object[]) enumConstants.clone();
}
public Map enumConstantDirectory() {
if (enumConstantDirectory == null) {
final Object[] values;
if ((values getEnumConstants()) null) {
throw new IllegalArgumentException(
clazz.getName() + " is not an enum type");
}
final HashMap directory = new HashMap(values.length * 2);
for (int index = values.length; --index >= 0; ) {
final Object value;
directory.put(((Enum) (value = values[index])).name(), value);
}
enumConstantDirectory = directory;
}
return enumConstantDirectory;
}
}
7 mars 2006 à 09:37
7 mars 2006 à 06:51
6 mars 2006 à 23:39
je rejoint sheorogath .....
de plus c'est pas super ressemblant...
juste au passage en java une variable commence par une minuscule...
6 mars 2006 à 19:24
OK, ce n'est pas très utile pour les PC mais pour les portables (téléphones avec J2ME) assez anciens, ça peut-être utile car je n'ai jamais reussi à mettre le mien à jour(je me demande d'ailleurs si c'est possible...)
6 mars 2006 à 19:01