Iniciación a la programación: Operadores y Condicionales (parte 4)

Estándar

Una vez hablado de los diferentes tipos de datos con los que podemos trabajar y como usarlos en variables en nuestro código Java nos toca hablar de como usamos estas variables para dar forma a un flujo algorítmico.

Para ello usaremos los bucles, que nos ayudan a iterar sobre una porción de código repetitivamente (que veremos en la siguiente entrada), y los condicionales, que nos ayudan a elegir el código que se ejecutará en función de una instrucción comparativa o booleana.Como ya vimos en el post anterior, el tipo booleano es aquel que tiene dos posibles valores (True y False). En sí mismos, los valores booleanos no son muy útiles, pero en conjunción con las condiciones son la herramienta más importante que tenemos cuando programamos.

Para poder inicializar una variable, para posteriormente usarla en una condición, podemos hacerlo como vimos en el post anterior (directamente con el operador de asignación) o usando los operadores de comparación.

Operadores

Pero los operadores no sólo sirven obtener valores booleanos con los que dar valor a una variable o usar en una comparación, sino también para, por ejemplo, asignar un valor a una variable, con el operador de igualdad como vimos en el post anterior. Todos los operadores devuelven algo al ser usados y deben guardarse en alguna variable si queremos mantener el valor que obtengamos al aplicar el operador. En Java nos podemos encontrar los siguientes operadores:

  • Asignación: Del que hablábamos anteriormente.
  • Aritméticos: Estos operadores se usan para operar valores numéricos. Se corresponden con los operadores matemáticos que usamos normalmente y son +, , *, / y % (operador de resto). Estos operadores requieren dos argumentos para poder usarse y se colocan en medio de los dos valores.
  • Operadores unarios: Estos son los operadores que necesitan únicamente de un operador para ser usados y son los que cambian el signo del valor ( y + delante del valor), los que incrementan el valor en 1 (++ y delante o detrás del valor) o la negación de un valor booleano (! delante del valor)
  • Relacionales: Estos son los operadores que relacionan dos valores para devolver un valor boleado en función de la comparación realizada. Estos operadores son: los operadores de igualdad (== para igualdad, != para desigualdad) y los operadores de mayor (> y >=) y menor que (< y <=)
  • Condicionales: Este tipo de operadores son los que usamos para comparar valores booleanos entre sí. Estos son el operador And (&&) y Or (||) que evaluarán los dos valores en función de la lógica booleana, como podemos ver en la siguiente tabla.
Lógica booleana

Lógica booleana

En el siguiente código os muestro algunos ejemplos sobre el uso de estos operadores:

//Declaramos unas variables para usarlas con los operadores
int x = 5;
int y = 2;
int z = 5;

//iguales será True ya que x y z tienen el mismo valor
boolean iguales = x == z;
//y si negamos su valor obtenemos el contrario de True, False
boolean distinto = !iguales;

//Un And entre dos valores contrarios siempre será False
boolean siempreFalso = iguales &amp;&amp; distinto;
//y un Or entre esos valores contrarios siempre True
boolean siempreTrue = iguales || distinto;

//También podemos combinar operadores
boolean esVerdadero = x == z &amp;&amp; y &amp;lt; x;
//Pero si no tenemos claro que se va a ejecutar antes debemos usar los paréntesis
boolean seguroVerdadero = (x == z) &amp;&amp; (y &amp;lt; x);

Como vemos en el ejemplo, existe un orden de precedencia entre los operadores para decidir cuales se evalúan antes que otros. Podemos romper esta precedencia usando los paréntesis alrededor de la operación que queramos que se ejecute primero. También suele ser una buena práctica usar estos paréntesis para facilitar la claridad de lectura de las operaciones.

//Porque no es lo mismo
int x = 5+5/4;
//que
int x2 = (5+5)/4;

Condicionales

Como ya hemos dicho los bloques condicionales nos ayudan a ejecutar un bloque de código en función de la evaluación de una condición. Los condicionales en Java, y en casi todos los lenguajes, se usan mediante la palabra reservada if seguida de la condición entre paréntesis y un conjunto de instrucciones dentro de un bloque de llaves, como podemos ver a continuación:

if (cond) {
    //instrucciones dependientes de la condición
}

El bloque de instrucciones que se encuentra dentro del condicional se evaluará si la condición que está dentro de los paréntesis se cumple, es decir si su valor se evalúa a True.

El comportamiento de los condicionales se extiende con la clausula else que siempre que se usa se sitúa a continuación del if. Su comportamiento es similar al del if, sólo que las instrucciones que se encuentran entre sus llaves se evalúan si la (o las) condiciones anteriores no se ha evaluado a True. En el siguiente ejemplo vemos su comportamiento:

int x;
boolean b = True;

if (b == True) {
   x = 1;  
} else {
   x = 2;
}

//Esta sentencia nos permite imprimir por pantalla una instrucción
//en este caso, el valor de x.
System.out.println(x)

//En la pantalla aparecerá 1

Como vemos el else no lleva condición por lo que hemos dicho anteriormente, sólo se ejecuta si en su if anterior no se ha cumplido la condición.

Por último, una variante habitual cuando queremos hacer muchas comprobaciones seguidas relacionadas entre ellas usamos la sentencia else if, que sí que tiene condición y que será evaluada siempre que las anteriores condiciones se hayan evaluado a False. Un ejemplo vale más que mil palabras:

int x = 1;
boolean b = True;

if (b == True) {
    System.out.println("Se cumple la primera condición");
} else if (b == True && x == 1) {
    System.out.println("Se cumple la segunda condición");
} else {
    System.out.println("No se cumple ninguna condición");
}

//En este caso se imprimirá -> Se cumple la primera condición

En este ejemplo, aunque muy sencillo, vemos como el orden de las condiciones en los bloques if-else if-else es importante, llegandose a tapar condiciones que nunca se van a evaluar estando otra previamente. La regla a seguir en estos casos es poner las condiciones más restrictivas primero para que puedan ser evaluadas antes y puedan dar paso a las menos restrictivas.

Cuando el conjunto de condiciones a comprobar aumenta la sintaxis del if-else if-else es muy engorrosa y ocupa mucho espacio. En este caso es cuando entra en juego el switch. Switch es una palabra reservada que se usa para designar un tipo especial de condicional que nos ayuda a agrupar todas las condiciones que tienen que ver con una variable o valor único que tiene que compararse con muchos valores. Vemos la sintaxis con un ejemplo:

//Lo que en un if se escribiría de esta manera:
int x = 3;

if (x == 1) {
    //si x es 1
} else if (x == 2) {
    //si x es 2
} else if (x == 3) {
    //si x es 3
} else {
    //si x no es ninguna de las anteriores
}

//Con un switch lo escribiríamos así:
switch (x) {
case 1: //si x es 1
        break;
case 2: //si x es 2
        break;
case 3: //si x es 3
        break;
default: //si no es ninguna
}

Este tipo de condiciones se puede usar sobre los tipos de datos primitivos int, short, byte y char (además de sus wrappers). También se pueden usar en tipos enumerados (que son tipos en los que se asigna a cada literal que pertenece al enumerado un número) y, desde Java SE7 salido del horno recientemente, Strings (cadenas de caracteres).

Nos debemos fijar sobre todo en dos características de este tipo de condicionales:

  • break: esta sentencia nos sirve que una vez ejecutado el caso en el que nos encontremos salgamos de la instrucción switch. Si no se coloca el flujo sigue su ejecución por el bloque de sentencias del siguiente caso (sin comprobar su condición). Esta característica es muy útil cuando queremos implementar una condición en cascada.
  • default: esta sentencia es la equivalente al else de los if corrientes, agrupa los casos en los que no se cumple ninguna de las condiciones anteriores (esta no lleva break porque automáticamente se procede a la salida después de su ejecución).

Y esto es todo por hoy, espero que no se haya hecho demasiado largo y en la siguiente entrada veremos los bucles y quizás comencemos a hablar de las clases, el tema importante de la programación orientada a objetos.

Anuncios

Un comentario en “Iniciación a la programación: Operadores y Condicionales (parte 4)

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s