En esta entrada vamos a ver los puntos clave sobre: Sentencias if y switch, Uso de bucles, Usando break y continue, Manejo de Excepciones, Mecanismo de Aserción.

• Sentencias if y switch

  • La única expresión legal en una sentencia if es una expresión boolean, en otras palabras, una expresión que resulta en un boolean o en una variable Boolean.
  • Hay que estar atentos a asignaciones boolean (=) que pueden ser confundidas por test de igualdad boolean (==):

    				boolean x = false;
    				if (x = true) { } // Una asignacion, x siempre será true
    				

  • Las llaves en un if son opcionales para bloques que solo tienen una sentencia, pero puede llevar a engaños.
  • Las sentencias switch pueden evaluar solo una enum, o un byte, short, int y tipo de dato char. No podemos hacer:

    				long s = 30;
    				switch(s){ }
    				

  • La constante case debe ser un literal o una variable final, o una expresión constante, incluyendo una enum. No podemos tener un caso que incluya una variable no final, o un rango de valores.
  • Si la condición en una sentencia switch coincide con una constante case, la ejecución se ejecutará a través de todo el código en el switch seguido de la sentencia case hasta que una sentencia break o el final de la sentencia switch sea encontrada. En otras palabras, el case que coincida es el punto de entrada al bloque case, pero a no ser que no exista una sentencia break, no será el único case que se ejecute.
  • La palabra clave default debería ser usada en una sentencia switch si queremos ejecutar algún código cuando ninguno de los valores case coinciden con el valor condicional.
  • El bloque default puede ser localizado en cualquier lugar del bloque switch, por lo que si no hay ningún case que coincida, el bloque default será ejecutado, y si el default no contiene un break, entonces el código seguirá ejecutandose hasta el final del switch o hasta que un break sea encontrado.

• Uso de bucles

  • Una sentencia for básica tiene 3 partes: declaración y/o inicialización, evaluación booleana, y expresión de iteración.
  • Si una variable es incrementada o evaluada dentro de un bucle for básico, debe ser declarado antes del bucle, o dentro de la declaración del bucle for.
  • Una variable declarada (no inicializada) dentro de la declaración del bucle for básico no puede ser accedida fuera del bucle for. (En otras palabras, el código que se encuentre debajo del bloque del bucle for no podrá usar la variable).
  • Podemos inicializar mas de una variable del mismo tipo en la primera parte de la declaración del bucle for básico; cada inicialización debe ser separada por una coma.
  • Un bucle for mejorado (añadido en Java 6), tiene 2 partes, la declaración y la expresión. Es usado solo para hacer bucles a través de arrays o colecciones.
  • Con el bucle for mejorado, la expresión es el array o colección por la que queremos iterar.
  • Con un bucle for mejorado, la declaración es el bloque de la variable, cuyo tipo es compatible con los elementos del array o la colección, y esta variable contiene el valor del elemento para la iteración que se está llevando a cabo.
  • No podemos usar un número o cualquier otra cosa que no pueda evaluarse como un valor boolean como condición para la sentencia if o el constructor del bucle.
  • El bucle do entrará al cuerpo del bucle al menos una vez, incluso si la condición de la comprobación no se ha llevado a cabo.

• Usando break y continue

  • Una sentencia break sin etiquetar causará que la iteración actual del bucle mas interior se pare y la línea de código que siga al bucle se ejecute.
  • Una sentencia continue sin etiquetar causará que la iteración actual del bucle interior se pare, la condición del bucle sea comprobada, y si se dá, el bucle comenzará de nuevo.
  • Si la sentencia break o continue es etiquetada, causará una acción similar que ocurrirá al bucle etiquetado, no al bucle interior.

• Manejando Excepciones

  • Las Excepciones pueden ser de 2 tipos: controladas y sin controlar.
  • Una excepción controlada incluye todos los subtipos de Exception, excluyendo clases que heredan de RuntimeException.
  • Las excepciones controladas son sujetos de la regla de manejar o declarar: cualquier método que pueda lanzar una excepción controlada (incluidos métodos que puedan invocar métodos que puedan lanzar una excepción controlada) deben ya sea declara la excepción usando throws, o manejar la excepción con un bloque try/catch.
  • Los subtipos de Error o RuntimeException no están controlados, por lo que el compilador no nos forzará a manejar o declararlos. Somos libres de manejarlos, o declararlos, pero el compilador no le importará una manera o la otra.
  • Si unsas un bloque finally, siempre será invocado, independientemente si la excepción se ha lanzado en el try o no, y sin importar si la excepción ha sido cogida o no.
  • La única excepción que que no cumple esta regla del finally es aquella que hace que la JVM se apague. Esto podría pasar si el código del try o catch llama a System.exit().
  • Que finally sea invocado no quiere decir que se complete. El código en el bloque finally podría por sí mismo levantar una excepción o un System.exit().
  • Las excepciones que no son recogidas se propagarán a través de la pila de llamadas o call stack, empezando en el método donde la excepción ha sido lanzada y terminando en el primer método que tenga el correspondiente catch para ese tipo de excepción o que la JVM se apague (lo cuál pasarási la excepción llega a main()).
  • Puedes crear tus propias excepciones, normalmente heredando de la clase Exception o uno de sus subtipos. Tu excepción entonces será considerada como una excepción comprobada, y el compilador forzará la regla de manejar o declarar esa excepción.
  • Todos los bloques catch deben estar ordenados desde el mas específico hasta el mas general. Si tenemos un catch para una Exception y otro para una IOException, deberemos poner antes el catch para la IOException.
  • Algunas excepciones son creadas por los programadores, y otras por la JVM.