Scjp Jug Section 2 Flow Control
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
2,785
On Slideshare
2,719
From Embeds
66
Number of Embeds
4

Actions

Shares
Downloads
46
Comments
0
Likes
0

Embeds 66

http://www.jug.cl 54
http://www.linkedin.com 6
http://www.slideshare.net 4
https://www.linkedin.com 2

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. SCJP – Sección 2: Control de Flujo, Exceptions y Assertions José Miguel Selman G. (jose.selman@gmail.com)‏
  • 2. 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
  • 3. 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)‏
  • 4. 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”);
  • 5. 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 }
  • 6. 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”);
  • 7. 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”); }
  • 8.
    • 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”); }
  • 9. 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
  • 10. 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)‏
  • 11. 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.
  • 12.
    • 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.
  • 13. 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
  • 14. 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++)
  • 15. 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); }
  • 16. 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
  • 17. 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”
  • 18. 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
  • 19. 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
  • 20. 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
  • 21. 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; }
  • 22.
    • 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; }
  • 23. 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.
  • 24. 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 … … …
  • 25. 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
  • 26. 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();
      • }
      • // ...
      • }
  • 27. 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.
  • 28. 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.
  • 29. 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.
  • 30. 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...
  • 31. 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;)‏
  • 32. 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