Can enums be subclassed to add new elements

Question

I want to take an existing enum and add more elements to it as follows   enum A  a b c   enum B extends A  d     B is  a b c d      Is this possible in Java

User · Answer

In the hopes this elegant solution of a colleague of mine is even seen in this long post I'd like to share this approach for subclassing which follows the interface approach and beyond.

Please be aware that we use custom exceptions here and this code won't compile unless you replace it with your exceptions.

The documentation is extensive and I hope it's understandable for most of you.

The interface that every subclassed enum needs to implement.

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;
}

The implementing ENUM base class.

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);
  }
}

The subclassed ENUM which "inherits" from base class.

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);
  }
}

Finally the generic ParameterImpl to add some utilities.

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());
  }
}

User · Answer

This is how I enhance the enum inheritance pattern with runtime check in static initializer  The BaseKind checkEnumExtender checks that  extending  enum declares all the values of the base enum in exactly the same way so  name   and  ordinal   remain fully compatible   There is still copy-paste involved for declaring values but the program fails fast if somebody added or modified a value in the base class without updating extending ones   Common behavior for different enums extending each other   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  with verifying method   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  lt  baseValues length           throw new IncorrectExtensionError   Only     extendingValues length     values against               baseValues length     base values                for  int i   0   i  lt  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                    Extension sample   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

User · Answer

I tend to avoid enums  because they are not extensible  To stay with the example of the OP  if A is in a library and B in your own code  you can t extend A if it is an enum  This is how I sometimes replace 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         There are some pits to avoid  see the comments in the code  Depending on your needs  this is a solid  extensible alternative to enums

User · Answer

enum A  a b c  enum B extends A  d    B is  a b c d      can be written as   public enum All       a        ClassGroup A ClassGroup B       b        ClassGroup A ClassGroup B       c        ClassGroup A ClassGroup B       d        ClassGroup B          ClassGroup B getMembers   contains  a b c d    How it can be useful  Let say we want something like  We have events and we are using enums  Those enums can be grouped by similar processing  If we have operation with many elements  then some events starts operation  some are just step and other end the operation  To gather such operation and avoid long switch case we can group them as in example and use   if myEvent is State StatusGroup START   makeNewOperationObject     if myEnum is State StatusGroup STEP   makeSomeSeriousChanges     if myEnum is State StatusGroup FINISH   closeTransactionOrSomething       Example   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 lt AtmOperationStatus gt  getMembers        void addMember AtmOperationStatus pE        DEFINING GROUPS public enum State StatusGroup implements StatusGroupInterface      START  STEP  FAIL  FINISH       private List lt AtmOperationStatus gt  members   new LinkedList lt AtmOperationStatus gt           Override     public EnumSet lt AtmOperationStatus gt  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             Add some more advanced   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           At above if we have some fail  myEvent is State StatusGroup FAIL   then iterating by previous events we can easily check if we must revert money transfer by   if myEvent2 is ChangedMoneyAccountState EventsGroup CHANGED   rollBack       It can be useful for         including explicite meta-data about processing logic  less to remember   implementing some of multi-inheritance   we don t want to use class structures  ex  for sending short status messages

User · Answer

In case you missed it  there s a chapter in the excellent Joshua Bloch s book  quot Effective Java  2nd edition quot    Chapter 6 - Enums and Annotations Item 34   Emulate extensible enums with interfaces  Just the conclusion    A minor disadvantage of the use of interfaces to emulate extensible enums is those implementations cannot be inherited from one enum type to another  In the case of our Operation example  the logic to store and retrieve the symbol associated with an operation is duplicated in BasicOperation and ExtendedOperation  In this case  it doesn   t matter because very little code is duplicated  If there were a a larger amount of shared functionality  you could encapsulate it in a helper class or a static helper method to eliminate the code duplication    In summary  while you cannot write an extensible enum type  you can emulate it by writing an interface to go with a basic enum type that implements the interface  This allows clients to write their own enums that implement the interface  These enums can then be used wherever the basic enum type can be used  assuming APIs are written in terms of the interface

User · Answer

Based on  Tom Hawtin - tackline answer we add switch support   interface Day lt T gt              T valueOf       public enum Weekday implements Day lt Weekday gt        MON  TUE  WED  THU  FRI     Weekday valueOf         return valueOf name             public enum WeekendDay implements Day lt WeekendDay gt        SAT  SUN     WeekendDay valueOf         return valueOf name             Day lt Weekday gt  wds   Weekday MON  Day lt WeekendDay gt  wends   WeekendDay SUN   switch wds valueOf         case MON      case TUE      case WED      case THU      case FRI     switch wends valueOf         case SAT      case SUN

User · Answer

As an aid to understanding why extending an Enum is not reasonable at the language implementation level to consider what would happen if you passed an instance of the extended Enum to a routine that only understands the base Enum  A switch that the compiler promised had all cases covered would in fact not cover those extended Enum values    This further emphasizes that Java Enum values are not integers such as C s are  for instances  to use a Java Enum as an array index you must explicitly ask for its ordinal   member  to give a java Enum an arbitrary integer value you must add an explicit field for that and reference that named member   This is not a comment on the OP s desire  just on why Java ain t never going to do it

User · Answer

I suggest you take the other way around approach     Instead of extending the existing enumeration  create a larger one and create a subset of it  For exemple if you had an enumeration called PET and you wanted to extend it to ANIMAL you should do this instead    public enum ANIMAL       WOLF CAT  DOG    EnumSet lt ANIMAL gt  pets   EnumSet of ANIMAL CAT  ANIMAL DOG     Be careful  pets is not an immutable collections  you might want to use Guava or Java9 for more safety

User · Answer

Enums represent a complete enumeration of possible values  So the  unhelpful  answer is no   As an example of a real problem take weekdays  weekend days and  the union  days of week  We could define all days within days-of-week but then we would not be able to represent properties special to either weekdays and weekend-days   What we could do  is have three enum types with a mapping between weekdays weekend-days and days-of-week   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      Alternatively  we could have an open-ended interface for day-of-week   interface Day             public enum Weekday implements Day       MON  TUE  WED  THU  FRI    public enum WeekendDay implements Day       SAT  SUN      Or we could combine the two approaches   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

User · Answer

No  you can t do this in Java  Aside from anything else  d would then presumably be an instance of A  given the normal idea of  extends    but users who only knew about A wouldn t know about it - which defeats the point of an enum being a well-known set of values   If you could tell us more about how you want to use this  we could potentially suggest alternative solutions

User · Answer

The recommended solution to this is the extensible enum pattern   This involves creating an interface and using that where you currently use the enum  Then make the enum implement the interface  You can add more constants by making that new enum also extend the interface

User · Answer

Under the covers your ENUM is just a regular class generated by the compiler  That generated class extends java lang Enum  The technical reason you can t extend the generated class is that the generated class is final  The conceptual reasons for it being final are discussed in this topic  But I ll add the mechanics to the discussion   Here is a test enum   public enum TEST         ONE  TWO  THREE      The resulting code from javap   public final class TEST extends java lang Enum lt TEST gt      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       Conceivably you could type this class on your own and drop the  final   But the compiler prevents you from extending  java lang Enum  directly  You could decide NOT to extend java lang Enum  but then your class and its derived classes would not be an instanceof java lang Enum     which might not really matter to you any way

User · Answer

Having had this same problem myself I d like to post my perspective  I think that there are a couple motivating factors for doing something like this    You want to have some related enum codes  but in different classes  In my case I had a base class with several codes defined in an associated enum  At some later date  today   I wanted to provide some new functionality to the base class  which also meant new codes for the enum  The derived class would support both the base classes  enum as well as its own  No duplicate enum values  So  how to have an enum for the subclass that includes the enum s of its parent along with its new values    Using an interface doesn t really cut it  you can accidentally get duplicate enum values  Not desirable   I ended up just combining the enums  this ensures that there cannot be any duplicate values  at the expense of being less tightly tied to its associated class  But  I figured the duplicate issue was my main concern

User · Answer

My way to code that would be as follows      enum A   a  b  c   static final Set lt Short gt  enumA   new LinkedHashSet lt  gt  Arrays asList new Short    a   b   c          enum B extends A   d   static final Set lt Short gt  enumB   new LinkedHashSet lt  gt  enumA   static       enumB add  short   d           If you have to add more elements         enumB addAll Arrays asList new Short     e    f    g                     LinkedHashSet provides both that each entry only exists once  and that their order is preserved  If order doesn   t matter  you can use HashSet instead  The following code is not possible in 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               The code can be written as follows   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               From Java 7 onwards you can even do the same with String      enum A   BACKWARDS  FOREWARDS  STANDING   static final Set lt String gt  enumA   new LinkedHashSet lt  gt  Arrays asList new String              BACKWARDS    FOREWARDS    STANDING           enum B extends A   JUMP   static final Set lt String gt  enumB   new LinkedHashSet lt  gt  enumA   static       enumB add  JUMP        Using the enum replacement   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

User · Answer

Here is a way how I found how to extend a enum into other enum  is a very straighfoward approach   Suposse you have a enum with common constants   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            then you can try to do a manual extends in this way   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            of course every time you need to extend a constant you have to modify your SubEnum files

[java] Can enums be subclassed to add new elements?

Examples related to java

Examples related to enums