Qual è la pratica consigliata per prendere un enum Java che dice 1300 valori e lo inserisce in gruppi organizzati? So che non puoi semplicemente estendere il gruppo enum, quindi ci sono altre buone alternative?Rompere un grande enum Java
Vorrei utilizzare un'interfaccia condivisa da tutte queste istanze, quindi è possibile utilizzare qualsiasi numero di enumerazioni o caricarle da un'altra origine dati, ad esempio un file o un database.
Da un punto di vista Oops, sarebbe una buona idea spezzarli in unità coesive. Quindi se fossi in te, valuterei quali di queste enumerazioni hanno una coesione verso una responsabilità.
1300 valori? Buon dio, chi ha pensato che fosse una buona idea? Non è successo a qualcuno dopo il 100 che stava diventando troppo grande?
Non c'è un modo per aggirare che io possa vedere. Prendi una pala e inizia a combinarli in sotto-eni più coesi.
Ecco una domanda: come vengono utilizzati? Se fanno parte della configurazione dell'applicazione, ti consigliamo di spostarli in un database anziché mantenerli nel codice. Saranno più flessibili in questo modo.
Sono già nel database. Queste enumerazioni sono le chiavi principali per un elenco di codici di errore. Ad esempio, la chiave enum "NO_DATA_FOUND" punta a "Siamo spiacenti, ma non siamo in grado di individuare la tua richiesta" nel database. – yd39
potete romperli in su come:
import java.util.*;
interface Children {
Set<Enum<?>> children();
}
enum Dog implements Children {
myDog,yourDog;
Dog() {
this(null);
}
Dog(Set<Enum<?>> children) {
this.children=children;
}
@Override public Set<Enum<?>> children() {
return children!=null?Collections.unmodifiableSet(children):null;
}
Set<Enum<?>> children;
}
enum Animal implements Children {
cat,dog(EnumSet.allOf(Dog.class));
Animal() {
this(null);
}
Animal(Set children) {
this.children=children;
}
@Override public Set<Enum<?>> children() {
return children!=null?Collections.unmodifiableSet(children):null;
}
Set<Enum<?>> children;
}
enum Thing implements Children {
animal(EnumSet.allOf(Animal.class)),vegetable,mineral;
Thing() {
this(null);
}
Thing(Set children) {
this.children=children;
}
@Override public Set<Enum<?>> children() {
return children!=null?Collections.unmodifiableSet(children):null;
}
Set<Enum<?>> children;
}
public class So8671088 {
static void visit(Class<?> clazz) {
Object[] enumConstants = clazz.getEnumConstants();
if (enumConstants[0] instanceof Children) for (Object o : enumConstants)
visit((Children) o, clazz.getName());
}
static void visit(Children children, String prefix) {
if (children instanceof Enum) {
System.out.println(prefix + ' ' + children);
if (children.children() != null) for (Object o : children.children())
visit((Children) o, prefix + ' ' + children);
} else
System.out.println("other " + children.getClass());
}
public static void main(String[] args) {
visit(Thing.animal," ");
visit(Thing.class);
}
}
Sono pienamente d'accordo. Caricalo da un file o dal database. Tuttavia, se sono presenti implementazioni di metodi in alcune delle enumerazioni, prendere in considerazione la creazione di un'interfaccia e un'implementazione separata per ogni enumerazione che ha un metodo definito e quindi un'implementazione predefinita che riceve i valori dal database o dal file. Se non sono definiti metodi, è sufficiente creare un POJO. – Saish