Peut-on subdiviser les enums pour ajouter de nouveaux éléments?
Je veux prendre une énumération existante et y ajouter d'autres éléments comme suit:
enum A {a,b,c}
enum B extends A {d}
/*B is {a,b,c,d}*/
Est-ce possible en Java?
Non, vous ne pouvez pas faire cela en Java. En dehors de toute autre chose, d serait alors vraisemblablement un exemple de A (étant donné l’idée normale de "rallonge"), mais les utilisateurs ne connaissant que A ne le sauraient pas. - qui défait le point d'une enum étant un ensemble de valeurs bien connu.
Si vous pouviez nous en dire plus sur la façon dont vous voulez tiliser ceci, nous pourrions potentiellement suggérer des solutions alternatives.
Les énumérations représentent une énumération complète des valeurs possibles. Donc, la réponse (inutile) est non.
Par exemple, prenons les jours de la semaine, les week-ends et le syndicat, les jours de la semaine. Nous pourrions définir tous les jours de la semaine, mais nous ne serions pas en mesure de représenter des propriétés spéciales en jours de semaine et de week-end.
Ce que nous pourrions faire, c’est avoir trois types d’énumérations avec une correspondance entre les jours de la semaine/week-end et les jours de la semaine.
public enum Weekday {
MON, TUE, WED, THU, FRI;
public DayOfWeek toDayOfWeek() { ... }
}
public enum WeekendDay {
SAT, Sun;
public DayOfWeek toDayOfWeek() { ... }
}
public enum DayOfWeek {
MON, TUE, WED, THU, FRI, SAT, Sun;
}
Alternativement, nous pourrions avoir une interface ouverte pour le jour de la semaine:
interface Day {
...
}
public enum Weekday implements Day {
MON, TUE, WED, THU, FRI;
}
public enum WeekendDay implements Day {
SAT, Sun;
}
Ou nous pourrions combiner les deux approches:
interface Day {
...
}
public enum Weekday implements Day {
MON, TUE, WED, THU, FRI;
public DayOfWeek toDayOfWeek() { ... }
}
public enum WeekendDay implements Day {
SAT, Sun;
public DayOfWeek toDayOfWeek() { ... }
}
public enum DayOfWeek {
MON, TUE, WED, THU, FRI, SAT, Sun;
public Day toDay() { ... }
}
La solution recommandée est le modèle de énumération extensible .
Cela implique la création d'une interface et l'utilisation de celle où vous utilisez actuellement l'énum. Ensuite, faites enum implémenter l'interface. Vous pouvez ajouter plus de constantes en faisant en sorte que cette nouvelle énumération étende également l'interface.
Sous les couvertures, votre ENUM est juste une classe régulière générée par le compilateur. Cette classe générée étend Java.lang.Enum. La raison technique pour laquelle vous ne pouvez pas étendre la classe générée est que la classe générée est final. Les raisons conceptuelles de sa finalisation sont discutées dans cette rubrique. Mais je vais ajouter les mécanismes à la discussion.
Voici un test enum:
public enum TEST {
ONE, TWO, THREE;
}
Le code résultant de javap:
public final class TEST extends Java.lang.Enum<TEST> {
public static final TEST ONE;
public static final TEST TWO;
public static final TEST THREE;
static {};
public static TEST[] values();
public static TEST valueOf(Java.lang.String);
}
Il est concevable que vous puissiez taper cette classe vous-même et abandonner la "finale". Mais le compilateur vous empêche d’étendre directement "Java.lang.Enum". Vous pourriez décider de NE PAS étendre Java.lang.Enum, mais votre classe et ses classes dérivées ne seraient pas une instance de Java.lang.Enum ... qui ne vous importerait pas vraiment!
enum A {a,b,c}
enum B extends A {d}
/*B is {a,b,c,d}*/
peut être écrit comme:
public enum All {
a (ClassGroup.A,ClassGroup.B),
b (ClassGroup.A,ClassGroup.B),
c (ClassGroup.A,ClassGroup.B),
d (ClassGroup.B)
...
- ClassGroup.B.getMembers () contient {a, b, c, d}
Comment cela peut être utile: Disons que nous voulons quelque chose comme: Nous avons des événements et nous utilisons des enums. Ces énumérations peuvent être regroupées par un traitement similaire. Si nous avons une opération avec de nombreux éléments, alors certains événements démarrent, d'autres ne sont que des étapes et d'autres terminent l'opération. Pour rassembler une telle opération et éviter de longs cas de commutation, nous pouvons les regrouper comme dans l'exemple et utiliser:
if(myEvent.is(State_StatusGroup.START)) makeNewOperationObject()..
if(myEnum.is(State_StatusGroup.STEP)) makeSomeSeriousChanges()..
if(myEnum.is(State_StatusGroup.FINISH)) closeTransactionOrSomething()..
Exemple:
public enum AtmOperationStatus {
STARTED_BY_SERVER (State_StatusGroup.START),
SUCCESS (State_StatusGroup.FINISH),
FAIL_TOKEN_TIMEOUT (State_StatusGroup.FAIL,
State_StatusGroup.FINISH),
FAIL_NOT_COMPLETE (State_StatusGroup.FAIL,
State_StatusGroup.STEP),
FAIL_UNKNOWN (State_StatusGroup.FAIL,
State_StatusGroup.FINISH),
(...)
private AtmOperationStatus(StatusGroupInterface ... pList){
for (StatusGroupInterface group : pList){
group.addMember(this);
}
}
public boolean is(StatusGroupInterface with){
for (AtmOperationStatus eT : with.getMembers()){
if( eT .equals(this)) return true;
}
return false;
}
// Each group must implement this interface
private interface StatusGroupInterface{
EnumSet<AtmOperationStatus> getMembers();
void addMember(AtmOperationStatus pE);
}
// DEFINING GROUPS
public enum State_StatusGroup implements StatusGroupInterface{
START, STEP, FAIL, FINISH;
private List<AtmOperationStatus> members = new LinkedList<AtmOperationStatus>();
@Override
public EnumSet<AtmOperationStatus> getMembers() {
return EnumSet.copyOf(members);
}
@Override
public void addMember(AtmOperationStatus pE) {
members.add(pE);
}
static { // forcing initiation of dependent enum
try {
Class.forName(AtmOperationStatus.class.getName());
} catch (ClassNotFoundException ex) {
throw new RuntimeException("Class AtmEventType not found", ex);
}
}
}
}
//Some use of upper code:
if (p.getStatus().is(AtmOperationStatus.State_StatusGroup.FINISH)) {
//do something
}else if (p.getStatus().is(AtmOperationStatus.State_StatusGroup.START)) {
//do something
}
Ajoutez un peu plus avancé:
public enum AtmEventType {
USER_DEPOSIT (Status_EventsGroup.WITH_STATUS,
Authorization_EventsGroup.USER_AUTHORIZED,
ChangedMoneyAccountState_EventsGroup.CHANGED,
OperationType_EventsGroup.DEPOSIT,
ApplyTo_EventsGroup.CHANNEL),
SERVICE_DEPOSIT (Status_EventsGroup.WITH_STATUS,
Authorization_EventsGroup.TERMINAL_AUTHORIZATION,
ChangedMoneyAccountState_EventsGroup.CHANGED,
OperationType_EventsGroup.DEPOSIT,
ApplyTo_EventsGroup.CHANNEL),
DEVICE_MALFUNCTION (Status_EventsGroup.WITHOUT_STATUS,
Authorization_EventsGroup.TERMINAL_AUTHORIZATION,
ChangedMoneyAccountState_EventsGroup.DID_NOT_CHANGED,
ApplyTo_EventsGroup.DEVICE),
CONFIGURATION_4_C_CHANGED(Status_EventsGroup.WITHOUT_STATUS,
ApplyTo_EventsGroup.TERMINAL,
ChangedMoneyAccountState_EventsGroup.DID_NOT_CHANGED),
(...)
En haut, si nous avons des échecs (myEvent.is (State_StatusGroup.FAIL)), puis, en répétant les événements précédents, nous pouvons facilement vérifier si nous devons annuler le transfert d'argent par:
if(myEvent2.is(ChangedMoneyAccountState_EventsGroup.CHANGED)) rollBack()..
Cela peut être utile pour:
- y compris des méta-données explicite sur la logique de traitement, moins à retenir
- mettre en œuvre une partie du multi-héritage
- nous ne voulons pas utiliser les structures de classe, ex. pour l'envoi de messages d'état courts
Voici une façon dont j'ai trouvé comment étendre une énumération en une autre, est une approche très directe:
Vous avez une énumération avec des constantes communes:
public interface ICommonInterface {
String getName();
}
public enum CommonEnum implements ICommonInterface {
P_EDITABLE("editable"),
P_ACTIVE("active"),
P_ID("id");
private final String name;
EnumCriteriaComun(String name) {
name= name;
}
@Override
public String getName() {
return this.name;
}
}
alors vous pouvez essayer de faire un manuel étend de cette façon:
public enum SubEnum implements ICommonInterface {
P_EDITABLE(CommonEnum.P_EDITABLE ),
P_ACTIVE(CommonEnum.P_ACTIVE),
P_ID(CommonEnum.P_ID),
P_NEW_CONSTANT("new_constant");
private final String name;
EnumCriteriaComun(CommonEnum commonEnum) {
name= commonEnum.name;
}
EnumCriteriaComun(String name) {
name= name;
}
@Override
public String getName() {
return this.name;
}
}
bien sûr, chaque fois que vous avez besoin d'étendre une constante, vous devez modifier vos fichiers SubEnum.
Au cas où vous l'auriez manqué, l'excellent livre de Joshua Bloch intitulé " Java Effective, 2nd edition " contient un chapitre.
- Chapitre 6 - Enums et annotations
- Elément 34: Émuler des énumérations extensibles avec des interfaces
Extrait ici .
Juste la conclusion:
Un inconvénient mineur de l'utilisation d'interfaces pour émuler des énumérations extensibles est que les implémentations ne peuvent pas être héritées d'un type enum à un autre. Dans le cas de notre exemple Operation, la logique de stockage et de récupération du symbole associé à une opération est dupliquée dans BasicOperation et ExtendedOperation. Dans ce cas, cela n’a aucune importance, car très peu de code est dupliqué. Si le nombre de fonctionnalités partagées était plus important, vous pouvez l'encapsuler dans une classe d'assistance ou une méthode d'assistance statique pour éliminer la duplication de code.
En résumé, bien que vous ne puissiez pas écrire un type enum extensible, vous pouvez l'émuler en écrivant une interface associée à un type enum de base qui implémente l'interface. Cela permet aux clients d'écrire leurs propres énumérations qui implémentent l'interface. Ces énumérations peuvent ensuite être utilisées partout où le type d’énumération de base peut être utilisé, en supposant que les API sont écrites en termes d’interface.
C'est ainsi que j'améliore le modèle d'héritage enum avec la vérification de l'exécution dans un initialiseur statique. Le BaseKind#checkEnumExtender vérifie que "l 'extension" enum déclare toutes les valeurs de la base enum exactement de la même manière, de sorte que #name() et #ordinal() restent parfaitement compatibles.
Un copier-coller est toujours nécessaire pour déclarer des valeurs, mais le programme échoue rapidement si quelqu'un ajoute ou modifie une valeur dans la classe de base sans mettre à jour les valeurs en extension.
Comportement commun pour différents énumérations se prolongeant mutuellement:
public interface Kind {
/**
* Let's say we want some additional member.
*/
String description() ;
/**
* Standard {@code Enum} method.
*/
String name() ;
/**
* Standard {@code Enum} method.
*/
int ordinal() ;
}
Base enum, avec méthode de vérification:
public enum BaseKind implements Kind {
FIRST( "First" ),
SECOND( "Second" ),
;
private final String description ;
public String description() {
return description ;
}
private BaseKind( final String description ) {
this.description = description ;
}
public static void checkEnumExtender(
final Kind[] baseValues,
final Kind[] extendingValues
) {
if( extendingValues.length < baseValues.length ) {
throw new IncorrectExtensionError( "Only " + extendingValues.length + " values against "
+ baseValues.length + " base values" ) ;
}
for( int i = 0 ; i < baseValues.length ; i ++ ) {
final Kind baseValue = baseValues[ i ] ;
final Kind extendingValue = extendingValues[ i ] ;
if( baseValue.ordinal() != extendingValue.ordinal() ) {
throw new IncorrectExtensionError( "Base ordinal " + baseValue.ordinal()
+ " doesn't match with " + extendingValue.ordinal() ) ;
}
if( ! baseValue.name().equals( extendingValue.name() ) ) {
throw new IncorrectExtensionError( "Base name[ " + i + "] " + baseValue.name()
+ " doesn't match with " + extendingValue.name() ) ;
}
if( ! baseValue.description().equals( extendingValue.description() ) ) {
throw new IncorrectExtensionError( "Description[ " + i + "] " + baseValue.description()
+ " doesn't match with " + extendingValue.description() ) ;
}
}
}
public static class IncorrectExtensionError extends Error {
public IncorrectExtensionError( final String s ) {
super( s ) ;
}
}
}
Exemple d'extension:
public enum ExtendingKind implements Kind {
FIRST( BaseKind.FIRST ),
SECOND( BaseKind.SECOND ),
THIRD( "Third" ),
;
private final String description ;
public String description() {
return description ;
}
ExtendingKind( final BaseKind baseKind ) {
this.description = baseKind.description() ;
}
ExtendingKind( final String description ) {
this.description = description ;
}
}
J'ai tendance à éviter les enums, car ils ne sont pas extensibles. Pour rester avec l'exemple de l'OP, si A est dans une bibliothèque et B dans votre propre code, vous ne pouvez pas étendre A s'il s'agit d'une énumération. Voici comment je remplace parfois des enums:
// access like enum: A.a
public class A {
public static final A a = new A();
public static final A b = new A();
public static final A c = new A();
/*
* In case you need to identify your constant
* in different JVMs, you need an id. This is the case if
* your object is transfered between
* different JVM instances (eg. save/load, or network).
* Also, switch statements don't work with
* Objects, but work with int.
*/
public static int maxId=0;
public int id = maxId++;
public int getId() { return id; }
}
public class B extends A {
/*
* good: you can do like
* A x = getYourEnumFromSomeWhere();
* if(x instanceof B) ...;
* to identify which enum x
* is of.
*/
public static final A d = new A();
}
public class C extends A {
/* Good: e.getId() != d.getId()
* Bad: in different JVMs, C and B
* might be initialized in different order,
* resulting in different IDs.
* Workaround: use a fixed int, or hash code.
*/
public static final A e = new A();
public int getId() { return -32489132; };
}
Il y a quelques fosses à éviter, voir les commentaires dans le code. Selon vos besoins, il s’agit d’une alternative solide et extensible aux enums.
Basé sur @Tom Hawtin - tackline répondons que nous ajoutons un support de commutateur,
interface Day<T> {
...
T valueOf();
}
public enum Weekday implements Day<Weekday> {
MON, TUE, WED, THU, FRI;
Weekday valueOf(){
return valueOf(name());
}
}
public enum WeekendDay implements Day<WeekendDay> {
SAT, Sun;
WeekendDay valueOf(){
return valueOf(name());
}
}
Day<Weekday> wds = Weekday.MON;
Day<WeekendDay> wends = WeekendDay.Sun;
switch(wds.valueOf()){
case MON:
case TUE:
case WED:
case THU:
case FRI:
}
switch(wends.valueOf()){
case SAT:
case Sun:
}
Je vous suggère de prendre l'approche inverse.
Au lieu d'étendre l'énumération existante, créez-en une plus grande et créez-en un sous-ensemble. Par exemple, si vous avez une énumération appelée PET et que vous souhaitez l'étendre à ANIMAL, vous devez le faire à la place:
public enum ANIMAL {
WOLF,CAT, DOG
}
EnumSet<ANIMAL> pets = EnumSet.of(ANIMAL.CAT, ANIMAL.DOG);
Attention, pets n'est pas une collection immuable, vous pouvez utiliser Guava ou Java9 pour plus de sécurité.
Ayant moi-même eu le même problème, j'aimerais publier mon point de vue. Je pense qu'il existe quelques facteurs de motivation pour faire quelque chose comme ceci:
- Vous voulez avoir des codes enum liés, mais dans des classes différentes. Dans mon cas, j'avais une classe de base avec plusieurs codes définis dans un enum associé. À une date ultérieure (aujourd'hui!), Je souhaitais fournir de nouvelles fonctionnalités à la classe de base, ce qui signifiait également de nouveaux codes pour l'énum.
- La classe dérivée prend en charge à la fois l'énumération des classes de base et la sienne. Pas de valeurs enum en double! Alors, comment avoir une énumération pour la sous-classe qui inclut l'énumération de son parent avec ses nouvelles valeurs.
Utiliser une interface ne coupe pas vraiment le problème: vous pouvez obtenir accidentellement des valeurs enum dupliquées. Pas souhaitable.
En fin de compte, j'ai simplement combiné les enums: cela garantit qu'il ne peut pas y avoir de doublons, au détriment des liens moins étroits avec la classe associée. Mais, je me suis dit que le problème des doublons était ma principale préoccupation ...
Pour aider à comprendre pourquoi étendre un enum n’est pas raisonnable au niveau de la mise en œuvre du langage, il est préférable d’envisager ce qui se produirait si vous transmettiez une instance d’Enum étendu à une routine ne comprenant que l’énumération de base. Un commutateur que le compilateur avait promis si tous les cas couverts ne couvraient en fait pas ces valeurs Enum étendues.
Ceci souligne encore que Java Enum ne sont pas des entiers tels que C, par exemple: pour utiliser un Java Enum en tant qu'index de tableau, vous devez demander explicitement son membre ordinal (), pour donner à Java Enum une valeur entière arbitraire, vous devez ajouter un champ explicite à cela et faire référence à ce membre nommé.
Ce n'est pas un commentaire sur le souhait du PO, mais simplement sur la raison pour laquelle Java ne le fera jamais.
Dans l'espoir que cette solution élégante d'un de mes collègues se voit même dans ce long post, j'aimerais partager cette approche pour le sous-classement qui suit l'approche d'interface et au-delà.
Veuillez noter que nous utilisons ici des exceptions personnalisées et que ce code ne sera pas compilé à moins que vous ne le remplaciez par vos exceptions.
La documentation est vaste et j'espère que c'est compréhensible pour la plupart d'entre vous.
L'interface que chaque énumération de sous-classe doit implémenter.
public interface Parameter {
/**
* Retrieve the parameters name.
*
* @return the name of the parameter
*/
String getName();
/**
* Retrieve the parameters type.
*
* @return the {@link Class} according to the type of the parameter
*/
Class<?> getType();
/**
* Matches the given string with this parameters value pattern (if applicable). This helps to find
* out if the given string is a syntactically valid candidate for this parameters value.
*
* @param valueStr <i>optional</i> - the string to check for
* @return <code>true</code> in case this parameter has no pattern defined or the given string
* matches the defined one, <code>false</code> in case <code>valueStr</code> is
* <code>null</code> or an existing pattern is not matched
*/
boolean match(final String valueStr);
/**
* This method works as {@link #match(String)} but throws an exception if not matched.
*
* @param valueStr <i>optional</i> - the string to check for
* @throws ArgumentException with code
* <dl>
* <dt>PARAM_MISSED</dt>
* <dd>if <code>valueStr</code> is <code>null</code></dd>
* <dt>PARAM_BAD</dt>
* <dd>if pattern is not matched</dd>
* </dl>
*/
void matchEx(final String valueStr) throws ArgumentException;
/**
* Parses a value for this parameter from the given string. This method honors the parameters data
* type and potentially other criteria defining a valid value (e.g. a pattern).
*
* @param valueStr <i>optional</i> - the string to parse the parameter value from
* @return the parameter value according to the parameters type (see {@link #getType()}) or
* <code>null</code> in case <code>valueStr</code> was <code>null</code>.
* @throws ArgumentException in case <code>valueStr</code> is not parsable as a value for this
* parameter.
*/
Object parse(final String valueStr) throws ArgumentException;
/**
* Converts the given value to its external form as it is accepted by {@link #parse(String)}. For
* most (ordinary) parameters this is simply a call to {@link String#valueOf(Object)}. In case the
* parameter types {@link Object#toString()} method does not return the external form (e.g. for
* enumerations), this method has to be implemented accordingly.
*
* @param value <i>mandatory</i> - the parameters value
* @return the external form of the parameters value, never <code>null</code>
* @throws InternalServiceException in case the given <code>value</code> does not match
* {@link #getType()}
*/
String toString(final Object value) throws InternalServiceException;
}
La classe de base ENUM implémentée.
public enum Parameters implements Parameter {
/**
* ANY ENUM VALUE
*/
VALUE(new ParameterImpl<String>("VALUE", String.class, "[A-Za-z]{3,10}"));
/**
* The parameter wrapped by this enum constant.
*/
private Parameter param;
/**
* Constructor.
*
* @param param <i>mandatory</i> - the value for {@link #param}
*/
private Parameters(final Parameter param) {
this.param = param;
}
/**
* {@inheritDoc}
*/
@Override
public String getName() {
return this.param.getName();
}
/**
* {@inheritDoc}
*/
@Override
public Class<?> getType() {
return this.param.getType();
}
/**
* {@inheritDoc}
*/
@Override
public boolean match(final String valueStr) {
return this.param.match(valueStr);
}
/**
* {@inheritDoc}
*/
@Override
public void matchEx(final String valueStr) {
this.param.matchEx(valueStr);
}
/**
* {@inheritDoc}
*/
@Override
public Object parse(final String valueStr) throws ArgumentException {
return this.param.parse(valueStr);
}
/**
* {@inheritDoc}
*/
@Override
public String toString(final Object value) throws InternalServiceException {
return this.param.toString(value);
}
}
Le sous-groupe ENUM qui "hérite" de la classe de base.
public enum ExtendedParameters implements Parameter {
/**
* ANY ENUM VALUE
*/
VALUE(my.package.name.VALUE);
/**
* EXTENDED ENUM VALUE
*/
EXTENDED_VALUE(new ParameterImpl<String>("EXTENDED_VALUE", String.class, "[0-9A-Za-z_.-]{1,20}"));
/**
* The parameter wrapped by this enum constant.
*/
private Parameter param;
/**
* Constructor.
*
* @param param <i>mandatory</i> - the value for {@link #param}
*/
private Parameters(final Parameter param) {
this.param = param;
}
/**
* {@inheritDoc}
*/
@Override
public String getName() {
return this.param.getName();
}
/**
* {@inheritDoc}
*/
@Override
public Class<?> getType() {
return this.param.getType();
}
/**
* {@inheritDoc}
*/
@Override
public boolean match(final String valueStr) {
return this.param.match(valueStr);
}
/**
* {@inheritDoc}
*/
@Override
public void matchEx(final String valueStr) {
this.param.matchEx(valueStr);
}
/**
* {@inheritDoc}
*/
@Override
public Object parse(final String valueStr) throws ArgumentException {
return this.param.parse(valueStr);
}
/**
* {@inheritDoc}
*/
@Override
public String toString(final Object value) throws InternalServiceException {
return this.param.toString(value);
}
}
Enfin, le générique ParameterImpl pour ajouter des utilitaires.
public class ParameterImpl<T> implements Parameter {
/**
* The default pattern for numeric (integer, long) parameters.
*/
private static final Pattern NUMBER_PATTERN = Pattern.compile("[0-9]+");
/**
* The default pattern for parameters of type boolean.
*/
private static final Pattern BOOLEAN_PATTERN = Pattern.compile("0|1|true|false");
/**
* The name of the parameter, never <code>null</code>.
*/
private final String name;
/**
* The data type of the parameter.
*/
private final Class<T> type;
/**
* The validation pattern for the parameters values. This may be <code>null</code>.
*/
private final Pattern validator;
/**
* Shortcut constructor without <code>validatorPattern</code>.
*
* @param name <i>mandatory</i> - the value for {@link #name}
* @param type <i>mandatory</i> - the value for {@link #type}
*/
public ParameterImpl(final String name, final Class<T> type) {
this(name, type, null);
}
/**
* Constructor.
*
* @param name <i>mandatory</i> - the value for {@link #name}
* @param type <i>mandatory</i> - the value for {@link #type}
* @param validatorPattern - <i>optional</i> - the pattern for {@link #validator}
* <dl>
* <dt style="margin-top:0.25cm;"><i>Note:</i>
* <dd>The default validation patterns {@link #NUMBER_PATTERN} or
* {@link #BOOLEAN_PATTERN} are applied accordingly.
* </dl>
*/
public ParameterImpl(final String name, final Class<T> type, final String validatorPattern) {
this.name = name;
this.type = type;
if (null != validatorPattern) {
this.validator = Pattern.compile(validatorPattern);
} else if (Integer.class == this.type || Long.class == this.type) {
this.validator = NUMBER_PATTERN;
} else if (Boolean.class == this.type) {
this.validator = BOOLEAN_PATTERN;
} else {
this.validator = null;
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean match(final String valueStr) {
if (null == valueStr) {
return false;
}
if (null != this.validator) {
final Matcher matcher = this.validator.matcher(valueStr);
return matcher.matches();
}
return true;
}
/**
* {@inheritDoc}
*/
@Override
public void matchEx(final String valueStr) throws ArgumentException {
if (false == this.match(valueStr)) {
if (null == valueStr) {
throw ArgumentException.createEx(ErrorCode.PARAM_MISSED, "The value must not be null",
this.name);
}
throw ArgumentException.createEx(ErrorCode.PARAM_BAD, "The value must match the pattern: "
+ this.validator.pattern(), this.name);
}
}
/**
* Parse the parameters value from the given string value according to {@link #type}. Additional
* the value is checked by {@link #matchEx(String)}.
*
* @param valueStr <i>optional</i> - the string value to parse the value from
* @return the parsed value, may be <code>null</code>
* @throws ArgumentException in case the parameter:
* <ul>
* <li>does not {@link #matchEx(String)} the {@link #validator}</li>
* <li>cannot be parsed according to {@link #type}</li>
* </ul>
* @throws InternalServiceException in case the type {@link #type} cannot be handled. This is a
* programming error.
*/
@Override
public T parse(final String valueStr) throws ArgumentException, InternalServiceException {
if (null == valueStr) {
return null;
}
this.matchEx(valueStr);
if (String.class == this.type) {
return this.type.cast(valueStr);
}
if (Boolean.class == this.type) {
return this.type.cast(Boolean.valueOf(("1".equals(valueStr)) || Boolean.valueOf(valueStr)));
}
try {
if (Integer.class == this.type) {
return this.type.cast(Integer.valueOf(valueStr));
}
if (Long.class == this.type) {
return this.type.cast(Long.valueOf(valueStr));
}
} catch (final NumberFormatException e) {
throw ArgumentException.createEx(ErrorCode.PARAM_BAD, "The value cannot be parsed as "
+ this.type.getSimpleName().toLowerCase() + ".", this.name);
}
return this.parseOther(valueStr);
}
/**
* Field access for {@link #name}.
*
* @return the value of {@link #name}.
*/
@Override
public String getName() {
return this.name;
}
/**
* Field access for {@link #type}.
*
* @return the value of {@link #type}.
*/
@Override
public Class<T> getType() {
return this.type;
}
/**
* {@inheritDoc}
*/
@Override
public final String toString(final Object value) throws InternalServiceException {
if (false == this.type.isAssignableFrom(value.getClass())) {
throw new InternalServiceException(ErrorCode.PANIC,
"Parameter.toString(): Bad type of value. Expected {0} but is {1}.", this.type.getName(),
value.getClass().getName());
}
if (String.class == this.type || Integer.class == this.type || Long.class == this.type) {
return String.valueOf(value);
}
if (Boolean.class == this.type) {
return Boolean.TRUE.equals(value) ? "1" : "0";
}
return this.toStringOther(value);
}
/**
* Parse parameter values of other (non standard types). This method is called by
* {@link #parse(String)} in case {@link #type} is none of the supported standard types (currently
* String, Boolean, Integer and Long). It is intended for extensions.
* <dl>
* <dt style="margin-top:0.25cm;"><i>Note:</i>
* <dd>This default implementation always throws an InternalServiceException.
* </dl>
*
* @param valueStr <i>mandatory</i> - the string value to parse the value from
* @return the parsed value, may be <code>null</code>
* @throws ArgumentException in case the parameter cannot be parsed according to {@link #type}
* @throws InternalServiceException in case the type {@link #type} cannot be handled. This is a
* programming error.
*/
protected T parseOther(final String valueStr) throws ArgumentException, InternalServiceException {
throw new InternalServiceException(ErrorCode.PANIC,
"ParameterImpl.parseOther(): Unsupported parameter type: " + this.type.getName());
}
/**
* Convert the values of other (non standard types) to their external form. This method is called
* by {@link #toString(Object)} in case {@link #type} is none of the supported standard types
* (currently String, Boolean, Integer and Long). It is intended for extensions.
* <dl>
* <dt style="margin-top:0.25cm;"><i>Note:</i>
* <dd>This default implementation always throws an InternalServiceException.
* </dl>
*
* @param value <i>mandatory</i> - the parameters value
* @return the external form of the parameters value, never <code>null</code>
* @throws InternalServiceException in case the given <code>value</code> does not match
* {@link #getClass()}
*/
protected String toStringOther(final Object value) throws InternalServiceException {
throw new InternalServiceException(ErrorCode.PANIC,
"ParameterImpl.toStringOther(): Unsupported parameter type: " + this.type.getName());
}
}
Ma façon de coder serait la suivante:
// enum A { a, b, c }
static final Set<Short> enumA = new LinkedHashSet<>(Arrays.asList(new Short[]{'a','b','c'}));
// enum B extends A { d }
static final Set<Short> enumB = new LinkedHashSet<>(enumA);
static {
enumB.add((short) 'd');
// If you have to add more elements:
// enumB.addAll(Arrays.asList(new Short[]{ 'e', 'f', 'g', '♯', '♭' }));
}
LinkedHashSet indique à la fois que chaque entrée n'existe qu'une seule fois et que leur ordre est préservé. Si l'ordre n'a pas d'importance, vous pouvez utiliser HashSet à la place. Le code suivant est impossible en Java:
for (A a : B.values()) { // enum B extends A { d }
switch (a) {
case a:
case b:
case c:
System.out.println("Value is: " + a.toString());
break;
default:
throw new IllegalStateException("This should never happen.");
}
}
Le code peut être écrit comme suit:
for (Short a : enumB) {
switch (a) {
case 'a':
case 'b':
case 'c':
System.out.println("Value is: " + new String(Character.toChars(a)));
break;
default:
throw new IllegalStateException("This should never happen.");
}
}
À partir de Java 7, vous pouvez même faire de même avec String:
// enum A { BACKWARDS, FOREWARDS, STANDING }
static final Set<String> enumA = new LinkedHashSet<>(Arrays.asList(new String[] {
"BACKWARDS", "FOREWARDS", "STANDING" }));
// enum B extends A { JUMP }
static final Set<String> enumB = new LinkedHashSet<>(enumA);
static {
enumB.add("JUMP");
}
Utiliser le remplacement d'énum:
for (String a : enumB) {
switch (a) {
case "BACKWARDS":
case "FOREWARDS":
case "STANDING":
System.out.println("Value is: " + a);
break;
default:
throw new IllegalStateException("This should never happen.");
}
}