Quelle est l'utilisation de "enum" en Java?

Question

J'ai donc examiné ce type "enum", et cela me semble être un tableau glorifié / ArrayList / List . A quoi sert-il exactement?

Answer 1

Vous utilisez un enum au lieu de class si la classe doit avoir un nombre fixe d'instances.

Exemples:

• Weekday = 7 instances → enum
• CardSuit = 4 instances → enum
• Singleton = 1 exemple → enum
  
  
• Product = nombre variable d'instances → class
• User = nombre variable d'instances → class
• Date = nombre variable d'instances → class

Answer 2

Enum sert comme un type de nombre fixe de constantes et peut être utilisé au moins pour deux choses

constant

public enum Month {
    JANUARY, FEBRUARY, ...
}

C'est beaucoup mieux que la création d'un groupe de constantes entières.

la création d'un singleton

public enum Singleton {
    INSTANCE

   // init
};

Vous pouvez faire pas mal de choses intéressantes avec les énumérations, regardez ici

Regardez également la documentation officielle

Answer 3

Un type énuméré est fondamentalement un type de données qui permet de décrire chaque membre d'un type dans un plus lisible et fiable.

Voici un exemple simple pour expliquer pourquoi:

En supposant que vous écrivez une méthode qui a quelque chose à voir avec les saisons:

L'int enum modèle

Tout d'abord, vous avez déclaré des int constantes statiques pour représenter chaque saison.

public static final int SPRING = 0;
public static final int SUMMER = 1;
public static final int FALL = 2;
public static final int WINTER = 2;

Ensuite, vous avez déclaré une méthode pour imprimer le nom de la saison dans la console.

public void printSeason(int seasonCode) {
    String name = "";
    if (seasonCode == SPRING) {
        name = "Spring";
    }
    else if (seasonCode == SUMMER) {
        name = "Summer";
    }
    else if (seasonCode == FALL) {
        name = "Fall";
    }
    else if (seasonCode == WINTER) {
        name = "Winter";
    }
    System.out.println("It is " + name + " now!");
}

Alors, après ça, vous pouvez imprimer une saison nom comme ça.

printSeason(SPRING);
printSeason(WINTER);

C'est une jolie commune (mais mauvaise) façon de faire des choses différentes pour les différents types de membres dans une classe. Cependant, depuis ces code implique entiers, de sorte que vous pouvez également appeler la méthode comme ça, sans aucun problème.

printSeason(0);
printSeason(1);

ou encore comme ce

printSeason(x - y);
printSeason(10000);

Le compilateur ne va pas se plaindre parce que ces appels de méthode sont valides, et votre printSeason méthode peut encore travailler.

Mais quelque chose ne va pas ici. Ce qui fait une saison de code d' 10000 censé signifier? Que faire si x - y résultats dans un nombre négatif? Lorsque votre méthode reçoit une entrée qui n'a pas de sens et n'est pas censé être là, votre programme ne sait rien à ce sujet.

Vous pouvez corriger ce problème, par exemple, par l'ajout d'une vérification supplémentaire.

...
else if (seasonCode == WINTER) {
    name = "Winter";
}
else {
    throw new IllegalArgumentException();
}
System.out.println(name);

Désormais, le programme de jeter un RunTimeException lors de la saison de code n'est pas valide. Cependant, vous devez décider comment vous allez gérer l'exception.

Par ailleurs, je suis sûr que vous avez remarqué le code de l' FALL et WINTER sont à la fois 2, droit?

Vous devriez obtenir l'idée maintenant. Ce modèle est fragile. Il vous fait écrire condition vérifie partout. Si vous faites un jeu, et vous voulez ajouter un supplément de saison dans votre monde imaginaire, ce modèle vous fera passer par toutes les méthodes qui font des choses par saison, et dans la plupart des cas, vous oubliez certains d'entre eux.

Vous pourriez penser que l'héritage de classe est une bonne idée pour ce cas. Mais nous avons besoin juste de eux et rien de plus.

C'est lors de l' enum entre en jeu.

---

Utiliser enum type

En Java, enum types sont des classes que l'exportation d'une instance pour chaque constante d'énumération par l'intermédiaire d'un public static final de terrain.

Ici vous pouvez déclarer les quatre énumération des constantes: SPRING, SUMMER, FALL, WINTER. Chacun a sa propre name.

public enum Season {
    SPRING("Spring"), SUMMER("Summer"), FALL("Fall"), WINTER("Winter");

    private String name;

    Season(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Maintenant, revenir à la méthode.

public void printSeason(Season season) {
    System.out.println("It is " + season.getName() + " now!");
}

Au lieu d'utiliser int, vous pouvez maintenant utiliser Season comme entrée. Au lieu d'une condition de vérifier, vous pouvez dire Season pour vous donner son nom.

C'est la façon dont vous utilisez cette méthode:

printSeason(Season.SPRING);
printSeason(Season.WINTER);
printSeason(Season.WHATEVER); <-- compile error

Vous obtiendrez une erreur de compilation lorsque vous utilisez une entrée incorrecte, et vous avez la garantie d'obtenir un non-null singleton de référence de l' Season , tant que le programme compile.

Lorsque nous avons besoin d'un supplément de saison, nous avons simplement ajouter une autre constante en Season et pas plus.

public enum Season {
    SPRING("Spring"), SUMMER("Summer"), FALL("Fall"), WINTER("Winter"), 
    MYSEASON("My Season");

...

---

Chaque fois que vous avez besoin d'un ensemble fixe de constantes, enum peut être un bon choix (mais pas toujours). C'est plus lisible, plus fiable et plus performant.

Answer 4

Un type enum est un type dont les champs sont constitués d'un ensemble fixe de constantes. Des exemples communs incluent directions de la boussole (NORD, SUD, EST et OUEST) et les jours de la semaine.

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

Vous devez utiliser les types enum tout moment vous avez besoin de représenter un ensemble fixe de constantes. Qui comprend les types enum comme les planètes dans notre système solaire et des ensembles de données où vous savez toutes les valeurs possibles au moment de la compilation-par exemple, le choix d'un menu, les options de ligne de commande, et ainsi de suite.

Voici un code qui vous montre comment utiliser le Jour enum définis ci-dessus:

public class EnumTest {
    Day day;

    public EnumTest(Day day) {
        this.day = day;
    }

    public void tellItLikeItIs() {
        switch (day) {
            case MONDAY:
                System.out.println("Mondays are bad.");
                break;

            case FRIDAY:
                System.out.println("Fridays are better.");
                break;

            case SATURDAY: case SUNDAY:
                System.out.println("Weekends are best.");
                break;

            default:
                System.out.println("Midweek days are so-so.");
                break;
        }
    }

    public static void main(String[] args) {
        EnumTest firstDay = new EnumTest(Day.MONDAY);
        firstDay.tellItLikeItIs();
        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
        thirdDay.tellItLikeItIs();
        EnumTest fifthDay = new EnumTest(Day.FRIDAY);
        fifthDay.tellItLikeItIs();
        EnumTest sixthDay = new EnumTest(Day.SATURDAY);
        sixthDay.tellItLikeItIs();
        EnumTest seventhDay = new EnumTest(Day.SUNDAY);
        seventhDay.tellItLikeItIs();
    }
}

La sortie est:

Les lundis sont mauvais.
En milieu de semaine jours sont so-so.
Les vendredis sont mieux.
Les week-ends sont les meilleurs.
Les week-ends sont les meilleurs.

Le langage de programmation Java les types enum sont beaucoup plus puissants que leurs homologues dans d'autres langues. La déclaration d'enum définit une classe (appelé un type enum). L'enum corps de classe peut comprendre des méthodes et des autres champs. Le compilateur ajoute automatiquement certaines méthodes spéciales lorsqu'il crée un enum. Par exemple, ils ont des valeurs statiques méthode qui retourne un tableau contenant toutes les valeurs de l'enum dans l'ordre où elles sont déclarées. Cette méthode est couramment utilisé en combinaison avec le pour-chaque construction pour effectuer une itération sur les valeurs d'un type enum. Par exemple, ce code à partir de la classe de la Planète exemple ci-dessous passe en revue toutes les planètes du système solaire.

for (Planet p : Planet.values()) {
    System.out.printf("Your weight on %s is %f%n",
                      p, p.surfaceWeight(mass));
}

En plus de ses propriétés et de son constructeur, la Planète a des méthodes qui vous permettent de récupérer de la surface de la gravité et le poids d'un objet sur chaque planète. Voici un exemple de programme qui prend votre poids sur la terre (dans n'importe quelle unité) et calcule et imprime votre poids sur toutes les planètes (dans la même unité):

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }
}

Si vous exécutez Planet.class à partir de la ligne de commande avec un argument de 175, vous obtenez ce résultat:

$ java Planète 175
Votre poids sur le MERCURE est 66.107583
Votre poids de VÉNUS est 158.374842
Votre poids sur TERRE est 175.000000
Votre poids sur MARS est 66.279007
Votre poids sur JUPITER est 442.847567
Votre poids sur SATURN est 186.552719
Votre poids sur URANUS est 158.397260
Votre poids sur NEPTUNE est 199.207413

Source: http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

Answer 5

un Enum est un type sûr, vous ne pouvez donc pas affecter une nouvelle valeur au moment de l'exécution. De plus, vous pouvez l'utiliser dans une instruction switch (comme un int).