Java: Verwenden der switch-Anweisung mit enum unter der Unterklasse

Zuerst werde ich sagen, dass ich mit Enums in C # viel besser vertraut bin und es scheint, dass Enums in Java ein ziemliches Durcheinander sind.

Wie Sie sehen können, versuche ich in meinem nächsten Beispiel, eine switch-Anweisung @ enums zu verwenden, aber ich erhalte immer eine Fehlermeldung, egal was ich tue.

Der Fehler, den ich erhalte, ist:

Das qualifizierte Falletikett SomeClass.AnotherClass.MyEnum.VALUE_Amuss durch die nicht qualifizierte Enum-Konstante ersetzt werdenVALUE_A

Die Sache ist, dass ich den Fehler ziemlich verstehe, aber ich kann nicht einfach VALUE_A schreiben, da sich die Aufzählung in einer anderen Unterklasse befindet. Gibt es eine Möglichkeit, dieses Problem zu lösen? Und warum passiert das in 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;
            }
        }
    }
}

Ändern Sie es in dieses:

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

Der Hinweis liegt im Fehler. Sie müssen keine caseBeschriftungen mit dem Aufzählungstyp qualifizieren, sondern nur dessen Wert.

Java leitet automatisch den Typ der Elemente ab case, sodass die Beschriftungen nicht qualifiziert werden müssen.

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

das sollte reichen:

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

Falsch:

case AnotherClass.MyEnum.VALUE_A

Recht:

case VALUE_A:

So benutze ich es. Und es funktioniert fantastisch -

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

Und das switch-casewie unten gezeigt

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

Schreiben Sie folgendermaßen someMethod():

public void someMethod() {

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

    switch (enumExample) {
    case VALUE_A:
        break;
    }

}

In der switch-Anweisung dürfen Sie nur den Konstantennamen verwenden.