Operador OR en caja de interruptores?

Tomemos un caso de interruptor simple que se parece a:

@Override
public void onClick(View v) {
    switch (v.getId()) {
        case R.id.someValue :
        case R.id.someOtherValue:
            // do stuff
            break;
    }
}

Me pregunto por qué no está permitido usar el || ¿operador? Me gusta

switch (v.getId()) {
    case R.id.someValue || R.id.someOtherValue:
        // do stuff
        break;
}

los switch-case construcción es bastante similar a un if-else instrucción, puede utilizar el operador OR en una if sin embargo. ¿Cuáles son los antecedentes para un switch-case para no aceptar este operador?

amigo haz esto

    case R.id.someValue :
    case R.id.someOtherValue :
       //do stuff

Esto es lo mismo que usar el operador OR entre dos valores. Debido a este caso, el operador no está allí en el cambio de caso.

¿Cuáles son los antecedentes para que un switch-case no acepte este operador?

Porque case requiere expresión constante como su valor. Y desde un || expresión no es una constante de tiempo de compilación, no está permitida.

De JLS Sección 14.11:

La etiqueta del interruptor debe tener la siguiente sintaxis:

Cambiar etiqueta:
caso ExpresiónConstante:
caso EnumConstantName:
defecto :

Bajo el capó:

La razón detrás de permitir sólo la expresión constante con los casos se puede entender a partir de la JVM Spec Sección 3.10 – Compilación de conmutadores:

La compilación de sentencias switch utiliza el interruptor de mesa y cambio de búsqueda instrucciones. La instrucción tableswitch se usa cuando los casos del cambio pueden representarse eficientemente como índices en una tabla de compensaciones objetivo. El objetivo predeterminado del cambio se usa si el valor de la expresión del cambio cae fuera del rango de índices válidos.

Entonces, para que la etiqueta de casos sea utilizada por tableswitch como un índice en la tabla de compensaciones de destino, el valor del caso debe conocerse en el momento de la compilación. Eso solo es posible si el valor del caso es una expresión constante. Y || expresión se evaluará en tiempo de ejecución y el valor solo estará disponible en ese momento.

Desde la misma sección de JVM, lo siguiente switch-case:

switch (i) {
    case 0:  return  0;
    case 1:  return  1;
    case 2:  return  2;
    default: return -1;
}

se compila a:

0   iload_1             // Push local variable 1 (argument i)
1   tableswitch 0 to 2: // Valid indices are 0 through 2  (NOTICE This instruction?)
      0: 28             // If i is 0, continue at 28
      1: 30             // If i is 1, continue at 30
      2: 32             // If i is 2, continue at 32
      default:34        // Otherwise, continue at 34
28  iconst_0            // i was 0; push int constant 0...
29  ireturn             // ...and return it
30  iconst_1            // i was 1; push int constant 1...
31  ireturn             // ...and return it
32  iconst_2            // i was 2; push int constant 2...
33  ireturn             // ...and return it
34  iconst_m1           // otherwise push int constant -1...
35  ireturn             // ...and return it

Entonces, si el case el valor no es una expresión constante, el compilador no podrá indexarlo en la tabla de punteros de instrucción, usando tableswitch instrucción.

No puedes usar || operadores entre 2 casos. Pero puede usar múltiples valores de caso sin usar un descanso entre ellos. El programa luego saltará al caso respectivo y luego buscará código para ejecutar hasta que encuentre un “descanso”. Como resultado, estos casos compartirán el mismo código.

switch(value) 
{ 
    case 0: 
    case 1: 
        // do stuff for if case 0 || case 1 
        break; 
    // other cases 
    default: 
        break; 
}

No sé cuál es el mejor enfoque, pero lo hago como

case 'E':
case 'e':
   System.exit(0);
   break;

Switch no es lo mismo que if-else-if.

El cambio se usa cuando hay una expresión que se evalúa como un valor y ese valor puede ser uno de un conjunto de valores predefinido. Si necesita realizar múltiples operaciones booleanas/comparaciones en tiempo de ejecución, entonces debe usar if-else-if.

Todavía puedes hacerlo así.

switch (v.getId()) {
    case R.id.someValue: case R.id.someOtherValue:
        // do stuff
        break;
}

foreach (array('one', 'two', 'three') as $v) {
    switch ($v) {
        case (function ($v) {
            if ($v == 'two') return $v;
            return 'one';
        })($v):
            echo "$v min \n";
            break;


    }
}

esto funciona bien para idiomas que admiten gabinetes