¿Por qué una expresión booleana es válida en un bloque de casos cuando los booleanos no son tipos de datos compatibles para los switches?

Question

Después de leer parte de la certificación SCJP anoche, pensé en las declaraciones de cambio y cómo se evalúan las expresiones, y algo me deja perplejo.

Java no le permitirá cambiar en un valor lógico, por lo que el siguiente no se compilará:

public static void switchOnBoolean(boolean theBool) 
    { 
     System.out.println("\n\nAssessing boolean :" + theBool); 
     // line below won't compile, since booleans are not valid for the switch statement 
     switch(theBool) 
     { 
      case true: 
      { 
       System.out.println("The boolean was true"); 
       break; 
      } 
      case false: 
      { 
       System.out.println("The boolean was false"); 
      } 
     } 
    } 

Sin embargo, el compilador no se quejará si se intenta utilizar una expresión que se evalúa como un valor booleano en un bloque caso, como por ejemplo:

public static void switchOnChar(char theChar) 
    { 
     System.out.println("\n\nAssessing char : " + theChar); 
     switch(theChar) 
     { 
      case 'a': 
      { 
       System.out.println("The char was a"); 
       break; 
      } 
      case 'b': 
      { 
       System.out.println("The char was b"); 
       break; 
      } 
      case ('c' | 'd'): 
      { 
       System.out.println("The char was c or d"); 
       break; 
      } 
      default: 
      { 
       System.out.println("The char didn't match anything, must be something else"); 
      } 
     } 
    } 

en última instancia, no puede nunca entrar en el caso ('c' | 'd') ya que es de suponer que evaluar a un valor lógico ...

Así que mi pregunta es:

1. ¿Por qué es legal el uso de algo así como ('c' | 'd')?
2. ¿Cómo podría ser útil alguna vez, ya que sería inalcanzable
3. Si alguna vez quiso encajar en más de un valor, pero sin utilizar un valor predeterminado, es su única opción volver a implementar como una instrucción if-else ?

Answer 1

'c' | 'd' wont return boolean. En este caso, | es en modo bit O no booleano O.

Se puede ver en este ejemplo cómo se calcula

System.out.println(Integer.toBinaryString('c')); 
System.out.println(Integer.toBinaryString('d')); 
System.out.println("======="); 
System.out.println(Integer.toBinaryString('c' | 'd')); 

salida

1100011 
1100100 
======= 
1100111 

y binario 1100111 es igual a 103 entero decimal por lo que es válido el argumento caso.

Answer 2

('c' | 'd') 

es bit a bit o por lo que no devolverá un valor booleano , es totalmente válida.

Si intenta que fuera así:

System.out.println('c' | 'd'); 

se imprimirá 103, que es el código ASCII para g.

Answer 3

Si realiza 'c' || 'd', obtendrá el error booleano esperado y no compilará.

'c' | 'd' es bitwise OR

Answer 4

'c' | 'd' es un bit a bit o que resulta en 'g', de manera válida en el interruptor.

Se puede sincronizar más de un caso sin ir a la sentencia if como

switch(theChar) { 
    case 'a': 
     break; 
    case 'b': 
     break; 
    case 'c': 
    case 'd': 
     System.out.println("c or d"); 
     break; 
    default: 
     throw new IllegalStateException(); 
}