Java-Switch-Anweisung: Konstanter Ausdruck erforderlich, aber konstant

Ich arbeite also an dieser Klasse, die einige statische Konstanten hat:

public abstract class Foo {
    ...
    public static final int BAR;
    public static final int BAZ;
    public static final int BAM;
    ...
}

Dann möchte ich einen Weg finden, einen relevanten String basierend auf der Konstante zu erhalten:

public static String lookup(int constant) {
    switch (constant) {
        case Foo.BAR: return "bar";
        case Foo.BAZ: return "baz";
        case Foo.BAM: return "bam";
        default: return "unknown";
    }
}

Beim Kompilieren wird jedoch constant expression requiredauf jedem der drei Falletiketten eine Fehlermeldung angezeigt.

Ich verstehe, dass der Compiler den Ausdruck benötigt, der zur Kompilierungszeit bekannt sein muss, um einen Switch zu kompilieren, aber warum ist er nicht Foo.BA_konstant?

Ich verstehe, dass der Compiler den Ausdruck zur Kompilierungszeit kennen muss, um einen Switch zu kompilieren, aber warum ist Foo.BA_ nicht konstant?

Während sie aus der Sicht eines Codes konstant sind, der nach der Initialisierung der Felder ausgeführt wird, sind sie keine Kompilierungszeitkonstante im Sinne des JLS. siehe §15.28 Konstante Ausdrücke für die Angabe eines konstanten Ausdrucks ¹ . Dies bezieht sich auf §4.12.4 Endvariablen, der eine "konstante Variable" wie folgt definiert:

Wir nennen eine Variable vom primitiven Typ oder Typ String, die endgültig ist und mit einem konstanten Ausdruck zur Kompilierungszeit (§15.28) initialisiert wird, eine konstante Variable. Ob eine Variable eine konstante Variable ist oder nicht, kann Auswirkungen auf die Klasseninitialisierung (§12.4.1), die Binärkompatibilität (§13.1, §13.4.9) und die definitive Zuordnung (§16) haben.

In Ihrem Beispiel haben die Foo.BA * -Variablen keine Initialisierer und gelten daher nicht als "konstante Variablen". Das Update ist einfach; Ändern Sie die Foo.BA * -Variablendeklarationen so, dass Initialisierer Konstantenausdrücke zur Kompilierungszeit sind.

In anderen Beispielen (in denen die Initialisierer bereits Konstantenausdrücke zur Kompilierungszeit sind) wird die Variable als finalerforderlich deklariert .

Sie könnten Ihren Code so ändern, dass er eine Konstante enumanstelle von intKonstanten verwendet. Dies bringt jedoch noch einige andere Einschränkungen mit sich:

• Sie müssen einen defaultFall einschließen , auch wenn Sie casefür jeden bekannten Wert der enum; Siehe Warum ist die Standardeinstellung für einen Schalter in einer Aufzählung erforderlich?
• Die caseBeschriftungen müssen alle explizite enumWerte sein, keine Ausdrücke, die zu enumWerten ausgewertet werden.

^{1 - Die Einschränkungen für konstante Ausdrücke können wie folgt zusammengefasst werden. Konstante Ausdrücke a) können primitive Typen verwenden und Stringnur, b) Primäre zulassen, die Literale (außer null) und nur konstante Variablen sind, c) konstante Ausdrücke zulassen, die möglicherweise als Unterausdrücke in Klammern stehen, d) Operatoren außer Zuweisungsoperatoren zulassen ++, --oder instanceof, und e) Typumwandlungen für primitive Typen oder Stringnur zulassen .}

^{Beachten Sie, dass dies keine Form von Verfahren oder Lambda - Anrufe enthält, new, .class. .lengthoder Array-Subskription. Darüber hinaus ist die Verwendung von Array-Werten, enumWerten, Werten primitiver Wrapper-Typen, Boxing und Unboxing aufgrund von a) ausgeschlossen.}

Sie erhalten den Ausdruck Konstante erforderlich, weil Sie die Werte von Ihren Konstanten weggelassen haben. Versuchen:

public abstract class Foo {
    ...
    public static final int BAR=0;
    public static final int BAZ=1;
    public static final int BAM=2;
    ...
}

Ich habe diesen Fehler auf Android erhalten und meine Lösung war nur zu verwenden:

public static final int TAKE_PICTURE = 1;

anstatt

public static int TAKE_PICTURE = 1;

Weil dies keine Kompilierungszeitkonstanten sind. Betrachten Sie den folgenden gültigen Code:

public static final int BAR = new Random().nextInt();

Sie können den Wert von nur BARzur Laufzeit kennen.

Sie können eine Aufzählung wie in diesem Beispiel verwenden:

public class MainClass {
enum Choice { Choice1, Choice2, Choice3 }
public static void main(String[] args) {
Choice ch = Choice.Choice1;

switch(ch) {
  case Choice1:
    System.out.println("Choice1 selected");
    break;
 case Choice2:
   System.out.println("Choice2 selected");
   break;
 case Choice3:
   System.out.println("Choice3 selected");
   break;
    }
  }
}

Quelle: Switch-Anweisung mit Aufzählung

Dies wurde vor Ewigkeiten beantwortet und ist wahrscheinlich nicht relevant, aber nur für den Fall. Als ich mit diesem Problem konfrontiert wurde, habe ich einfach eine ifAussage verwendet, anstatt switchden Fehler zu beheben. Es ist natürlich eine Problemumgehung und wahrscheinlich nicht die "richtige" Lösung, aber in meinem Fall war es gerade genug.

Manchmal kann die Schaltvariable auch diesen Fehler machen, zum Beispiel:

switch(view.getTag()) {//which is an Object type

   case 0://will give compiler error that says Constant expression required

   //...
}

Zum Lösen sollten Sie die Variable in int umwandeln (in diesem Fall). So:

switch((int)view.getTag()) {//will be int

   case 0: //No Error

   //...
}

Ich habe diesen Fehler in Android erhalten, als ich so etwas gemacht habe:

 roleSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
        @Override
        public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {

            switch (parent.getItemAtPosition(position)) {
                case ADMIN_CONSTANT: //Threw the error

            }

trotz der Angabe einer Konstanten:

public static final String ADMIN_CONSTANT= "Admin";

Ich habe das Problem behoben, indem ich meinen Code folgendermaßen geändert habe:

roleSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
        @Override
        public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {

            String selectedItem = String.valueOf(parent.getItemAtPosition(position));
            switch (selectedItem) {
                case ADMIN_CONSTANT:

            }

In meinem Fall bekam ich diese Ausnahme, weil

switch (tipoWebServ) {
                            case VariablesKmDialog.OBTENER_KM:
                                resultObtenerKm(result);
                                break;
                            case var.MODIFICAR_KM:
                                resultModificarKm(result);
                                break;
                        }

Im zweiten Fall habe ich die Konstante aus der Instanz aufgerufen, var.MODIFICAR_KM:aber ich sollte sie VariablesKmDialog.OBTENER_KMdirekt aus der Klasse verwenden.

Wenn Sie es in einem Switch-Gehäuse verwenden, müssen Sie den Typ der Aufzählung abrufen, bevor Sie diesen Wert in den Switch einstecken. Zum Beispiel :

SomeEnum someEnum = SomeEnum.values ​​() [1];

switch (someEnum) {
            case GRAPES:
            case BANANA: ...

Und die Aufzählung ist wie:

public enum SomeEnum {

    GRAPES("Grapes", 0),
    BANANA("Banana", 1),

    private String typeName;
    private int typeId;

    SomeEnum(String typeName, int typeId){
        this.typeName = typeName;
        this.typeId = typeId;
    }
}

Der folgende Code ist selbsterklärend. Wir können eine Aufzählung mit einem Schaltergehäuse verwenden:

/**
 *
 */
enum ClassNames {
    STRING(String.class, String.class.getSimpleName()),
    BOOLEAN(Boolean.class, Boolean.class.getSimpleName()),
    INTEGER(Integer.class, Integer.class.getSimpleName()),
    LONG(Long.class, Long.class.getSimpleName());
    private Class typeName;
    private String simpleName;
    ClassNames(Class typeName, String simpleName){
        this.typeName = typeName;
        this.simpleName = simpleName;
    }
}

Basierend auf den Klassenwerten kann die Aufzählung zugeordnet werden:

 switch (ClassNames.valueOf(clazz.getSimpleName())) {
        case STRING:
            String castValue = (String) keyValue;
            break;
        case BOOLEAN:
            break;
        case Integer:
            break;
        case LONG:
            break;
        default:
            isValid = false;

    }

Ich hoffe es hilft :)

Ich empfehle folgende Methode:

public enum Animal {
    DOG("dog"), TIGER("tiger"), LION("lion");
    private final String name;

    @Override
    public String toString() {
        return this.name;
    }
}


public class DemoSwitchUsage {

     private String getAnimal(String name) {
         Animal animalName = Animal.valueOf(name);
         switch(animalName) {
         case DOG:
             // write the code required.
             break;
         case LION:
             // Write the code required.
             break;
         default:
             break;
         }
     }
}

Ich empfehle dir, Aufzählungen zu verwenden :)

Überprüfen Sie dies heraus:

public enum Foo 
{
    BAR("bar"),
    BAZ("baz"),
    BAM("bam");

    private final String description;

    private Foo(String description)
    {
        this.description = description;
    }

    public String getDescription()
    {
        return description;
    }
}

Dann können Sie es so verwenden:

System.out.println(Foo.BAR.getDescription());