Ausführliche Erläuterung der Verwendung von Java-Enumerationen

Dieser Artikel stellt hauptsächlich relevante Informationen zur Verwendung von Java-Aufzählungen vor. Ich hoffe, dass Sie durch diesen Artikel die Verwendung von Aufzählungen beherrschen können So verwenden Sie

Vorwort Die Flags und Status in Ihrem Code sollten durch Aufzählungen ersetzt werden

Viele Leute sagen, dass Aufzählungen selten verwendet werden tatsächliche Entwicklung oder gar keine Nutzung erfolgt. Denn ihr Code sieht oft so aus:

Dann verwenden sie diese Klasse so:

public class Constant { 
  /* 
   * 以下几个变量表示英雄的状态 
   */ 
  public final static int STATUS_WALKING = 0;//走  
  public final static int STATUS_RUNNINGING = 1;//跑 
  public final static int STATUS_ATTACKING = 2;//攻击  
  public final static int STATUS_DEFENDING = 3;//防御  
  public final static int STATUS_DEAD = 4;//挂了  
   
  /* 
   * 以下几个变量表示英雄的等级 
   */ 
  //此处略去N行代码 
}

Nun, dann sagten sie: „Ich verwende Aufzählungen in der tatsächlichen Entwicklung selten.“

hero.setStatus(Contant.STATUS_ATTACKING);

Natürlich meinen sie sehr. Die Enum-Klasse wird selten verwendet.

Was ich jedoch sagen möchte ist, dass alle oben genannten Codes mit Enum implementiert werden sollten.

Warum?

Da ihr Code vollständig auf dem Vertrauen in Teamkollegen basiert, nehmen wir an, dass ein seltsamer Teamkollege kommt und Folgendes tut:

Was wird Ihrer Meinung nach mit den Helden auf der Leinwand passieren?

hero.setStatus(666);

Kurz gesagt: Wenn Sie solchen Code häufig in der tatsächlichen Programmierung verwenden, ist es an der Zeit, Enum zu lernen.

Eine vorläufige Studie zu Aufzählungen Warum Aufzählungstypen verwenden

Überall im Leben gibt es Aufzählungen, einschließlich „natürlicher Aufzählungen“ wie Planeten und Wochen Die Zahl of Days umfasst auch die von uns entworfenen Aufzählungen, wie z. B. csdn-Tab-Beschriftungen, Menüs usw.

Es gibt im Allgemeinen zwei Möglichkeiten, Aufzählungen in Java-Code auszudrücken. Eine davon ist die Enum-Aufzählung, aber wir alle wissen, dass die Enum-Aufzählung von Java bereitgestellt wird.

Warum verwenden wir also den Aufzählungstyp Enum? Schauen wir uns zunächst an, wie wir Aufzählungen vor Java 1.5 dargestellt haben, als es noch keine Aufzählungstypen gab.

Nehmen Sie die acht Planeten als Beispiel. Wir würden dies wahrscheinlich als Int-Aufzählungsmodus bezeichnen. Natürlich können Sie auch den String-Aufzählungsmodus verwenden Unabhängig davon, welche Methode verwendet wird, ist dieser Ansatz hinsichtlich der Typensicherheit und Benutzerfreundlichkeit sehr schlecht.
Wenn die Variable Planet einen Planeten darstellt, kann der Benutzer diesen Wert einem Wert zuweisen, der nicht in unserem Aufzählungswert enthalten ist, z. B. Planet = 9. Nur Gott weiß, um welchen Planeten es sich handelt, außerdem ist es für uns schwierig berechnen Ohne zu wissen, wie viele Planeten es gibt, wäre es für uns schwierig, die Planeten zu durchqueren und so weiter.

Jetzt verwenden wir Aufzählungen, um unsere Planeten zu erstellen.

public class PlanetWithoutEnum { 
  public static final int PLANET_MERCURY = 0; 
  public static final int PLANET_VENUS = 1; 
  public static final int PLANET_EARTH = 2; 
  public static final int PLANET_MARS = 3; 
  public static final int PLANET_JUPITER = 4; 
  public static final int PLANET_SATURN = 5; 
  public static final int PLANET_URANUS = 6; 
  public static final int PLANET_NEPTUNE = 7; 
}

Das Obige ist die einfachste Aufzählung. Nennen wir es Planet 1.0. Für diese Version der Planetenaufzählung haben wir eine Funktion implementiert, die For ist Bei jeder Variablen vom Typ Planet kann der Compiler garantieren, dass jedes an den Parameter übergebene Nicht-Null-Objekt zu einem dieser acht Planeten gehören muss.

Dann aktualisieren wir Planet Java und können dem Aufzählungstyp eine beliebige Methode hinzufügen. Hier finden Sie eine Einführung in den Konstruktor, die öffentliche Methode und die Aufzählung der Aufzählung. Geben Sie Wissenspunkte wie Durchquerung.

public enum Planet { 
  MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE; 
}

Run WeightTable, das Druckergebnis ist wie folgt:

public enum Planet { 
  MERCURY(3.302e+23, 2.439e6),  
  VENUS(4.869e+24, 6.052e6),  
  EARTH(5.975e+24,6.378e6),  
  MARS(6.419e+23, 3.393e6),  
  JUPITER(1.899e+27, 7.149e7),  
  SATURN(5.685e+26, 6.027e7),  
  URANUS(8.683e+25, 2.556e7),  
  NEPTUNE(1.024e+26,2.477e7); 
  private final double mass; // In kilograms 
  private final double radius; // In meters 
  private final double surfaceGravity; // In m / s^2 
 
  // Universal gravitational constant in m^3 / kg s^2 
  private static final double G = 6.67300E-11; 
 
  // Constructor 
  Planet(double mass, double radius) { 
    this.mass = mass; 
    this.radius = radius; 
    surfaceGravity = G * mass / (radius * radius); 
  } 
 
  public double mass() { 
    return mass; 
  } 
 
  public double radius() { 
    return radius; 
  } 
 
  public double surfaceGravity() { 
    return surfaceGravity; 
  } 
 
  public double surfaceWeight(double mass) { 
    return mass * surfaceGravity; // F = ma 
  } 
}

In diesem kleinen Programm verwenden wir die Methode „values()“ der Aufzählung. Diese Methode gibt eine Sammlung von Aufzählungsvariablen im Aufzählungstyp zurück, was sehr praktisch ist.

//注：这里对书中的代码做了微调 
public class WeightTable { 
  public static void main(String[] args) { 
    printfWeightOnAllPlanets(8d); 
  } 
 
  public static void printfWeightOnAllPlanets(double earthWeight) { 
    double mass = earthWeight / Planet.EARTH.surfaceGravity(); 
    for (Planet p : Planet.values()) 
      System.out.printf("Weight on %s is %f%n", p, p.surfaceWeight(mass)); 
  } 
}

Enumeration Advanced Calculator Operator Enumeration Class

Im Beispiel im vorherigen Abschnitt haben wir die öffentlichen Methoden der Aufzählungsklasse verwendet. In diesem Abschnitt verwenden wir die Taschenrechneroperation Take the Operationsaufzählungsklasse als Beispiel, um zu sehen, wie unterschiedliche Vorgänge für jedes Aufzählungsobjekt ausgeführt werden

.

Weight on MERCURY is 3.023254
Weight on VENUS is 7.240408
Weight on EARTH is 8.000000
Weight on MARS is 3.036832
Weight on JUPITER is 20.237436
Weight on SATURN is 8.524113
Weight on URANUS is 7.238844
Weight on NEPTUNE is 9.090108

Zuerst können wir uns einfach eine Methode vorstellen, in der wir den Aufzählungstyp mithilfe von switch bestimmen und dann verschiedene Operationen ausführen:

Dieser Code erfüllt zwar unsere Anforderungen, hat aber zwei Nachteile.

Zuerst müssen wir am Ende eine Ausnahme auslösen oder den Standardwert im Schalter hinzufügen, sonst wird die Kompilierung nicht erfolgreich sein. Aber offensichtlich wird der Zweig des Programms die Ausnahme nicht eingeben Standard.

Zweitens ist dieser Code sehr fragil. Wenn wir einen neuen Operationstyp hinzufügen, aber vergessen, die entsprechende Verarbeitungslogik im Schalter hinzuzufügen, treten beim Ausführen neuer Operationen Probleme auf.

public enum OperationUseSwitch { 
  PLUS, MINUS, TIMES, pIDE; 
 
  double apply(double x, double y) { 
    switch (this) { 
      case PLUS: 
        return x + y; 
      case MINUS: 
        return x + y; 
      case TIMES: 
        return x + y; 
      case pIDE: 
        return x + y; 
    } 
    // 如果this不属于上面四种操作符，抛出异常 
    throw new AssertionError("Unknown operation: " + this); 
  } 
}

Glücklicherweise bieten Java-Enumerationen eine Funktion namens konstante spezifische Methodenimplementierung.

Wir müssen nur eine abstrakte Methode im Aufzählungstyp deklarieren und diese Methode dann in jeder Aufzählungskonstante überschreiben. Die Implementierung ist wie folgt:

Auf diese Weise werden wir nie vergessen, nach dem Hinzufügen eines neuen Operators die entsprechende Verarbeitungslogik hinzuzufügen, da der Compiler uns auffordert, die Apply-Methode zu überschreiben.

Diese konstante spezifische Methodenimplementierung hat jedoch einen Nachteil: Es ist für Sie schwierig, Code zwischen Aufzählungskonstanten gemeinsam zu nutzen.

Nehmen wir die Aufzählung der Woche

如果还是使用 特定于常量的方法实现，写出来的代码可能就是这样的：

public enum DayUseAbstractMethod { 
  MONDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//伪代码 
    } 
  }, 
  TUESDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//伪代码 
    } 
  }, 
  WEDNESDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//伪代码 
    } 
  }, 
  THURSDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//伪代码 
    } 
  }, 
  FRIDAY { 
    @Override 
    void apply() { 
      dealWithWeekDays();//伪代码 
    } 
  }, 
  SATURDAY { 
    @Override 
    void apply() { 
      dealWithWeekEnds();//伪代码 
    } 
  }, 
  SUNDAY { 
    @Override 
    void apply() { 
      dealWithWeekEnds();//伪代码 
    } 
  }; 
 
  abstract void apply(); 
}

很明显，我们这段代码里面有相当多的重复代码。

那么要怎么优化呢，我们不妨这样想，星期一星期二等等是一种枚举，那么工作日和休息日，难道不也是一种枚举吗，我们能不能给Day的构造函数传入一个工作日休息日的DayType枚举呢？这也就是书中给出的一种叫策略枚举 的方法，代码如下：

public enum Day { 
  MONDAY(DayType.WEEKDAY), TUESDAY(DayType.WEEKDAY), WEDNESDAY( 
      DayType.WEEKDAY), THURSDAY(DayType.WEEKDAY), FRIDAY(DayType.WEEKDAY), SATURDAY( 
      DayType.WEEKDAY), SUNDAY(DayType.WEEKDAY); 
  private final DayType dayType; 
 
  Day(DayType daytype) { 
    this.dayType = daytype; 
  } 
 
  void apply() { 
    dayType.apply(); 
  } 
 
  private enum DayType { 
    WEEKDAY { 
      @Override 
      void apply() { 
        System.out.println("hi, weekday"); 
      } 
    }, 
    WEEKEND { 
      @Override 
      void apply() { 
        System.out.println("hi, weekend"); 
      } 
    }; 
    abstract void apply(); 
  } 
}

通过策略枚举的方式，我们把Day的处理逻辑委托给了DayType，个中奥妙，读者可以细细体会。

枚举集合   EnumSet的使用

EnumSet提供了非常方便的方法来创建枚举集合，下面这段代码，感受一下

public class Text { 
  public enum Style { 
    BOLD, ITALIC, UNDERLINE, STRIKETHROUGH 
  } 
 
  // Any Set could be passed in, but EnumSet is clearly best 
  public void applyStyles(Set<Style> styles) { 
    // Body goes here 
    for(Style style : styles){ 
      System.out.println(style); 
    } 
  } 
 
  // Sample use 
  public static void main(String[] args) { 
    Text text = new Text(); 
    text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC)); 
  } 
}

这个例子里，我们使用了EnumSet.of方法，轻松创建了枚举集合。

枚举Map   EnumMap的使用

假设对于香草（Herb），有一个枚举属性Type(一年生、多年生、两年生)

Herb:

public class Herb { 
  public enum Type { ANNUAL, PERENNIAL, BIENNIAL } 
 
  private final String name; 
  private final Type type; 
   
  Herb(String name, Type type) { 
    this.name = name; 
    this.type = type; 
  } 
 
  @Override public String toString() { 
    return name; 
  } 
}

现在，假设我们有一个Herb数组，我们需要对这个Herb数组按照Type进行分类存放。

所以接下来，我们需要创建一个Map，value肯定是Herb的集合了，那么用什么作为key呢？

有的人会使用枚举类型的ordinal()方法，这个函数返回int类型，表示枚举遍历在枚举类里的位置，这样做，缺点很明显，由于你的key的类型是int，不能保证传入的int一定能和枚举类里的变量对应上。

所以，在key的选择上，毫无疑问，只能使用枚举类型，也即Herb.Type。

最后还有一个问题，要使用什么Map? Java为枚举类型专门提供了一种Map，叫EnumMap，相比较与其他Map，这种Map在处理枚举类型上更快，有兴趣的同学可以研究一下这个map的内部实现。

下面让我们看看怎么使用EnumMap：

public static void main(String[] args) { 
  Herb[] garden = { new Herb("Basil", Type.ANNUAL), 
      new Herb("Carroway", Type.BIENNIAL), 
      new Herb("Dill", Type.ANNUAL), 
      new Herb("Lavendar", Type.PERENNIAL), 
      new Herb("Parsley", Type.BIENNIAL), 
      new Herb("Rosemary", Type.PERENNIAL) }; 
 
  // Using an EnumMap to associate data with an enum - Page 162 
  Map<Herb.Type, Set<Herb>> herbsByType = new EnumMap<Herb.Type, Set<Herb>>( 
      Herb.Type.class); 
  for (Herb.Type t : Herb.Type.values()) 
    herbsByType.put(t, new HashSet<Herb>()); 
  for (Herb h : garden) 
    herbsByType.get(h.type).add(h); 
  System.out.println(herbsByType); 
 
}

总结

和int枚举相比，Enum枚举的在类型安全和使用便利上的优势是不言而喻的。
Enum为枚举提供了丰富的功能，如文章中提到的特定于常量的方法实现和策略枚举。
EnumSet和EnumMap是两个为枚举而设计的集合，在实际开发中，用到枚举集合时，请优先考虑这两个。

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der Verwendung von Java-Enumerationen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!