En esta sección, aprenderá acerca de las diversas sentencias y operadores que usará para comunicarle a sus programas Java cómo quiere que actúen en base a una entrada diferente.
Operadores relacionales y condicionales
El lenguaje Java le da operadores y sentencias de control que le permiten tomar decisiones en su código. Muy a menudo, una decisión en el código comienza con una expresión booleana (es decir, una que evalúa ya sea verdadera o falsa). Tales expresiones usan operadores relacionales, que comparan un operando o una expresión con otra, y operadores condicionales.
La Tabla 3 enumera los operadores relacionales y condicionales del lenguaje Java:
Tabla 3. Operadores relacionales y condicionales
La sentencia if
Ahora que tiene un grupo de operadores, es momento de usarlos. Este código muestra lo que sucede cuando agrega algo de lógica al accessor getHeight() del objeto Person:
1
2
3
4
5
6
7
public int getHeight() {
int ret = height;
// If locale of the machine this code is running on is U.S.,
if (Locale.getDefault().equals(Locale.US))
ret /= 2.54;// convert from cm to inches
return ret;
}
Si el entorno local actual está en los Estados Unidos (donde no se usa el sistema métrico), entonces tal vez tenga sentido convertir el valor interno de altura (en centímetros) a pulgadas. Este ejemplo ilustra el uso de la sentencia if, que evalúa una expresión booleana en paréntesis. Si esa expresión evalúa como verdadera, ejecuta la siguiente sentencia.
En este caso, solo necesita ejecutar una sentencia si el Locale de la máquina en la que se ejecuta el código es Locale.US. Si necesita ejecutar más de una sentencia, puede usar llaves para formar una sentencia compuesta. Una sentencia compuesta agrupa muchas sentencias en una, — y las sentencias compuestas también pueden contener otras sentencias compuestas.
getHeight() del objeto Person:
1
2
3
4
5
6
7
| public int getHeight() { int ret = height; // If locale of the machine this code is running on is U.S., if (Locale.getDefault().equals(Locale.US)) ret /= 2.54;// convert from cm to inches return ret;} |
if, que evalúa una expresión booleana en paréntesis. Si esa expresión evalúa como verdadera, ejecuta la siguiente sentencia.Locale de la máquina en la que se ejecuta el código es Locale.US. Si necesita ejecutar más de una sentencia, puede usar llaves para formar una sentencia compuesta. Una sentencia compuesta agrupa muchas sentencias en una, — y las sentencias compuestas también pueden contener otras sentencias compuestas.Ámbito variable
Cada variable en una aplicación Java tiene un ámbito, o espacio de nombres localizado, al cual usted puede acceder por nombre dentro del código. Fuera de ese espacio, la variable está fuera de ámbito y usted obtendrá un error de compilación si intenta acceder a ella. Los niveles de ámbitos en el lenguaje Java se definen de acuerdo a dónde se declare una variable, como se muestra en el Listado 8:
Listado 8. Ámbito variable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SomeClass {
private String someClassVariable;
public void someMethod(String someParameter) {
String someLocalVariable = "Hello";
if (true) {
String someOtherLocalVariable = "Howdy";
}
someClassVariable = someParameter; // legal
someLocalVariable = someClassVariable; // also legal
someOtherLocalVariable = someLocalVariable;// Variable out of scope!
}
public void someOtherMethod() {
someLocalVariable = "Hello there";// That variable is out of scope!
}
}
Dentro de SomeClass, someClassVariable es accesible por medio de todos los métodos de instancia (es decir, no estáticos). Dentro de someMethod, someParameter es visible pero, fuera de ese método, no lo es y lo mismo sucede para someLocalVariable. Dentro del bloque if, someOtherLocalVariable se declara y, fuera de ese bloque if, está fuera de ámbito.
El ámbito tiene muchas reglas pero el Listado 8 muestra las más comunes. Tómese algunos minutos para familiarizarse con ellas.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class SomeClass { private String someClassVariable; public void someMethod(String someParameter) { String someLocalVariable = "Hello"; if (true) { String someOtherLocalVariable = "Howdy"; } someClassVariable = someParameter; // legal someLocalVariable = someClassVariable; // also legal someOtherLocalVariable = someLocalVariable;// Variable out of scope! } public void someOtherMethod() { someLocalVariable = "Hello there";// That variable is out of scope! }} |
SomeClass, someClassVariable es accesible por medio de todos los métodos de instancia (es decir, no estáticos). Dentro de someMethod, someParameter es visible pero, fuera de ese método, no lo es y lo mismo sucede para someLocalVariable. Dentro del bloque if, someOtherLocalVariable se declara y, fuera de ese bloque if, está fuera de ámbito.
La sentencia else
Hay momentos en el flujo de control de un programa en los que usted quiere participar solo si una expresión particular falla al evaluar como verdadero. En ese momento es cuando else resulta de ayuda:
1
2
3
4
5
6
7
8
9
10
public int getHeight() {
int ret;
if (gender.equals("MALE"))
ret = height + 2;
else {
ret = height;
Logger.getLogger("Person").info("Being honest about height...");
}
return ret;
}
La sentencia else funciona del mismo modo que if en el sentido que ejecuta solo la siguiente sentencia que encuentra. En este caso, dos sentencias se agrupan en una sentencia compuesta (observe las llaves), que luego el programa ejecuta.
También puede usar else para realizar una verificación if adicional, del siguiente modo:
1
2
3
4
5
6
7
8
9
10
if (conditional) {
// Block 1
} else if (conditional2) {
// Block 2
} else if (conditional3) {
// Block 3
} else {
// Block 4
} // End
Si conditional evalúa como verdadero, entonces el Block 1 se ejecuta y el programa salta a la siguiente sentencia luego de la llave final (lo que se indica con // End). Si conditionalno evalúa como verdadero, entonces se evalúa conditional2. Si es verdadero, entonces el Block 2 se ejecuta y el programa salta a la siguiente sentencia luego de la llave final. Si conditional2 no es verdadero, entonces el programa sigue con conditional3 y así sucesivamente. Solo si las tres condicionales fallan, se ejecutaría el Block 4.
else resulta de ayuda:
1
2
3
4
5
6
7
8
9
10
| public int getHeight() { int ret; if (gender.equals("MALE")) ret = height + 2; else { ret = height; Logger.getLogger("Person").info("Being honest about height..."); } return ret;} |
else funciona del mismo modo que if en el sentido que ejecuta solo la siguiente sentencia que encuentra. En este caso, dos sentencias se agrupan en una sentencia compuesta (observe las llaves), que luego el programa ejecuta.else para realizar una verificación if adicional, del siguiente modo:
1
2
3
4
5
6
7
8
9
10
| if (conditional) { // Block 1} else if (conditional2) { // Block 2} else if (conditional3) { // Block 3} else { // Block 4} // End |
conditional evalúa como verdadero, entonces el Block 1 se ejecuta y el programa salta a la siguiente sentencia luego de la llave final (lo que se indica con // End). Si conditionalno evalúa como verdadero, entonces se evalúa conditional2. Si es verdadero, entonces el Block 2 se ejecuta y el programa salta a la siguiente sentencia luego de la llave final. Si conditional2 no es verdadero, entonces el programa sigue con conditional3 y así sucesivamente. Solo si las tres condicionales fallan, se ejecutaría el Block 4.El operador ternario
El lenguaje Java proporciona un operador práctico para hacer simples verificaciones de sentencias if/else. Su sintaxis es:
1
(conditional) ? statementIfTrue : statementIfFalse;
Si conditional evalúa como verdadero, entonces se ejecuta statementIfTrue; caso contrario, se ejecuta statementIfFalse. Las sentencias compuestas no se permiten para ninguna de las sentencias.
El operador ternario es de ayuda cuando usted sabe que necesitará ejecutar una sentencia como el resultado de la condicional que evalúa como verdadero, y otra si no lo hace. Los operadores ternarios a menudo se usan para inicializar una variable (como un valor de retorno), como de la siguiente manera:
1
2
3
public int getHeight() {
return (gender.equals("MALE")) ? (height + 2) : height;
}
Los paréntesis que siguen luego del signo de interrogación anterior no se requieren estrictamente pero sí hacen que el código sea más legible.
if/else. Su sintaxis es:
1
| (conditional) ? statementIfTrue : statementIfFalse; |
conditional evalúa como verdadero, entonces se ejecuta statementIfTrue; caso contrario, se ejecuta statementIfFalse. Las sentencias compuestas no se permiten para ninguna de las sentencias.
1
2
3
| public int getHeight() { return (gender.equals("MALE")) ? (height + 2) : height;} |
No hay comentarios:
Publicar un comentario