Why would an Enum implement an Interface

Question

I just found out that Java allows enums to implement an interface  What would be a good use case for that

User · Answer

For example if you have a Logger enum  Then you should have the logger methods such as debug  info  warning and error in the interface  It makes your code loosely coupled

User · Answer

Here s one example  a similar better one is found in Effective Java 2nd Edition    public interface Operator       int apply  int a  int b      public enum SimpleOperators implements Operator       PLUS            int apply int a  int b    return a   b               MINUS            int apply int a  int b    return a - b              public enum ComplexOperators implements Operator          can t think of an example right now  -      Now to get a list of both the Simple   Complex Operators   List lt Operator gt  operators   new ArrayList lt Operator gt      operators addAll Arrays asList SimpleOperators values      operators addAll Arrays asList ComplexOperators values        So here you use an interface to simulate extensible enums  which wouldn t be possible without using an interface

User · Answer

There is a case I often use  I have a IdUtil class with static methods to work with objects implementing a very simple Identifiable interface   public interface Identifiable lt K gt        K getId        public abstract class IdUtil        public static  lt T extends Enum lt T gt   amp  Identifiable lt S gt   S gt  T get Class lt T gt  type  S id            for  T t   type getEnumConstants                  if  Util equals t getId    id                     return t                                  return null             public static  lt T extends Enum lt T gt   amp  Identifiable lt S gt   S extends Comparable lt   super S gt  gt  List lt T gt  getLower T en            List lt T gt  list   new ArrayList lt  gt             for  T t   en getDeclaringClass   getEnumConstants                   if  t getId   compareTo en getId     lt  0                     list add t                                   return list            If I create an Identifiable enum       public enum MyEnum implements Identifiable lt Integer gt             FIRST 1   SECOND 2            private int id           private MyEnum int id                this id   id                     public Integer getId                 return id                     Then I can get it by its id this way   MyEnum e   IdUtil get MyEnum class  1

User · Answer

I used an inner enum in an interface describing a strategy to keep instance control  each strategy is a Singleton  from there   public interface VectorizeStrategy                   Keep instance control from here                 Concrete classes constructors should be package private              enum ConcreteStrategy implements VectorizeStrategy           DEFAULT  new VectorizeImpl              private final VectorizeStrategy INSTANCE           ConcreteStrategy VectorizeStrategy concreteStrategy                INSTANCE   concreteStrategy                      Override         public VectorImageGridIntersections processImage MarvinImage img                return INSTANCE processImage img                                   Should perform edge Detection in order to have lines  that can be vectorized                  param img An Image suitable for edge detection                  return the VectorImageGridIntersections representing img s vectors         intersections with the grids              VectorImageGridIntersections processImage MarvinImage img       The fact that the enum implements the strategy is convenient to allow the enum class to act as proxy for its enclosed Instance  which also implements the interface   it s a sort of strategyEnumProxy  P the clent code looks like this   VectorizeStrategy ConcreteStrategy DEFAULT processImage img     If it didn t implement the interface it d had been   VectorizeStrategy ConcreteStrategy DEFAULT getInstance   processImage img

User · Answer

The Comparable example given by several people here is wrong  since Enum already implements that  You can t even override it   A better example is having an interface that defines  let s say  a data type  You can have an enum to implement the simple types  and have normal classes to implement complicated types   interface DataType        methods here    enum SimpleDataType implements DataType     INTEGER  STRING        implement methods    class IdentifierDataType implements DataType        implement interface and maybe add more specific methods

User · Answer

Most common usage for this would be to merge the values of two enums into one group and treat them similarly  For example  see how  to join Fruits and Vegatables

User · Answer

Enums don t just have to represent passive sets  e g  colours   They can represent more complex objects with functionality  and so you re then likely to want to add further functionality to these - e g  you may have interfaces such as Printable  Reportable etc  and components that support these

User · Answer

When creating constants in a jar file  it is often helpful to let users extend enum values   We used enums for PropertyFile keys and got stuck because nobody could add any new ones   Below would have worked much better   Given   public interface Color     String fetchName        and   public class MarkTest      public static void main String   args        MarkTest showColor Colors BLUE       MarkTest showColor MyColors BROWN          private static void showColor Color c        System out println c fetchName             one could have one enum in the jar   public enum Colors implements Color     BLUE  RED  GREEN     Override   public String fetchName         return this name            and a user could extend it to add his own colors   public enum MyColors implements Color     BROWN  GREEN  YELLOW     Override   public String fetchName         return this name

User · Answer

It s required for extensibility -- if someone uses an API you ve developed  the enums you define are static  they can t be added to or modified  However  if you let it implement an interface  the person using the API can develop their own enum using the same interface  You can then register this enum with an enum manager which conglomerates the enums together with the standard interface   Edit   Helper Method has the perfect example of this  Think about having other libraries defining new operators and then telling a manager class that  hey  this enum exists -- register it   Otherwise  you d only be able to define Operators in your own code - there d be no extensibility

User · Answer

One of the best use case for me to use enum s with interface is Predicate filters  It s very elegant way to remedy lack of typness of apache collections  If other libraries mayn t be used    import java util ArrayList  import java util Collection   import org apache commons collections CollectionUtils  import org apache commons collections Predicate    public class Test       public final static String DEFAULT COMPONENT    Default        enum FilterTest implements Predicate           Active false                 Override             boolean eval Test test                    return test active                                   DefaultComponent true                 Override             boolean eval Test test                    return DEFAULT COMPONENT equals test component                                               private boolean defaultValue           private FilterTest boolean defautValue                this defaultValue   defautValue                     abstract boolean eval Test test            public boolean evaluate Object o                if  o instanceof Test                    return eval  Test o                             return defaultValue                        private boolean active   true      private String component   DEFAULT COMPONENT       public static void main String   args            Collection lt Test gt  tests   new ArrayList lt Test gt             tests add new Test              CollectionUtils filter tests  FilterTest Active

User · Answer

Enums are just classes in disguise  so for the most part  anything you can do with a class you can do with an enum   I cannot think of a reason that an enum should not be able to implement an interface  at the same time I cannot think of a good reason for them to either     I would say once you start adding thing like interfaces  or method to an enum you should really consider making it a class instead   Of course I am sure there are valid cases for doing non-traditional enum things  and since the limit would be an artificial one  I am in favour of letting people do what they want there

User · Answer

Another posibility   public enum ConditionsToBeSatisfied implements Predicate lt Number gt        IS NOT NULL Objects  nonNull   Item is null        IS NOT AN INTEGER item - gt  item instanceof Integer   Item is not an integer        IS POSITIVE item - gt  item instanceof Integer  amp  amp   Integer  item  gt  0   Item is negative         private final Predicate lt Number gt  predicate      private final String notSatisfiedLogMessage       ConditionsToBeSatisfied final Predicate lt Number gt  predicate  final String notSatisfiedLogMessage            this predicate   predicate          this notSatisfiedLogMessage   notSatisfiedLogMessage              Override     public boolean test final Number item            final boolean isNotValid   predicate negate   test item            if  isNotValid                log warn  Invalid     Cause       item  notSatisfiedLogMessage                      return predicate test item             and using   Predicate lt Number gt  p   IS NOT NULL and IS NOT AN INTEGER  and IS POSITIVE

User · Answer

Enums are like Java Classes  they can have Constructors  Methods  etc  The only thing that you can t do with them is new EnumName    The instances are predefined in your enum declaration

User · Answer

Since Enums can implement interfaces they can be used for strict enforcing of the singleton pattern   Trying to make a standard class a singleton allows      for the possibility of using reflection techniques to expose private methods as public  for inheriting from your singleton and overriding your singleton s methods with something else   Enums as singletons help to prevent these security issues   This might have been one of the contributing reasons to let Enums act as classes and implement interfaces   Just a guess   See https   stackoverflow com questions 427902 java-enum-singleton and Singleton class in java for more discussion

User · Answer

Here s my reason why      I have populated a JavaFX ComboBox with the values of an Enum   I have an interface  Identifiable  specifying one method  identify   that allows me to specify how any object identifies itself to my application for searching purposes   This interface enables me to scan lists of any type of objects  whichever field the object may use for identity  for an identity match   I d like to find a match for an identity value in my ComboBox list  In order to use this capability on my ComboBox containing the Enum values  I must be able to implement the Identifiable interface in my Enum  which  as it happens  is trivial to implement in the case of an Enum

User · Answer

The post above that mentioned strategies didn t stress enough what a nice lightweight implementation of the strategy pattern using enums gets you   public enum Strategy      A        Override     void execute           System out print  Executing strategy A                  B        Override     void execute           System out print  Executing strategy B                  abstract void execute        You can have all your strategies in one place without needing a separate compilation unit for each  You get a nice dynamic dispatch just with   Strategy valueOf  A   execute      Makes java read almost like a nice loosely typed language

[java] Why would an Enum implement an Interface?

Examples related to java

Examples related to enums