Scjp Jug Section 2 Flow Control

SCJP – Sección 2: Control de Flujo, Exceptions y Assertions José Miguel Selman G. (jose.selman@gmail.com)‏

SCJP – Objetivos exámen Develop code that implements an if or switch statement; and identify legal argument types for these statements. Develop code that implements all forms of loops and iterators, including the use of for, the enhanced for loop (for-each), do, while, labels, break, and continue; and explain the values taken by loop counter variables during and after loop execution. Develop code that makes use of assertions, and distinguish appropriate from inappropriate uses of assertions. Develop code that makes use of exceptions and exception handling clauses (try, catch, finally), and declares methods and overriding methods that throw exceptions. Recognize the effect of an exception arising at a specified point in a code fragment. Note that the exception may be a runtime exception, a checked exception, or an error. Recognize situations that will result in any of the following being thrown: ArrayIndexOutOfBoundsException,ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError or NoClassDefFoundError. Understand which of these are thrown by the virtual machine and recognize situations in which others should be thrown programatically. * Extraído desde: http://www.sun.com/training/catalog/courses/CX-310-055.xml

Introducción El control de flujo es un aspecto fundamental de cualquier cualquier lenguaje de programación En Java existen: Decisión (if, switch)‏ Iteración (for, while, do, for-each )‏ Excepciones Depuración (assert)‏

if-else La expresión en paréntesis debe ser evaluada a un valor booleano: true o false La sentencia else es opcional Paréntesis opcionales if (expresión booleana) { // la expresión es verdadera, ==> dentro de la sentencia if } else { // la expresión es falsa, ==> dentro de la sentencia else } if (x > 3) System.out.println(“x es mayor a 3”); else System.out.println(“x es menos o igual a 3”);

else if Pueden incluirse varias sentencias else-if if (x >= 1 && x < 3) { // x es 1 o 2 } else if ( x >= 3 && x < 5 ) { // x es 3 o 4 } else if ( x >= 5 && x < 7 ) { // x es 5 o 6 } else { // x es mayor que 7 }

Expresiones válidas int verdadero = 1; int falso = 0; if (verdadero) // ilegal if (verdadero == true) // ilegal if (verdadero == 1) // legal Ojo con: boolean b = false; if (b = true) { // ... } if (false) System.out.println(“Hola”); System.out.println(“Chao”); if (false) ; System.out.println(“Hola”);

switch switch (expresión) { case constante1: // Código case constante2: // Código default: // Código } Por ejemplo int largo = “abc”.length(); switch (largo) { case 1: System.out.println(“1”); break; case 2: System.out.println(“2”); break; default: System.out.println(“default”); }

Imprime 1, 2, default Las expresiones son evaluadas de arriba a abajo y la primera coincidencia es el punto de entrada int largo = 1; switch (largo) { case 1: System.out.println(“1”); case 2: System.out.println(“2”); default: System.out.println(“default”); } int largo = 1; switch (largo) { case 1: case 2: System.out.println(“1 o 2”); break; default: System.out.println(“default”); }

Fall-Through y default int i = 11; switch(i) { case 1: System.out.println(“1”); default: System.out.println(“default”); case 2: System.out.println(“2”); case 3: System.out.println(“3”); } Imprime: default, 2, 3 Las expresiones son evaluadas de arriba a abajo y la primera coincidencia es el punto de entrada

switch Las sentencias switch pueden evaluarse con los siguientes tipos: enum , byte , short , int y char No pueden evaluarse con long En las sentencias case deben usarse sólo literales o variables finales. (compile-time constants)‏

while while(expresión booleana) { // hacer algo } La expresión debe evaluarse a un valor booleano La expresión se prueba cada vez que se va a iterar por lo que se puede entrar al código 0 ó más veces. int x = 10; while(x > 10) { System.out.println(“dentro del loop”); } System.out.println(“fuera del loop”); Imprime solamente: fuera del loop.

La iteración dentro del ciclo puede detenerse prematuramente si se encuentra alguna de las siguientes sentencias break : la ejecución salta a la primera sentencia fuera del loop return : se devuelve la ejecución al método que había realizado la llamada a este System.exit() : Finaliza la ejecución del programa y la JVM se detiene Se puede usar la sentencia continue para volver al inicio del cuerpo del loop.

do-while do { // Código } while (expresión booleana); Entra al menos una vez int x = 10; do { System.out.println(“dentro del loop”); } while(x > 10); System.out.println(“fuera del loop”); Imprime: dentro del loop, fuera del loop. Aplican las mismas características de término anticipado del ciclo que para while

for A partir de Java 5 apareció un nueva estructura para el loop for. La estructura básica tiene tres partes principales Declaración e inicialización de variables Una prueba condicional (expresión booleana) Expresión de iteración Deben separase con punto-y-coma for ( Inicialización ; Condición ; Iteración ) { // instrucciones } Por ejemplo: for ( int i=0; i<10; i++) { } for (int i=10, j=3; y>3; y++) { } for (int x=0; x < 10 && y-- > 2 | x == 3; x++)

for‏ Para el for básico aplican las mismas características de término anticipado de ciclo En los objetivos del examen la nueva estructura for se denomina for-each Fue creado como un atajo a los usos más frecuentes de for para iterar sobre arreglos for (declaración: expresión) { // instrucciones } Por ejemplo: String[] numeros = {“uno”, “dos”, “tres”, “cuatro”, “cinco”}; for(String s: numeros) { System.out.println(s); }

break y continue Son usados para detener la ejecución completa del loop ( break ) o solamente la iteración actual ( continue ). continue debe ser usado solamente dentro de un loop, en caso contrario provoca un error de compilación break debe ser usado dentro de un loop o de un switch . for(int i=1; i<10; i++) { if ( i == 5 || i == 7 ) { continue; } System.out.println(i); } Imprime 1, 2, 3, 4, 6, 8, 9

Labels Son usados típicamente en loops en conjunto con las sentencias break o continue . En loops anidados se usan para indicar a cuál queremos aplicarle la sentencia. Los labels se adhieren a las normas para los identificadores de nombres de variables. Se debe poner el identificador del label seguido de dos-puntos (:) boolean condicion = true; externo: for(int i=0; i<10; i++) { while(condicion) { System.out.println(“Hola”); break externo; } System.out.println(“Esto no se imprimirá”); } System.out.println(“Chao”); Imprime “Hola” y “Chao”

Exceptions Java provee un elegante mecanismo para detección y manipulación de errores: Las excepciones Permite a los desarrolladores detectar errores fácilmente sin tener que escribir código con reglas de códigos de retorno. Una excepción es una condición-excepcional que altera el flujo de ejecución normal de un programa. Cuando una de estas condiciones es alcanzada un excepción se dice ser lanzada (thrown). Las palabras reservadas try , catch y finally se usan para estructurar el código. try es usado para identificar un bloque de código que puede ocasionar alguna condición de excepción catch es usado para capturar las excepciones y manipularlas

try { // Intentamos abrir un archivo para lectura } catch(NoTenemosLosPermisosSuficientes e) { // Mostrar mensaje de error al usuario } finally es usado para realizar “limpieza” de recursos ya que se ejecuta incluso si una excepción es lanzada. Una sentencia try debe tener 0 o más sentencias catch A lo más un bloque finally Las excepciones pueden atraparse o bien declararse ( throws ) en cuyo caso no es necesario atraparlas con catch . Serán propagadas al método que esta abajo en el stack de ejecución. Para las excepciones que se declaran es importante conocer el stack de ejecución

Stack de Ejecución main() metodo1() main() metodo1() metodo2() main() main() metodo1() main() La ejecución se inicia con el método main main llama a metodo1 metodo1 llama a metodo2 metodo2 retorna metodo1 retorno y main llama a metodo3 metodo3() main() metodo3 retorna

Exception ducking En el caso que un método lance una excepción, esta es propagada al método que invocó al actual Si este método también la lanza, entonces sigue hacia abajo del stack de ejecución. Si no es atrapada cuando llega al método main, la máquina virtual finaliza su ejecución e imprime el error en stdout . public int cuentaLineasArchivo(String filename) throws IOException { BufferedReader br; int lineas = 0; try { br = new BufferedReader(new FileReader(filename)); while (br.readLine() != null) { lineas++; } } finally { if (br != null) br.close(); } return lineas; }

También puede atraparse y ser re-lanzada con la sentencia throw . public int cuentaLineasArchivo(String filename) throws IOException { BufferedReader br; int lineas = 0; try { br = new BufferedReader(new FileReader(filename)); while (br.readLine() != null) { lineas++; } } catch(IOException ioe) { ioe.printStackTrace(); // o extraer el mensaje usando ioe.getMessage(); throw ioe; } finally { if (br != null) br.close(); } return lineas; }

Tipos de Exceptions Las conocidas como Checked-Exceptions son las excepciones que las aplicaciones anticipan y declaran dentro de la firma de sus métodos. public String leePrimeraLineaArchivo(String nombreArchivo) throws IOException; Las Checked-Exceptions estan sujetas a ser atrapadas o declaradas. Heredan de java.lang.Exception Los Errores son otro tipo de excepciones Heredan de java.lang.Error. Corresponden a condiciones excepcionales que no pueden ser anticipadas y no hay manera de recuperarlas. Por ejemplo cuándo la máquina virtual se queda sin memoria lanza un java.lang.OutOfMemoryError pero no hay mucho que podemos hacer para anticiparlo o recuperarnos, más que imprimir el stackTrace e intentar de notificar al usuario. El tercer tipo de excepciones son las java.lang.RuntimeException Son condiciones excepcionales internas de la aplicación, usualmente no anticipables e irrecuperables. Típicamente indícan bugs. Por ejemplo java.lang.NullPointerException. No es necesario declararlas.

Jerarquía de Excepciones java.lang.Object java.lang.Throwable java.lang.Error java.lang.Exception java.lang.RuntimeException Fuente: Sun Certified Programmer for Java 5 Study Guide, Kathy Sierra & Bert Bates, McGraw Hill … … …

Atrapar excepciones Las sentencias catch deben estar ordenadas de arriba debajo de las Exceptions más particulares y después las más generales, en caso contrario el código no compilará. Solamente se ejecutará el bloque catch de la primera excepción que coincida y el flujo continuará en el bloque finally de existir. try { // ... } catch(NumerFormatException e) { // ... } catch(Exception e) { // ... } try { // ... } catch(Exception e) { // ... } catch(NumerFormatException e) { // ... } Correcto Incorrecto

Excepciones y Errores comunes Pueden ser clasificadas en dos grandes categorías de acuerdo a quién las lanza Excepciones de la JVM Excepciones programáticas private void miMetodo() { miMetodo(); } private void miMetodo(Usuario usuario) throws PermisosInsuficientesException { if (!usuarioTienePrivilegios(usuario)) { throw new PermisosInsuficientesException(); } // ... }

Algunas Comunes JVM NullPointerException : Al accesar un objeto a través de una variable con valor null. ArrayIndexOutOfBoundsException : Al accesar un indíce inválido de un arreglo ClassCastException : Al intentar hacer un “cast” de un objeto a un tipo para el que no pasa la prueba de ES-UN (IS-A) ExceptionInInitializerError : Cuando ocurre un error al inicializar una variable o bloque estático StackOverflowError : Ocurre cuando un método recursa muy profundamente. NoClassDefFoundError : Ocurre cuando no se encuentra una clase en tiempo de ejecución OutOfMemoryError : Ocurre cuando el Heap se queda sin memoria para crear un objeto. …

Algunas Comunes Programáticas NumberFormatException : Al intentar convertir un String a número y el formato no era el esperado IllegalArgumentException : Usado para indicar que los parámetros con los que se llamó a un método no eran los correctos IllegalStateException : Usado para indicar que una operación no puede realizarse con las condiciones actuales (Por ejemplo intentar modificar el contenido de un buffer que se encuentra cerrado) AsertionError : Lanzado cuando la prueba de la sentencia es evaluada a falso. …

Assertions Disponibles en Java desde la versión 1.4 Permiten probar las hipótesis durante el desarrollo Ignoradas por la JVM si no están habilitadas private void miMetodo(int n) { assert (n >= 0); // Si esto no es cierto se lanza un // AssertionError // ... resto del método ... } Dos tipos: assert (expresión); assert (expresión): mensaje; La expresión debe ser un valor booleano, mientras que el mensaje debe ser cualquier cosa que resulte en valor.

Habilitación Assertions Por defecto deshabilitadas (Removidas por el class-loader por lo que no tienen efectos en la performance)‏ Modificadores JVM -ea -enableassertions -da -disableassertions ... se usa para paquete y sub-paquetes java -ea java -enableassertions java -da java -disableassertions java -ea:cl.bee.util.RutValidador java -ea -da:cl.bee.util.RutValidador java -ea -da:cl.bee.util...

Usos correctos de Assertions No utilizar para validación de parámetros de métodos públicos (usar java.lang.IllegalArgumentException) No usar aserciones que modifiquen el valor de variables (pueden estar deshabilitadas)‏ Usar para validación de parámetros en métodos privados Usar para validar que un cierto código no debe ejecutarse (assert false;)‏

Recursos http://java.boot.by/scjp-tiger/ch02.html http://java.sun.com/docs/books/tutorial/essential/exceptions/ http://java.sun.com/docs/books/tutorial/java/nutsandbolts/index.html

Scjp Jug Section 2 Flow Control

Más contenido relacionado

La actualidad más candente (19)

Destacado (8)

Similar a Scjp Jug Section 2 Flow Control (20)

Último (20)

Scjp Jug Section 2 Flow Control