Instrução switch Java: Expressão constante necessária, mas É constante

Então, eu estou trabalhando nessa classe que tem algumas constantes estáticas:

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

Então, eu gostaria de uma maneira de obter uma string relevante com base na 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";
    }
}

No entanto, ao compilar, recebo um constant expression requirederro em cada um dos três rótulos de casos.

Entendo que o compilador precisa que a expressão seja conhecida no momento da compilação para compilar um comutador, mas por que não é Foo.BA_constante?

Entendo que o compilador precisa que a expressão seja conhecida no momento da compilação para compilar um switch, mas por que o Foo.BA_ não é constante?

Embora sejam constantes da perspectiva de qualquer código que seja executado após a inicialização dos campos, eles não são uma constante de tempo de compilação no sentido exigido pelo JLS; consulte §15.28 Expressões constantes para a especificação de uma expressão constante ¹ . Isso se refere a §4.12.4 Variáveis ​​finais, que define uma "variável constante" da seguinte maneira:

Chamamos uma variável, do tipo primitivo ou do tipo String, que é final e inicializada com uma expressão constante em tempo de compilação (§15.28) como variável constante. Se uma variável é uma variável constante ou não, pode ter implicações em relação à inicialização de classe (§12.4.1), compatibilidade binária (§13.1, §13.4.9) e atribuição definida (§16).

No seu exemplo, as variáveis ​​Foo.BA * não possuem inicializadores e, portanto, não se qualificam como "variáveis ​​constantes". A correção é simples; altere as declarações da variável Foo.BA * para ter inicializadores que são expressões constantes em tempo de compilação.

Em outros exemplos (onde os inicializadores já são expressões constantes em tempo de compilação), declarar a variável como finalpode ser o necessário.

Você pode alterar seu código para usar um enumint constantes em vez de constantes, mas isso traz outras restrições diferentes:

• Você deve incluir um defaultcaso, mesmo se tiver casepara cada valor conhecido do enum; Vejo Por que o padrão é necessário para uma troca em uma enumeração?
• Os caserótulos devem ser todos enumvalores explícitos , não expressões que são avaliadas como enumvalores.

^{1 - As restrições de expressão constante podem ser resumidas da seguinte forma. Expressões constantes a) pode utilizar os tipos de primitivas e Stringúnica, b) permitir que primárias que são literais (aparte null) e variáveis constantes única, c) permitir que expressões constantes possivelmente parenthesised como subexpress~oes, d) permitir que os operadores excepto para operadores de atribuição, ++, --ou instanceof, e e) permitir a conversão de tipos para tipos primitivos ouString apenas.}

^{Note que isto não inclui qualquer forma de método ou lambda chamadas, new, .class. .lengthou assinatura de matriz. Além disso, qualquer uso de valores de matriz, enumvalores, valores de tipos de invólucros primitivos, boxe e unboxing são todos excluídos por causa de a).}

Você obtém a expressão Constant necessária porque deixou os valores fora de suas constantes. Experimentar:

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

Eu recebi esse erro no Android e minha solução foi apenas usar:

public static final int TAKE_PICTURE = 1;

ao invés de

public static int TAKE_PICTURE = 1;

Porque essas não são constantes de tempo de compilação. Considere o seguinte código válido:

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

Você só pode saber o valor de BARem tempo de execução.

Você pode usar uma enumeração como neste exemplo:

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: instrução Switch com enum

Isso foi respondido há séculos e provavelmente não é relevante, mas apenas por precaução. Quando fui confrontado com esse problema, simplesmente usei uma ifdeclaração em vez de switchresolver o erro. É claro que é uma solução alternativa e provavelmente não é a solução "certa", mas, no meu caso, foi apenas o suficiente.

Às vezes, a variável switch também pode cometer esse erro, por exemplo:

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

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

   //...
}

Para resolver, você deve converter a variável em int (neste caso). Assim:

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

   case 0: //No Error

   //...
}

Este erro ocorreu no Android ao fazer algo assim:

 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

            }

apesar de declarar uma constante:

public static final String ADMIN_CONSTANT= "Admin";

Resolvi o problema alterando meu código para este:

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:

            }

No meu caso, eu estava recebendo essa exceção porque

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

no segundo caso, eu estava chamando a constante da instância, var.MODIFICAR_KM:mas deveria usar VariablesKmDialog.OBTENER_KMdiretamente da classe.

Se você o estiver usando em um caso de comutador, precisará obter o tipo de enum antes mesmo de conectar esse valor ao comutador. Por exemplo :

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

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

E o enum é 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;
    }
}

O código abaixo é auto-explicativo. Podemos usar uma enumeração com uma caixa de opção:

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

Com base nos valores de classe da enumeração, podem ser mapeados:

 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 que ajude :)

Eu recomendo usar da seguinte maneira:

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

Eu recomendo que você use enums :)

Veja isso:

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

Então você pode usá-lo assim:

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