Declaración de cambio de Java: se requiere una expresión constante, pero ES constante

Entonces, estoy trabajando en esta clase que tiene algunas constantes estáticas:

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

Entonces, me gustaría una forma de obtener una cadena relevante basada en la constante:

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

Sin embargo, cuando compilo, aparece un constant expression requirederror en cada una de las 3 etiquetas de caso.

Entiendo que el compilador necesita que la expresión se conozca en el momento de la compilación para compilar un interruptor, pero ¿por qué no es Foo.BA_constante?

Entiendo que el compilador necesita que la expresión se conozca en el momento de la compilación para compilar un conmutador, pero ¿por qué no es constante Foo.BA_?

Si bien son constantes desde la perspectiva de cualquier código que se ejecute después de que se hayan inicializado los campos, no son una constante de tiempo de compilación en el sentido requerido por JLS; vea §15.28 Expresiones constantes para la especificación de una expresión constante ¹ . Esto se refiere a §4.12.4 Variables finales que define una "variable constante" de la siguiente manera:

Llamamos a una variable, de tipo primitivo o tipo String, que es final e inicializada con una expresión constante en tiempo de compilación (§15.28) una variable constante. Si una variable es una variable constante o no, puede tener implicaciones con respecto a la inicialización de la clase (§12.4.1), la compatibilidad binaria (§13.1, §13.4.9) y la asignación definida (§16).

En su ejemplo, las variables Foo.BA * no tienen inicializadores y, por lo tanto, no califican como "variables constantes". La solución es simple; cambie las declaraciones de variables Foo.BA * para tener inicializadores que sean expresiones constantes en tiempo de compilación.

En otros ejemplos (donde los inicializadores ya son expresiones constantes en tiempo de compilación), declarar la variable como finalpuede ser lo que se necesita.

Puede cambiar su código para usar una en enumlugar de intconstantes, pero eso trae otro par de restricciones diferentes:

• Usted debe incluir un defaultcaso, incluso si usted tiene casepara cada valor conocido de la enum; consulte ¿Por qué se requiere el valor predeterminado para un cambio en una enumeración?
• Las caseTodas las etiquetas deben ser explícitos enumlos valores, no expresiones que se evalúan como enumvalores.

^{1 - Las restricciones de expresión constante se pueden resumir de la siguiente manera. Las expresiones constantes a) pueden usar tipos primitivos y Stringsolo, b) permitir primarios que sean literales (aparte de null) y solo variables constantes, c) permitir expresiones constantes posiblemente entre paréntesis como subexpresiones, d) permitir operadores excepto operadores de asignación ++, --o instanceof, y e) permitir conversiones de tipos a tipos primitivos o Stringsolo.}

^{Tenga en cuenta que esto no incluye ningún tipo de método o lambda llamadas, new, .class. .lengtho suscripciones de matriz. Además, cualquier uso de valores de matriz, enumvalores, valores de tipos de envoltorio primitivo, boxeo y unboxing están excluidos debido a a).}

Obtiene la expresión Constante requerida porque dejó los valores fuera de sus constantes. Tratar:

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

Recibí este error en Android, y mi solución fue solo usar:

public static final int TAKE_PICTURE = 1;

en vez de

public static int TAKE_PICTURE = 1;

Porque esas no son constantes de tiempo de compilación. Considere el siguiente código válido:

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

Solo puede conocer el valor de BARen tiempo de ejecución.

Puede usar una enumeración como en este ejemplo:

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

Fuente: declaración de cambio con enumeración

Esto fue respondido hace años y probablemente no sea relevante, pero por si acaso. Cuando me enfrenté a este problema, simplemente usé una ifdeclaración en lugar de switch, resolvió el error. Por supuesto, es una solución alternativa y probablemente no sea la solución "correcta", pero en mi caso fue suficiente.

A veces el variable interruptor también puede cometer ese error, por ejemplo:

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

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

   //...
}

Para resolver, debe convertir la variable a int (en este caso). Entonces:

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

   case 0: //No Error

   //...
}

Recibí este error en Android al hacer algo como esto:

 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

            }

a pesar de declarar una constante:

public static final String ADMIN_CONSTANT= "Admin";

Resolví el problema cambiando mi código a esto:

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:

            }

En mi caso, recibí esta excepción porque

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

en el segundo caso, estaba llamando a la constante desde la instancia, var.MODIFICAR_KM:pero debería usarla VariablesKmDialog.OBTENER_KMdirectamente desde la clase.

Si lo está utilizando en una caja de interruptor, entonces necesita obtener el tipo de la enumeración incluso antes de enchufar ese valor en el interruptor. Por ejemplo :

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

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

Y la enumeración es como:

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

El siguiente código se explica por sí mismo. Podemos usar una enumeración con una caja de interruptor:

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

En función de los valores de clase de la enumeración se pueden asignar:

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

    }

Espero eso ayude :)

Recomiendo usar la siguiente manera:

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

Te recomiendo que uses enumeraciones :)

Mira esto:

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

Entonces puedes usarlo así:

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