Ich habe die Frage “Unterschied von Enum zwischen Java und C++” gelesen. aber ich bin immer noch verwirrt.
Ich möchte Folgendes, um den zugehörigen String zurückzugeben:
public enum Checker {
EMPTY ("Empty"),
RED ("Red"),
YELLOW ("Yellow");
}
Soweit ich gelesen habe, sollte dies möglich sein. Ich möchte nur, dass Sie etwas Licht darauf werfen, wie man es umsetzt.
Kurze Antwort
Sie benötigen einen Konstruktor, ein Feld und einen Getter.
Konstrukteure
Aufzählungstypen können Konstruktoren haben, vorausgesetzt, ihre Zugriffsebene ist entweder privat oder standardmäßig (paketprivat). Sie können diese Konstruktoren nicht direkt aufrufen, außer in der Enum-Deklaration selbst. Ähnlich wie bei Klassen rufen Sie beim Definieren einer Aufzählungskonstante ohne Parameter tatsächlich den vom Compiler generierten Standardkonstruktor auf. Z.B
public enum King {
ELVIS
}
ist äquivalent zu
public enum King {
ELVIS() // the compiler will happily accept this
}
Und genau wie in Klassen fügt der Compiler keinen Standardkonstruktor ein, wenn Sie einen expliziten Konstruktor definieren, sodass dies nicht kompiliert wird:
public enum King {
ELVIS, // error, default constructor is not defined
MICHAEL_JACKSON(true)
;
private boolean kingOfPop;
King(boolean kingOfPop){this.kingOfPop = kingOfPop;}
}
Das ist eine ziemlich gute Referenz auf Enums das erklärt auch die Konstruktorprobleme.
Felder und Accessoren
Aufzählungen sind Konstanten und als solche unveränderlich. Sie können jedoch Felder definieren, die einen Status haben können. Dies ist eine schreckliche Praxis, da Entwickler erwarten, dass Aufzählungen und ihre zugehörigen Werte Konstanten sind, aber Sie kann Definieren Sie immer noch ein nicht finales Feld in einer Aufzählung mit Gettern und Settern.
Dies ist legaler Java-Code:
public enum Color {
RED("FF0000"),
GREEN("00FF00"),
BLUE("0000FF");
private String code;
public String getCode(){return code;}
public void setCode(String code){this.code = code;}
private Color(String code){this.code = code;}
}
Aber es ermöglicht bösen Code wie diesen:
String oldBlue = Color.BLUE.getCode();
Color.BLUE.setCode(Color.RED.getCode());
Color.RED.setCode(oldBlue);
Also in 99,99 % der Fälle: Wenn Sie Felder in Ihren Aufzählungen haben, sollten Sie sie endgültig machen und nur Getter bereitstellen. Wenn die Felder selbst nicht unveränderlich sind, stellen Sie defensive Kopien bereit:
public enum Band {
THE_BEATLES("John","Paul","George","Ringo");
private final List<String> members;
public List<String> getMembers(){
// defensive copy, because the original list is mutable
return new ArrayList<String>(members);
}
private Band(String... members){
this.members=Arrays.asList(members);
}
}
Lösung
In Ihrem Fall ist es sehr einfach: Sie brauchen nur ein einzelnes Feld vom Typ String (unveränderlich), also ist es vollkommen in Ordnung, es im Konstruktor zu initialisieren und einen Getter bereitzustellen:
public enum Checker {
EMPTY ("Empty"),
RED ("Red"),
YELLOW ("Yellow");
private final String value;
private Checker(final String value) {
this.value = value;
}
public String getValue() { return value; }
}
Wenn das Muster gilt, funktioniert dies ebenfalls und eliminiert die Wiederholung:
public enum Checker {
EMPTY,
RED,
YELLOW;
public String getDescription(){
String name = name();
return ""+Character.toUpperCase(name.charAt(0))
+name.substring(1).toLowerCase();
}
}