logicos - sintaxis de los operadores relacionales en java

usar operadores relacionales en switch

Question

¿Hay alguna manera de usar operadores relacionales (<, <=,>,> =) en una instrucción switch?

int score = 95;
switch(score) {
case (score >= 90):
// do stuff
}

el ejemplo anterior (obviamente) no funciona

Answer 1

Los documentos para el estado de la declaración de mayúsculas y minúsculas :

una sentencia switch prueba expresiones basadas solo en un entero único, valor enumerado u objeto String.

Entonces no hay boolean Hacerlo no tendría sentido ya que solo tiene dos valores: true o falso.

Lo que podrías hacer es escribir un método que verifique el puntaje y luego devuelva uno de los tipos que el switch puede manejar

Por ejemplo:

enum CheckScore {
SCORE_HIGHER_EQUAL_90,
...
}
public CheckScore checkScore(int score) {
if(score >= 90) {
return SCORE_HIGHER_EQUAL_90;
} else if(...) {
return ...
}
}

y luego úsala en tu interruptor:

switch(checkScore(score)) {
case SCORE_HIGHER_EQUAL_90:
// do stuff
}

... O simplemente podría usar if, else-if, else directamente!

Answer 2

Nunca funcionará. Debes entender lo que hace el switch en primer lugar.

Ejecutará las instrucciones que caen debajo del caso que coincide con el argumento del interruptor.

En este caso, el score es un argumento que es 95 pero el score>=90 siempre evaluará a true o false y nunca coincide con un número entero.

Deberías usar if declaraciones en su lugar.

También Java no permite booleans en cajas de conmutadores así que sí.

Answer 3

Simplemente NO

int score = 95;
switch(score) {
case (score >= 90):
// do stuff
}

Estás pasando un valor int para switch . Entonces el caso debe estar en valores int , donde

(score >= 90)

Activa boolean

Su caso es un buen candidato para if else

Answer 4

Desafortunadamente , NO , aunque puede usar el case fallido (tipo de hacky) al agrupar varias declaraciones de caso sin break e implementar código cuando termina un rango:

int score = 95;
switch(score) {
..
case 79: System.out.println("value in 70-79 range"); break;
case 80:
..
case 85: System.out.println("value in 80-85 range"); break;
case 90:
case 91:
case 92:
case 93:
case 94:
case 95: System.out.println("value in 90-95 range"); break;
default: break;
}

En mi humilde opinión, usando if sería más apropiado en su caso particular.

Answer 5

No, no puedes.
Desde jls-14.11

The type of the Expression must be char, byte, short, int, Character, Byte, Short, Integer, String, or an enum type (§8.9), or a compile-time error occurs. 

Los operadores relacionales (<, <=,>,> =) dan como resultado boolean y no están permitidos.

Todo lo siguiente debe ser verdadero o se produce un error en tiempo de compilación:

• Cada expresión de constante de caso asociada con una instrucción de conmutación debe ser asignable (§5.2) al tipo de Expresión de conmutación.

• No hay dos expresiones de constante de caso asociadas a una instrucción de conmutación que puedan tener el mismo valor.

• Ninguna etiqueta de interruptor es nula.

• Como máximo, una etiqueta predeterminada puede estar asociada a la misma declaración de cambio.

Answer 6

Obviamente, esto no es posible como una construcción de lenguaje. Pero, solo por diversión, ¡podríamos implementarlo solos!

public class Switch<T, V> {
public static interface Action<V> {
V run();
}
private final T value;
private boolean runAction = false;
private boolean completed = false;
private Action<V> actionToRun;
public Switch(T value) {
this.value = value;
}
static public <T, V> Switch<T, V> on(T value) {
return new Switch<T, V>(value);
}
public Switch<T, V> ifTrue(boolean condition) {
runAction |= condition;
return this;
}
public Switch<T, V> ifEquals(T other) {
return ifTrue(value.equals(other));
}
public Switch<T, V> byDefault(Action<V> action) {
this.actionToRun = action;
return this;
}
public Switch<T, V> then(Action<V> action) {
if (runAction && !completed) {
actionToRun = action;
completed = true;
}
return this;
}
public V getResult() {
if (actionToRun == null) {
throw new IllegalStateException("none of conditions matched and no default action was provided");
}
return actionToRun.run();
}
}

Switch acepta cualquier valor para encender y luego proporciona funcionalidad para coincidir con condiciones booleanas (método ifTrue ) o por coincidencias exactas (método ifEquals ). Proporcionar un valor para encender es necesario solo para la última característica.

Después de getResult las condiciones, el usuario invoca getResult para obtener el resultado.

Por ejemplo, podríamos crear un método que nos diga qué piensa sobre nuestro puntaje:

String tellMeMyScore(int score) {
return Switch.<Integer, String> on(score).byDefault(new Action<String>() {
public String run() {
return "really poor score";
}
}).ifTrue(score > 95).then(new Action<String>() {
public String run() {
return "you rock!";
}
}).ifTrue(score > 65).then(new Action<String>() {
public String run() {
return "not bad, not bad";
}
}).ifEquals(42).then(new Action<String>() {
public String run() {
return "that''s the answer!";
}
}).getResult();
}

Esta simple prueba:

for (int score : new int[] { 97, 85, 66, 55, 42, 32, 4 }) {
System.out.println(score + ": " + tellMeMyScore(score));
}

Imprime:

97: you rock!
85: not bad, not bad
66: not bad, not bad
55: really poor score
42: that''s the answer!
32: really poor score
4: really poor score

Answer 7

Esto podría ayudarlo si necesita hacerlo con el interruptor mismo,

char g =''X'';
int marks = 65;
switch(marks/10)
{
case 1:
case 2:
case 3:
case 4: g = ''F'';
break;
case 5: g = ''E'';
break;
case 6: g = ''D'';
break;
case 7: g = ''C'';
break;
case 8: g = ''B'';
break;
case 9:
case 10: g = ''A'';
break;
}
System.out.println(g);

Funciona de esta manera,

 if(marks<50)
g=''F'';
else if(marks<60)
g=''E'';
else if(marks<70)
g=''D'';
else if(marks<80)
g=''C'';
else if(marks<90)
g=''B'';
else if(marks<=100)
g=''A'';