sentencia - ¿Hay alguna diferencia en la eliminación de las llaves de If en Java?
switch en java netbeans ejemplos (16)
Mientras observa el tutorial de newbostons sobre java básico, nos enseña a hacer declaraciones como esta. (Observe las llaves)
if("pie"== "pie"){
System.out.println("Hurrah!");
}
Así que traté de quitar las llaves
if("pie"== "pie")
System.out.println("Hurrah!");
¡Y todavía funciona! Como soy nuevo en Java, no sé por qué funciona. Y quiero saber si eliminar (o agregar) las llaves produce ventajas / desventajas.
Y quiero saber si eliminar (o agregar) las llaves da algún beneficio / desventaja?
La ventaja de agregarlos siempre es que simplemente puede extender el bloque de código más tarde, sin necesidad de agregarlos. Supongamos que tiene:
if("pie".equals("pie"))
System.out.println("Hurrah!");
luego, si desea agregar una línea adicional de código, debe asegurarse de agregar los paréntesis:
if("pie".equals("pie")) {
log.debug("I am here!");
System.out.println("Hurrah!");
}
Si ya están allí, simplemente coloque el cursor al final de la línea, presione regresar y comience a agregar un nuevo código.
Para una sola línea, no hay diferencia técnica, pero muchas convenciones de código proponen o incluso obligan a tenerlas siempre allí. Incluso hay una regla CheckStyle para ello.
Como dice @rajesh, las llaves son opcionales cuando el cuerpo es una sola declaración.
Una vez dicho esto, algunos estilos de codificación recomiendan dejar los refuerzos incluso para casos de sentencias individuales porque es menos probable que usted (o el programador que lo sigue) cometan errores cuando cambia el código más tarde.
if("pie"== "pie")
System.out.println("Hurrah!");
System.out.println("Tricked you");
La segunda impresión, Tricked you , no está realmente en el if , simplemente se ve como debido a la sangría.
Sin embargo, ese es solo un punto de estilo, no universalmente aceptado, y ciertamente un programador competente necesita poder leer ambas formas.
Es lo mismo, si el número de oraciones es igual a uno. Si hay más de uno, necesita la sintaxis {}
Esta es una cuestión de estilo que se aplica a varios idiomas, incluidos Java, C ++, C y C #.
Cuando un bloque de código contiene solo una línea, las llaves se pueden omitir. Esto se aplica a cualquier estructura de control: if, while, for, do-while.
Por ejemplo, los dos bucles a continuación son equivalentes.
for(int i=0; i<100; i++)
doSomething(i);
for(int i=0; i<100; i++) {
doSomething(i);
}
Ventaja de omitir {}: su código puede ser más breve, lo que significa menos línea. Algunos pueden sentir que es más legible.
Desventaja de omitir {}: si luego modificas tu código y necesitas agregar otra línea al bloque de código, es mejor que recuerdes agregar esos {}. Si no, y escribe el código a continuación:
for(int i=0; i<100; i++)
doSomething(i);
doSomethingElse(i);
Esto es realmente equivalente a:
for(int i=0; i<100; i++) {
doSomething(i);
}
doSomethingElse(i);
Funcionará bien si solo hay una declaración después de la condición if.
if("pie"== "pie")
System.out.println("Hurrah!");
System.out.println("second statement");// this will not print
pero aquí ambas afirmaciones se imprimirán
if("pie"== "pie")
{
System.out.println("Hurrah!");
System.out.println("second statement");
}
Le sugiero que lo utilice a continuación, incluso si desea imprimir una sola declaración.
if("pie".equals("pie"))
{
System.out.println("Hurrah!");
System.out.println("second statement");
}
Las llaves se usan solo si quieres ejecutar un montón de código en condiciones. Si no usa las llaves, solo ejecutará la primera declaración después de la condición if. Las líneas restantes (debajo de la primera declaración) no se considerarán como una parte if.
Las llaves son generalmente para tener un bloque de declaraciones. Sin llaves, solo la primera línea se ejecutará en la declaración if() . No todo el bloque que comienza con { y termina con }
if("pie" == "pie") {
System.out.println("Executes if pie==pie");
System.out.println("So does this");
}
y
if("pie" == "pie")
System.out.println("Executes if pie==pie");
System.out.println("Executes, regardless of if pie is equal to pie");
Sin embargo, tenga en cuenta que si desea comparar dos objetos String , use el método .equals() en String . Este ejemplo todavía funciona porque está comparando una cadena constante consigo misma, lo que siempre es cierto.
Mis dos centavos. Escribir dos líneas después de una instrucción if sin llaves es un error que nunca he visto. Dicho esto, las personas con las que trabajas son cabezas de huesos que no comprenderán el truco de magia que estás haciendo aquí. Guarde cosas divertidas como esta para su código privado, pero haga lo que le dicen en la configuración profesional y del aula.
Hay un argumento real sobre esto que ilustra un problema razonable que podría surgir. Como sabrá, todas las sangrías y los espacios en blanco adicionales se eliminan de su código cuando se analiza. Pueden surgir problemas cuando intente utilizar sentencias else una línea después de múltiples sentencias if una línea. Por ejemplo:
if("cherry".equals("cherry"))
if("pie".equals("pie"))
System.out.println("Hurrah!");
else
System.out.println("Rats!");
se vuelve indistinguible de
if("cherry".equals("cherry"))
if("pie".equals("pie"))
System.out.println("Hurrah!");
else
System.out.println("Rats!");
Incluso en esa circunstancia, una configuración de tabulación automática debe indicar a qué declaración apunta el else , pero es algo de lo que ciertamente debe desconfiar si elige eludir las reglas como suelo hacer.
No, PERO el peligro real ocurre cuando el código se edita más adelante. Es relativamente fácil editar algo como:
if (someCondition)
// do something
a
if (someCondition)
// do something
// do something else important
y piense que ''hacer algo más importante'' solo se ejecutará cuando alguna condición sea verdadera. La sangría extravía :-)
Con corchetes, este peligro no está presente.
No, no hay absolutamente ninguna diferencia: un par de llaves hace varias declaraciones en una sola; if , while , for , etc., esperan una sola declaración; si necesita proteger solo una declaración, no necesita llaves.
Sin embargo, muchas tiendas de software insisten en tener llaves incluso para una sola declaración. La razón es errores como este:
if (x > 20)
x -= 7;
y -= 8;
Las afirmaciones anteriores son engañosas: la sangría te lleva a creer que ambas asignaciones están protegidas, mientras que en realidad solo la primera es. La razón de esto es que el espacio en blanco en Java es insignificante: la sangría de una declaración no cambia su ubicación en el flujo general del programa. Los errores como los anteriores son muy difíciles de encontrar, por lo que es una buena idea adoptar una regla para evitarlos en primer lugar.
No, no hay diferencia entre ellos con una afirmación en respuesta al if . Si desea agregar una segunda instrucción en respuesta a if , entonces se requieren llaves.
Para un solo enunciado , seguirá siendo el mismo, pero si quiere agrupar más de un enunciado en el bloque if, entonces debe usar llaves.
if("pie"== "pie"){
System.out.println("Hurrah!");
System.out.println("Hurrah!2");
}
if("pie"== "pie")
System.out.println("Hurrah!"); //without braces only this statement will fall under if
System.out.println("Hurrah!2"); //not this one
Deberías ver: Bloques en Java
Un bloque es un grupo de cero o más declaraciones entre llaves equilibradas y se puede usar en cualquier lugar donde se permita una sola declaración. El siguiente ejemplo, BlockDemo, ilustra el uso de bloques:
class BlockDemo {
public static void main(String[] args) {
boolean condition = true;
if (condition) { // begin block 1
System.out.println("Condition is true.");
} // end block one
else { // begin block 2
System.out.println("Condition is false.");
} // end block 2
}
}
(ejemplo del enlace de arriba)
Para una sola declaración, no es un problema
if("pie"== "pie")
System.out.println("Hurrah!");
Para dos o más declaraciones después si necesita los apoyos
if("pie"== "pie"){
System.out.println("Hurrah!");
System.out.println("Hi!");
}
También use .equals () para comparar en lugar de ==.
Si agrega llaves a esta declaración if:
if(++colorIndex == someColors.length)
colorIndex = 0;
setForeground(currentColor());
repaint();
Entonces ya no funcionará.
Entonces creo que en algunos casos sí importa.
Si solo hay una declaración después de if llaves no son obligatorias.
Ahora, si tiene un bloque de código que debe caer bajo la condición if , entonces necesita usar llaves.
Esto también es válido para loops
Tiene una desventaja . Las respuestas mencionadas hasta ahora son correctas. Pero hay algunas desventajas desde la perspectiva de seguridad de las cosas. Habiendo trabajado en un equipo de pagos, la seguridad es un factor mucho más fuerte que motiva tales decisiones. Digamos que tienes el siguiente código:
if( "Prod".equals(stage) )
callBankFunction ( creditCardInput )
else
callMockBankFunction ( creditCardInput )
Ahora digamos que tiene este código no funciona debido a algún problema interno. Desea verificar la entrada. Entonces haces el siguiente cambio:
if( "Prod".equals(stage) )
callBankFunction ( creditCardInput )
else
callMockBankFunction ( creditCardInput )
Logger.log( creditCardInput )
Digamos que arregla el problema y despliega este código (y tal vez el revisor y cree que esto no causará ningún problema ya que no está dentro de la condición ''Prod''). Mágicamente, sus registros de producción ahora imprimen información de la tarjeta de crédito del cliente que es visible para todo el personal que puede ver los registros. Dios no lo permita si alguno de ellos (con intenciones maliciosas) se apodera de esta información.
Por lo tanto, no dar una llave y una codificación un poco descuidada a menudo puede conducir a la violación de la información segura. También está clasificado como una vulnerabilidad en JAVA por CERT - Software Engineering Institure, CMU .