enum Schlüsselwort in Java

Das Schlüsselwort enum wird in Java verwendet, um eine Reihe von benannten Konstanten zu definieren. Es ist ein spezieller Datentyp, der es ermöglicht, dass Variablen eine Reihe von vordefinierten Konstanten sind, wodurch der Code lesbarer und wartbarer wird. Enums werden häufig verwendet, um eine Sammlung von zusammenhängenden Konstanten darzustellen, z. B. Wochentage, Monate oder Zustände in einem Prozess.

Verwendung

Enums bieten eine Möglichkeit, eine Sammlung von Konstanten auf typsichere Weise zu definieren. Sie können Methoden und Felder enthalten und sie können Schnittstellen implementieren.

Syntax

enum EnumName {
    CONSTANT1, CONSTANT2, CONSTANT3;
}Bereitgestellt von

• EnumName: Der Name der Aufzählung.
• CONSTANT1, CONSTANT2, CONSTANT3: Die Konstanten, die innerhalb der Aufzählung definiert sind.

Beispiele

Beispiel 1: Basic Enum

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is: " + today);
    }
}Bereitgestellt von

In diesem Beispiel wird ein Enum Day mit Konstanten für die Wochentage definiert. Der Variablen today wird der Wert Day.MONDAY zugewiesen, und das Programm druckt den aktuellen Tag aus.

Beispiel 2: Enum mit Methoden

enum Size {
    SMALL, MEDIUM, LARGE;

    public String getSize() {
        switch (this) {
            case SMALL: return "Small Size";
            case MEDIUM: return "Medium Size";
            case LARGE: return "Large Size";
            default: return "Unknown Size";
        }
    }
}

public class EnumWithMethodExample {
    public static void main(String[] args) {
        Size size = Size.MEDIUM;
        System.out.println("Selected size: " + size.getSize());
    }
}Bereitgestellt von

Dieses Beispiel demonstriert ein Enum Size mit einer Methode getSize(), die eine String-Repräsentation der Größe zurückgibt. Der Variablen size wird Size.MEDIUM zugewiesen, und das Programm gibt die entsprechende Größenbeschreibung aus.

Beispiel 3: Enum mit Feldern und Konstruktor

enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double getMass() {
        return mass;
    }

    public double getRadius() {
        return radius;
    }
}

public class EnumWithFieldsExample {
    public static void main(String[] args) {
        for (Planet planet : Planet.values()) {
            System.out.printf("Planet: %s, Mass: %f, Radius: %f%n", planet, planet.getMass(), planet.getRadius());
        }
    }
}Bereitgestellt von

In diesem Beispiel hat die Aufzählung Planet die Felder mass und radius, einen Konstruktor, um diese Felder zu initialisieren, und Getter-Methoden, um auf sie zuzugreifen. Das Programm durchläuft alle Enum-Konstanten und gibt ihre Details aus.

Tipps und bewährte Praktiken

• Verwendung für Konstanten: Verwende Enums, um einen festen Satz von Konstanten zu definieren und so die Lesbarkeit und Wartungsfreundlichkeit des Codes zu verbessern.
• Typ Sicherheit: Enums bieten Typsicherheit im Vergleich zu traditionellen Konstantendefinitionen mit final static.
• Switch-Anweisungen: Enums funktionieren nahtlos mit Switch-Anweisungen und machen den Code sauberer.

  switch (size) {
      case SMALL:
          // Handle small size
          break;
      case MEDIUM:
          // Handle medium size
          break;
      case LARGE:
          // Handle large size
          break;
  }Bereitgestellt von

• Schnittstellen implementieren: Enums können Schnittstellen implementieren, was einen flexibleren und wiederverwendbaren Code ermöglicht.

  interface Describable {
      String getDescription();
  }
  
  enum Color implements Describable {
      RED, GREEN, BLUE;
  
      @Override
      public String getDescription() {
          return "Color: " + this.name();
      }
  }Bereitgestellt von

• Vermeide eine Überbeanspruchung: Auch wenn Enums sehr mächtig sind, solltest du sie nicht zu sehr für einfache Konstanten verwenden. Verwende sie, wenn es eine klare Reihe von zusammenhängenden Konstanten gibt.