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

Tout d'abord, je dirai que je suis beaucoup plus familier avec les énumérations en C # et il semble que les énumérations en java soient un vrai gâchis.

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

L'erreur que je reçois est:

L'étiquette de boîtier qualifiée SomeClass.AnotherClass.MyEnum.VALUE_Adoit être remplacée par la constante d'énumération non qualifiéeVALUE_A

Le fait est que je comprends bien l'erreur, mais je ne peux pas simplement écrire VALUE_A car l'énumération est située dans une autre sous-classe. Existe-t-il un moyen de résoudre ce problème? Et pourquoi cela se passe-t-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;
            }
        }
    }
}

Changez-le en ceci:

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

L'indice est dans l'erreur. Vous n'avez pas besoin de qualifier les caseétiquettes avec le type enum, juste sa valeur.

Java déduit automatiquement le type des éléments case, de sorte que les étiquettes doivent ê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
}

cela devrait faire:

//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;
            }
        }
    }
}

Faux:

case AnotherClass.MyEnum.VALUE_A

Droite:

case VALUE_A:

Voilà comment je l'utilise. Et cela fonctionne à merveille -

public enum Button {
        REPORT_ISSUES(0),
        CANCEL_ORDER(1),
        RETURN_ORDER(2);

        private int value;

        Button(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

Et switch-casecomme indiqué ci-dessous

@Override
public void onClick(MyOrderDetailDelgate.Button button, int position) {
    switch (button) {
        case REPORT_ISSUES: {
            break;
        }
        case CANCEL_ORDER: {
            break;
        }
        case RETURN_ORDER: {
            break;
        }
    }
}

Écrivez someMethod()de cette façon:

public void someMethod() {

    SomeClass.AnotherClass.MyEnum enumExample = SomeClass.AnotherClass.MyEnum.VALUE_A;

    switch (enumExample) {
    case VALUE_A:
        break;
    }

}

Dans l'instruction switch, vous devez utiliser uniquement le nom constant.