Ampliación de Java Enums

Question

Tengo una pregunta sobre el mejor patrón de diseño para la reutilización de código cuando se trata de enumeraciones de Java. Básicamente, lo que intento lograr es poder definir varias enumeraciones que modelan colecciones de negocios estáticas (conjuntos de constantes), pero también me gustaría compartir el comportamiento entre ellas, con una codificación mínima.

Esto es trivial con las clases abstractas pero, como las enumeraciones Java no se pueden extender (solo pueden implementar interfaces), este tipo de trabajo es tedioso e implica mucho trabajo de copiar/pegar propenso a errores (copiar el código de enum a enum). Los ejemplos de "lógica de negocios" que deben compartirse entre todas las enumeraciones incluyen la conversión de/a cadenas, comparación de instancias y lógica, etc.

Mi mejor oportunidad ahora es utilizar clases de ayuda junto con las interfaces de negocios, pero esto solo va hasta ahora en la reducción de la complejidad del código (ya que todas las enumeraciones aún tienen que declarar e invocar las clases de ayuda). Ver ejemplo (sólo para aclarar):

public enum MyEnum { 
    A, B, C; 

    // Just about any method fits the description - equals() is a mere example 
    public boolean equals(MyEnum that) { 
     ObjectUtils.equals(this, that); 
    } 
} 

Cómo hacer StackOverflowers acuerdo con esta "característica del lenguaje"?

Answer 1

Haría lo mismo, o combinaría los Enum en una super-enumeración.

Con Java 8 esto será más fácil. Podrá definir una implementación default para los métodos de interfaz y hacer que el enum amplíe la interfaz.

Answer 2

Rara vez encuentro enums útil, excepto para representar estados finitos en cuyo caso no necesitan un comportamiento.

Sugeriría refactorizar enums que necesita un comportamiento en classes con un Factory.

Answer 3

Puede mover la lógica reutilizable a clases dedicadas (sin enum) y luego hacer que las enums deleguen esas clases. Aquí hay un ejemplo:

[Nota al margen: no se recomienda la herencia de PlusTwo extends PlusOne (b/c PlusTwo no es PlusOne). Es aquí sólo para ilustrar el punto de ser capaz de extender una lógica existente.]

public interface Logic { 
    public int calc(int n); 
} 

public static class PlusOne implements Logic { 
    public int calc(int n) { return n + 1; } 
} 

public static class PlusTwo extends PlusOne { 
    @Override 
    public int calc(int n) { return super.calc(n) + 1; } 
} 

public static enum X { 
    X1, X2; 
    public Logic logic; 

    public int doSomething() { 
    return logic.calc(10); 
    } 
} 

public static enum Y { 
    Y1, Y2; 
    public Logic logic; 

    public String doSomethingElse() { 
    return "Your result is '" + logic.calc(10) + "'"; 
    } 
} 

public static void main(String[] args) { 
    // One time setup of your logic: 
    X.X1.logic = new PlusOne(); 
    X.X2.logic = new PlusTwo(); 
    Y.Y1.logic = new PlusOne(); 
    Y.Y2.logic = new PlusTwo(); 

    System.out.println(X.X1.doSomething()); 
    System.out.println(X.X2.doSomething()); 
    System.out.println(Y.Y1.doSomethingElse()); 
    System.out.println(Y.Y2.doSomethingElse()); 
} 

Answer 4

Esto puede parecer un poco feo, pero por lo general le puede ofrecer la funcionalidad requerida.

Usted puede tener interfaz

public interface MyEnumInterface<T extends Enum<T>> { 

    String getBusinessName(); 

    T getEnum(); 

} 

Implementación

public enum OneOfMyEnums implements MyEnumInterface<OneOfMyEnums>{ 

    X, Y, Z; 

    @Override 
    public String getBusinessName() { 
     return "[OneOfMyEnums]" + name(); 
    } 

    @Override 
    public OneOfMyEnums getEnum() { 
     return this; 
    } 

} 

y utilidad de clase en lugar de su clase padre

public class MyEnumUtils { 

    public static <T extends Enum<T>> String doSomething(MyEnumInterface<T> e){ 
     e.getBusinessName(); // can use MyEnumInterface methods 
     e.getEnum().name(); // can use Enum methods as well 
     return null; 
    } 

}