Java : utilisation de l'instruction switch avec un enum sous une sous-classe

Question

Tout d'abord, je tiens à préciser que je suis beaucoup plus familier avec les enums en C# et qu'il semble que les enums en Java soient un véritable fouillis.

Comme vous pouvez le constater, j'essaie d'utiliser une instruction switch @ enums dans mon prochain exemple, mais j'obtiens toujours une erreur, quoi que je fasse.

L'erreur que je reçois est la suivante :

L'étiquette du cas qualifié SomeClass.AnotherClass.MyEnum.VALUE_A doit être remplacée par la constante d'énumération non qualifiée VALUE_A

Le fait est que je bastante Je comprends l'erreur mais je ne peux pas simplement écrire la VALUE_A puisque l'enum est située dans une autre sous-classe. Existe-t-il un moyen de résoudre ce problème ? Et pourquoi cela se produit-il en Java ?

//Main Class
public class SomeClass {

    //Sub-Class
    public static class AnotherClass {
        public enum MyEnum {
            VALUE_A, VALUE_B
        }    
        public MyEnum myEnum;
    }

    public void someMethod() { 
        MyEnum enumExample //...

        switch (enumExample) {
            case AnotherClass.MyEnum.VALUE_A: { <-- error on this line
                //..
                break;
            }
        }
    }
}

Answer 1

Changez-le en ceci :

switch (enumExample) {
    case VALUE_A: {
        //..
        break;
    }
}

L'indice est dans l'erreur. Vous n'avez pas besoin de vous qualifier case avec le type de l'enum, seulement sa valeur.

Answer 2

Faux :

case AnotherClass.MyEnum.VALUE_A

Bien :

case VALUE_A:

Answer 3

Java déduit automatiquement le type des éléments dans le fichier case Les étiquettes doivent donc être non qualifiées.

int i;
switch(i) {
   case 5: // <- integer is expected
}
MyEnum e;
switch (e) {
   case VALUE_A: // <- an element of the enumeration is expected
}

Answer 4

Cela devrait faire l'affaire :

//Main Class
public class SomeClass {

    //Sub-Class
    public static class AnotherClass {
        public enum MyEnum {
            VALUE_A, VALUE_B
        }    
        public MyEnum myEnum;
    }

    public void someMethod() { 
        AnotherClass.MyEnum enumExample = AnotherClass.MyEnum.VALUE_A; //...

        switch (enumExample) {
            case VALUE_A: { //<-- error on this line
            //..
            break;
            }
        }
    }
}

Answer 5

De Java 14 A partir de là, on peut utiliser des expressions de commutation.

Pour ce poste

public enum MyEnum {
    VALUE_A, VALUE_B;
}

public void someMethod() { 
    MyEnum enumExample //...

    switch (enumExample) {
        case VALUE_A -> {
            // logic
        }
        case VALUE_B -> {
            // logic
        }   
    }
}

Expression de l'interrupteur

Comme toutes les expressions, les expressions switch sont évaluées à une seule valeur et peuvent être utilisées dans des instructions. Elles peuvent contenir des étiquettes "case L ->" qui rendent inutile l'utilisation d'instructions break pour éviter les ruptures. Vous pouvez utiliser une instruction yield pour spécifier la valeur d'une expression switch.

public enum Month {
    JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC;
}

Exemple 1 : Retourne la valeur.

public static int getNoOfDaysInAMonth(Month month, boolean isLeapYear) {
    return switch(month) {
        case APR, JUN, SEP, NOV -> 30;
        case FEB -> (isLeapYear)? 29: 28;
        case JAN, MAR, MAY, JUL, AUG, OCT, DEC -> 31;
    };
}

Exemple 2 : Ne renvoie pas de valeur.

public static void printNoOfDaysInAMonth(Month month, boolean isLeapYear) {
    switch(month) {
        case APR, JUN, SEP, NOV -> {
            System.out.println("30 days");
        }
        case FEB -> {
            System.out.println(((isLeapYear)? 29: 28) + " days");
        }
        case JAN, MAR, MAY, JUL, AUG, OCT, DEC -> {
            System.out.println("31 days");
        }
    };
}

Référence

Expressions de commutation