Istruzione switch Java: espressione costante richiesta, ma è costante

Quindi, sto lavorando su questa classe che ha alcune costanti statiche:

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

Quindi, vorrei un modo per ottenere una stringa pertinente in base alla costante:

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

Tuttavia, quando compilo, ricevo un constant expression requirederrore su ciascuna delle 3 etichette del caso.

Capisco che il compilatore ha bisogno che l'espressione sia conosciuta al momento della compilazione per compilare uno switch, ma perché non è Foo.BA_costante?

Comprendo che il compilatore ha bisogno che l'espressione sia nota al momento della compilazione per compilare uno switch, ma perché Foo.BA_ non è costante?

Sebbene siano costanti dal punto di vista di qualsiasi codice che viene eseguito dopo l'inizializzazione dei campi, non sono una costante di tempo di compilazione nel senso richiesto da JLS; vedi §15.28 espressioni costanti per la specifica di una costante espressione ¹ . Questo si riferisce al §4.12.4 Variabili finali che definisce una "variabile costante" come segue:

Chiamiamo una variabile, di tipo primitivo o tipo String, che è finale e inizializzata con un'espressione costante in fase di compilazione (§15.28) una variabile costante. Il fatto che una variabile sia una variabile costante o meno può avere implicazioni rispetto all'inizializzazione della classe (§12.4.1), compatibilità binaria (§13.1, §13.4.9) e assegnazione definita (§16).

Nel tuo esempio, le variabili Foo.BA * non hanno inizializzatori e quindi non si qualificano come "variabili costanti". La correzione è semplice; modificare le dichiarazioni delle variabili Foo.BA * in modo che abbiano inizializzatori che sono espressioni costanti in fase di compilazione.

In altri esempi (in cui gli inizializzatori sono già espressioni costanti in fase di compilazione), dichiarando la variabile come finalpotrebbe essere ciò che è necessario.

È possibile modificare il codice per utilizzare una enumanziché una intcostante, ma ciò comporta un altro paio di restrizioni diverse:

• È necessario includere un defaultcaso, anche se si dispone caseper ogni valore conosciuto del enum; vedi Perché è necessario il default per un interruttore su un enum?
• Le caseetichette devono essere tutte enumvalori espliciti , non espressioni che valutano enumvalori.

^{1 - Le restrizioni di espressione costante possono essere riassunte come segue. Espressioni costanti a) possono utilizzare tipi primitivi e Stringsolo, b) consentire primarie che sono letterali (a parte null) e variabili costanti solo, c) consentire espressioni costanti eventualmente parentesi, come sottoespressioni, d) consentire agli operatori tranne per operatori di assegnazione, ++, --o instanceof, e e) consentire il cast di tipi Stringsolo a tipi primitivi .}

^{Si noti che questo non include alcuna forma di chiamate di metodo o di lambda, new, .class. .lengtho sottoscrizione di array. Inoltre, qualsiasi uso di valori di array, enumvalori, valori di tipi di wrapper primitivi, boxe e unboxing sono tutti esclusi a causa di a).}

Ottieni l' espressione Costante richiesta perché hai lasciato i valori fuori dalle tue costanti. Provare:

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

Ho riscontrato questo errore su Android e la mia soluzione era solo quella di utilizzare:

public static final int TAKE_PICTURE = 1;

invece di

public static int TAKE_PICTURE = 1;

Perché quelli non sono costanti di tempo di compilazione. Considera il seguente codice valido:

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

Puoi conoscere solo il valore di BARin runtime.

Puoi usare un enum come in questo esempio:

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

Fonte: istruzione Switch con enum

Questa è stata risposta anni fa e probabilmente non è rilevante, ma per ogni evenienza. Quando mi sono trovato di fronte a questo problema, ho semplicemente usato ifun'istruzione invece di switch, risolto l'errore. Naturalmente è una soluzione alternativa e probabilmente non è la soluzione "giusta", ma nel mio caso è stata appena sufficiente.

A volte la variabile switch può anche fare questo errore, ad esempio:

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

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

   //...
}

Per risolvere dovresti lanciare la variabile in int (in questo caso). Così:

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

   case 0: //No Error

   //...
}

Ho ricevuto questo errore in Android mentre facevo qualcosa del genere:

 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

            }

nonostante abbia dichiarato una costante:

public static final String ADMIN_CONSTANT= "Admin";

Ho risolto il problema modificando il mio codice in questo:

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:

            }

Nel mio caso, stavo ottenendo questa eccezione perché

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

nel secondo caso stavo chiamando la costante dall'istanza var.MODIFICAR_KM:ma avrei dovuto usarla VariablesKmDialog.OBTENER_KMdirettamente dalla classe.

Se lo si utilizza in una custodia, è necessario ottenere il tipo di enum anche prima di inserire quel valore nello switch. Per esempio :

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

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

E l'enum è come:

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

Di seguito il codice è autoesplicativo, possiamo usare un enum con una custodia:

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

Sulla base dei valori di classe dall'enum può essere mappato:

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

    }

Spero che sia d'aiuto :)

Raccomando di usare il seguente modo:

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

Ti consiglio di usare enums :)

Controllalo:

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

Quindi puoi usarlo in questo modo:

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