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

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

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

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

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

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 lt   gt  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  lt i gt optional lt  i gt  - the string to check for       return  lt code gt true lt  code gt  in case this parameter has no pattern defined or the given string              matches the defined one   lt code gt false lt  code gt  in case  lt code gt valueStr lt  code gt  is               lt code gt null lt  code gt  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  lt i gt optional lt  i gt  - the string to check for       throws ArgumentException with code                 lt dl gt                  lt dt gt PARAM MISSED lt  dt gt                  lt dd gt if  lt code gt valueStr lt  code gt  is  lt code gt null lt  code gt  lt  dd gt                  lt dt gt PARAM BAD lt  dt gt                  lt dd gt if pattern is not matched lt  dd gt                  lt  dl gt          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  lt i gt optional lt  i gt  - the string to parse the parameter value from       return the parameter value according to the parameters type  see   link  getType     or               lt code gt null lt  code gt  in case  lt code gt valueStr lt  code gt  was  lt code gt null lt  code gt         throws ArgumentException in case  lt code gt valueStr lt  code gt  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  lt i gt mandatory lt  i gt  - the parameters value       return the external form of the parameters value  never  lt code gt null lt  code gt        throws InternalServiceException in case the given  lt code gt value lt  code gt  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 lt String gt   VALUE   String class    A-Za-z  3 10                  The parameter wrapped by this enum constant          private Parameter param              Constructor             param param  lt i gt mandatory lt  i gt  - 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 lt   gt  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 lt String gt   EXTENDED VALUE   String class    0-9A-Za-z  -  1 20                  The parameter wrapped by this enum constant          private Parameter param              Constructor             param param  lt i gt mandatory lt  i gt  - 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 lt   gt  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 lt T gt  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  lt code gt null lt  code gt           private final String name              The data type of the parameter          private final Class lt T gt  type              The validation pattern for the parameters values  This may be  lt code gt null lt  code gt           private final Pattern validator              Shortcut constructor without  lt code gt validatorPattern lt  code gt              param name  lt i gt mandatory lt  i gt  - the value for   link  name        param type  lt i gt mandatory lt  i gt  - the value for   link  type          public ParameterImpl final String name  final Class lt T gt  type        this name  type  null                   Constructor             param name  lt i gt mandatory lt  i gt  - the value for   link  name        param type  lt i gt mandatory lt  i gt  - the value for   link  type        param validatorPattern -  lt i gt optional lt  i gt  - the pattern for   link  validator                 lt dl gt                 lt dt style  margin-top 0 25cm   gt  lt i gt Note  lt  i gt                 lt dd gt The default validation patterns   link  NUMBER PATTERN  or                 link  BOOLEAN PATTERN  are applied accordingly                 lt  dl gt          public ParameterImpl final String name  final Class lt T gt  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  lt i gt optional lt  i gt  - the string value to parse the value from       return the parsed value  may be  lt code gt null lt  code gt        throws ArgumentException in case the parameter                  lt ul gt                  lt li gt does not   link  matchEx String   the   link  validator  lt  li gt                  lt li gt cannot be parsed according to   link  type  lt  li gt                  lt  ul gt        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 lt T gt  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        lt dl gt        lt dt style  margin-top 0 25cm   gt  lt i gt Note  lt  i gt        lt dd gt This default implementation always throws an InternalServiceException        lt  dl gt             param valueStr  lt i gt mandatory lt  i gt  - the string value to parse the value from       return the parsed value  may be  lt code gt null lt  code gt        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        lt dl gt        lt dt style  margin-top 0 25cm   gt  lt i gt Note  lt  i gt        lt dd gt This default implementation always throws an InternalServiceException        lt  dl gt             param value  lt i gt mandatory lt  i gt  - the parameters value       return the external form of the parameters value  never  lt code gt null lt  code gt        throws InternalServiceException in case the given  lt code gt value lt  code gt  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

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

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

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

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

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

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

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

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

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

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

Examples related to java

Examples related to enums