24 de septiembre de 2018

Condiciones (if-then-else)

Todo el código que hemos visto va siguiendo unos pasos fijos cada vez que lo ejecutamos. Las condiciones nos van a permitir decidir qué código se ejecutará en función de los valores que tengamos durante la ejecución.

Os recuerdo que tomar una decisión es una de las partes más generales que vimos cuando aprendimos qué es programar.

De manera general una cláusula condicional se expresa de la siguiente forma:
  if (condicion) {
    // rama se cumple
  }
  else {
    // rama NO se cumple
  }
  • Ejecuta la "rama se cumple" si se cumple la condición o la rama "NO se cumple" si no se cumple la misma condición.
  • El fragmento else no es obligatorio si no se necesita su rama.
La clásula if-then-else nos permite decidir el código a ejecutar en función de una condición


Este es un ejemplo básico:
  public static void main(String[] args) {
      int saldo = 100;
      String resultado;
    
      if (esRico(saldo)) {
          resultado = "Soy rico";
      }
      else {
          resultado = "NO soy rico";
      }
    
      System.out.println("¡" + resultado + "! Mi saldo es: " + saldo);
  }

  public static boolean esRico(int saldo) {
      return saldo >= 1000;
  }
Los bloques que marcan las ramas están encerrados entre llaves como de costumbre, pero si la rama sólo consta de una única sentencia se puede optar por omitir las llaves. Sin embargo hay que prestar especial atención a la indentación (las distintas sangrías que tienen las sentencias en función de la profundidad de su bloque) para no confundir líneas sucesivas como formando parte del bloque. En ese caso nos quedaría así:
  if (esRico(saldo))
      resultado = "Soy rico";
  else
      resultado = "NO soy rico";
O incluso podéis verlo así:
  if (esRico(saldo)) resultado = "Soy rico";
  else resultado = "NO soy rico";
No obstante, si repasáis la guía de estilo que marcamos para el curso, recomienda siempre poner las llaves.

Encadenar y Anidar condiciones

Si queremos tener condiciones más complejas se pueden encadenar. En este caso se puede continuar el comienzo de la rama else con otro if. Vamos a ver más claro este punto con un ejemplo:
  public static void main(String[] args) {
      int saldo = 100;
      String resultado;
    
      if (esRico(saldo)) {
          resultado = "Soy rico";
      }
      else if (esPobre(saldo)){
          resultado = "Soy pobre";
      }
      else {
          resultado = "Voy tirando";
      }
    
      System.out.println("¡" + resultado + "! Mi saldo es: " + saldo);
  }

  public static boolean esRico(int saldo) {
      return saldo >= 1000;
  }

  public static boolean esPobre(int saldo) {
      return saldo <= 0;
  }
Si queremos ir afinando desde condiciones más generales a otras más precisas, se pueden anidar condiciones dentro de las ramas. Personalmente suelo usar el anidamiento y comentar las ramas si es necesario (ver en el código). La parte que cambia es la siguiente:
  if (esRico(saldo)) { // Soy rico
      resultado = "Soy rico";
  }
  else { // NO soy rico
      if (esPobre(saldo)){ // Soy pobre
          resultado = "Soy pobre";
      }
      else {
          resultado = "Voy tirando";
      }
  }
La composición de condiciones es algo habitual. Se puede ver como un modo de filtrar valores para no tener que evaluar una sentencia de nuevo como si formáramos una única condición concatenándolas usando los operadores lógicos (!esRico && !esPobre). Al final vemos una demostración.

El encadenamiento y anidamiento de condiciones nos sirven para filtrar y separar mejor el código


En el libro se puede ver otro uso de la palabra clave return. Como dijimos anteriormente se usa en los métodos con retorno para terminar la ejecución y devolver el valor. En este caso simplemente finaliza la ejecución. Personalmente creo que no es necesario y que hace más dificil seguir el código. Recomiendo tener un único punto de salida de los métodos.

Demostrando los operadores lógicos cortocircuitados

Como os adelanté, veríamos exactamente una demostración de ese cortocircuito. En este código podemos ver que se cortocircuita al no haber salidas de consola que se producirían si se evaluara !esPobre. En el vídeo se observa claramente:
  public static void main(String[] args) {
      int saldo = 1000;
      System.out.println("¿Voy Tirando? " + vaTirando(saldo));
  }

  public static boolean esRico(int saldo) {
      System.out.println("Comprobando RICO");
      return saldo >= 1000;
  }

  public static boolean esPobre(int saldo) {
      System.out.println("Comprobando POBRE");
      return saldo <= 0;
  }

  public static boolean vaTirando(int saldo) {
      return !esRico(saldo) && !esPobre(saldo);
  }

No hay comentarios:

Publicar un comentario

Compárteme

Entradas populares