English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Verwendung von Java Enum
Verwendung 1: Konstanten
In JDK1.5 Bisher haben wir Konstanten definiert wie: public static final.... . Jetzt, mit Enum, können wir verwandte Konstanten in eine Enum-Typen-Gruppe gruppieren, und Enum bietet mehr Methoden als Konstanten.
public enum Color {
ROT, GRÜN, LEER, GELB
}
Verwendung 2: switch
JDK1.6Die vorherige switch-Anweisung unterstützt nur int, char, enum-Typen, und die Verwendung von Enum kann die Lesbarkeit unseres Codes verbessern.
enum Signal {
GRÜN, GELB, ROT
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {}}
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
}
Verwendungsfall 3: Hinzufügen neuer Methoden zu Enum
Wenn Sie Ihre eigenen Methoden anpassen möchten, müssen Sie am Ende der enum-Instanzreihe einen Semikolon hinzufügen. Und Java erfordert, dass die enum-Instanzen zunächst definiert werden.
public enum Color {
RED("rot", 1), GREEN("grün", 2), BLANK("weiß", 3), YELLO("gelb", 4);
// Mitglied-Variablen
private String name;
private int index;
// Konstruktor
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// Regelmäßige Methoden
public static String getName(int index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return c.name;
}
}
return null;
}
// get set Methoden
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
Verwendungsfall 4: Überschreibung von Enum-Methode
Nachstehend wird ein Beispiel für die Überschreibung der Methode toString() gegeben.
public class Test {
public enum Color {
RED("rot", 1), GREEN("grün", 2), BLANK("weiß", 3), YELLO("gelb", 4);
// Mitglied-Variablen
private String name;
private int index;
// Konstruktor
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// Überschriebene Methoden
@Override
public String toString() {
return this.index + "_" + this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED.toString());
}
}
Verwendungsfall 5: Implementierung von Schnittstellen
Alle Enumerierungen erben von der Klasse java.lang.Enum. Da Java keine Mehrvererbung unterstützt, können Enum-Objekte keine anderen Klassen mehr vererben.
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour {
RED("rot", 1), GREEN("grün", 2), BLANK("weiß", 3), YELLO("gelb", 4);
// Mitglied-Variablen
private String name;
private int index;
// Konstruktor
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// Schnittstellenmethode
@Override
public String getInfo() {
return this.name;
}
// Schnittstellenmethode
@Override
public void print() {
System.out.println(this.index + : + this.name);
}
}
Verwendung sechs: Die Verwendung von Schnittstellen zur Organisation von Enumeration
public interface Food {
enum Coffee implements Food {
BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
}
enum Dessert implements Food {
FRUIT, CAKE, GELATO
}
}
Verwendung sieben: Über die Verwendung von Enumerationssammlungen
java.util.EnumSet und java.util.EnumMap sind zwei Enumerationssammlungen. EnumSet gewährleistet, dass die Elemente in der Sammlung nicht dupliziert werden; Der Schlüssel in EnumMap ist enum Typ, während der Wert jeder beliebige Typ sein kann. Über die Verwendung dieser beiden Sammlungen wird hier nicht weiter erörtert, bitte referieren Sie die JDK-Dokumentation
Unterschied zwischen Enumeration und Konstanten
Eins: Methoden zur Definition von Konstanten
Wir verwenden in der Regel die Methoden public final static, wie folgt, mit1Darstellt Rotlicht,3Darstellt Grünlicht,2Darstellt Gelblicht.
public class Light {
/* Rotlicht */
public final static int RED = 1;
/* Grünlicht */
public final static int GREEN = 3;
/* Gelblicht */
public final static int YELLOW = 2;
}
Zwei: Methoden zur Definition von Enumerationstypen konstant
Die einfache Definitionsmethode der Enumerationstypen ist wie folgt, es scheint, dass wir die Werte jeder Enumerationstypen nicht definieren können. Zum Beispiel könnte der Code zur Definition von Rotlicht, Grünlicht und Gelblicht wie folgt aussehen:
public enum Light {
RED, GREEN, YELLOW;
}
Wir können nur Rotlicht, Grünlicht und Gelblicht darstellen, aber die konkreten Werte können wir nicht darstellen. Geduldig sein, da die Enumerationstypen einen Konstruktor bereitstellen, können wir durch den Konstruktor und die Überschreibung der toString-Methode erreichen. Zunächst müssen wir dem Enumerationstyp Light einen Konstruktor hinzufügen, und dann werden die Werte jeder Enumerationstyp durch den Konstruktor mit den entsprechenden Parametern übergeben. Gleichzeitig überschreiben wir die toString-Methode, in der die Parameter aus dem Konstruktor zurückgegeben werden. Das umgebaute Code wie folgt:
public enum Light {
// Verwendung von Konstruktorparametern
), RED(1), GREEN(3), YELLOW(2);
// Definition von privaten Variablen
private int nCode;
// Konstruktor, der enumerische Typ nur privat sein kann
private Light(int _nCode) {
this.nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf(this.nCode);
}
}
Drei, vollständiger Beispielcode
Vollständiger Quellcode der Demonstration von Enum-Typen wie folgt:
public class LightTest {
// 1.Definition von Enum-Typen
public enum Light {
// Verwendung von Konstruktorparametern
), RED(1), GREEN(3), YELLOW(2);
// Definition von privaten Variablen
private int nCode;
// Konstruktor, der enumerische Typ nur privat sein kann
private Light(int _nCode) {
this.nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf(this.nCode);
}
}
/**
*
* @param args
*/
public static void main(String[] args) {
// 1.Durchsuchung von Enum-Typen
System.out.println("Demonstration der Durchsuchung von Enum-Typen ......");
testTraversalEnum();
// 2.Demonstration der Verwendung von EnumMap
System.out.println("Demonstration der Verwendung und Durchsuchung von EnumMap-Objekten.....");
testEnumMap();
// 3.Demonstration der Verwendung von EnumSet
System.out.println("Demonstration der Verwendung und Durchsuchung von EnumSet-Objekten.....");
testEnumSet();
}
/**
*
* .Demonstration der Durchsuchung von Enum-Typen
*/
private static void testTraversalEnum() {
Light[] allLight = Light.values();
for (Light aLight : allLight) {
System.out.println("Aktuelle Lampe name: ", + aLight.name());
System.out.println("Aktuelle Lampe ordinal: ", + aLight.ordinal());
System.out.println("Aktuelle Lampe: ", + aLight);
}
}
/**
*
* .Demonstration der Verwendung von EnumMap, die Verwendung von EnumMap ähnelt der Verwendung von HashMap, nur müssen die Schlüssel enumerische Typen sein
*/
private static void testEnumMap() {
// 1.Demonstration der Definition von EnumMap-Objekten, der Konstruktor der EnumMap-Objekte erfordert Parameterübergabe, der Standard ist der Typ der Klasse des Schlüssels
EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(
Light.class);
currEnumMap.put(Light.RED, "红灯");
currEnumMap.put(Light.GREEN, "绿灯");
currEnumMap.put(Light.YELLOW, "黄灯");
// 2. durchsuchen
for (Light aLight : Light.values()) {
System.out.println("[key=" + aLight.name() + ",value="
+ currEnumMap.get(aLight) + "];
}
}
/**
*
* Demonstration, wie EnumSet verwendet wird, EnumSet ist eine abstrakte Klasse, die die Enum-Typen eines Typs abruft<BR/>
*
* Man kann die Methode allOf verwenden
*/
private static void testEnumSet() {
EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
for (Light aLightSetElement : currEnumSet) {
System.out.println("Die aktuellen Daten im EnumSet sind：" + aLightSetElement);
}
}
}
Das Ergebnis der Ausführung ist wie folgt：
Demonstration der Durchsuchung von Enum-Typen......
Aktuelle Lampe name：RED
Aktuelle Lampe ordinal：0
Aktuelle Lampe：1
Aktuelle Lampe name：GREEN
Aktuelle Lampe ordinal：1
Aktuelle Lampe：3
Aktuelle Lampe name：YELLOW
Aktuelle Lampe ordinal：2
Aktuelle Lampe：2
Demonstration der Verwendung und Durchsuchung von EnumMap-Objekten.....
[key=RED,value=红灯]
[key=GREEN,value=绿灯]
[key=YELLOW,value=黄灯]
Demonstration der Verwendung und Durchsuchung von EnumSet-Objekten.....
Die aktuellen Daten im EnumSet sind:1
Die aktuellen Daten im EnumSet sind:3
Die aktuellen Daten im EnumSet sind:2
Vier. Unterschied zwischen der Definition von Konstantenmethoden und der Definition von Konstantenmethoden durch Enumeration
Einige Inhalte könnten langweilig sein, aber sie sind definitiv wertvoll, einen Blick zu werfen.
1. 代码：
public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}
Es gibt nichts, was schlecht wäre, alle haben das seit langem so verwendet und es gibt keine Probleme.
Zunächst ist es nicht typsicher. Sie müssen sicherstellen, dass es int ist
Zweitens müssen Sie sicherstellen, dass sein Bereich 0 und1
Am Ende, oft wenn Sie es drucken, sehen Sie nur 1 und 0 ,
aber jemand, der den Code nicht sieht, weiß nicht, was Ihr Vorhaben ist, werfen Sie alle alten public static final Konstanten weg
2. Man kann eine Enum-Klasse erstellen und sie als eine gewöhnliche Klasse betrachten. Es kann keine anderen Klassen erben, außer es ist Java, das bereits von Enum erbt (Java ist Singleton, es hat bereits von Enum erbt),
Man kann andere Methoden hinzufügen und seine eigenen Methoden überschreiben
3. Der switch()-Parameter kann Enum verwenden
4. Das values() ist ein von der Compiler in die Enum-Definition eingefügtes statisches Methoden, daher ist values() nicht zugänglich, wenn Sie die Enum-Instanz in einen Enum-Überklasse-Übersetzungsstatus transformieren. Lösung: Es gibt in der Klasse eine Methode getEnumConstants(), sodass wir alle Enum-Instanzen über das Class-Objekt erhalten können, selbst wenn das Enum-Interface kein values() hat
5. Man kann keine Unterklasse von Enum ableiten. Wenn Sie die Elemente in Enum erweitern müssen, erstellen Sie in einem Interface intern eine Enumeration, die das Interface implementiert, um die Elemente zu gruppieren. Dies erreicht die Gruppierung der Enum-Elemente.
6. Verwenden Sie EnumSet anstelle von Flags. Enum erfordert, dass alle Mitglieder einzigartig sind, aber Elemente können in Enum nicht hinzugefügt oder entfernt werden.
7. Der Schlüssel von EnumMap ist Enum, der Wert ist jeder andere Object-Objekt.
8. Enum ermöglicht es dem Programmierer, Methoden für Enum-Instanzen zu schreiben. Daher können jedem Enum-Objekt unterschiedliche Verhaltensweisen zugewiesen werden.
9. Verwenden Sie enum für die Verantwortlichkeitskette (Chain of Responsibility). Dies betrifft das Designmuster Verantwortlichkeitskette. Um ein Problem auf verschiedene Weisen zu lösen, verbinden Sie sie miteinander. Wenn eine Anfrage eintrifft, durchsuchen Sie die Kette, bis eine Lösung in der Kette die Anfrage bearbeiten kann.
10. Verwenden Sie enum für den Zustandsautomaten.
11. Verwenden Sie enum für die Mehrfachverteilung.
Vielen Dank für das Lesen, ich hoffe, es kann Ihnen helfen, danke für Ihre Unterstützung dieser Website!