Excepciones y archivos

1. Info 033 Excepciones y archivos

2. Exception El término Exception es la palabra corta para la frase "evento excepcional." • Definition: Una excepción es un evento, que ocurre durante la ejecución de un programa, que interrumpe el flujo normal de las instrucciones del programa

3. How to throw exceptions Antes de que puedas atrapar una excepción, debes saber como lanzar excepciones. Java provee de varias clases de excepciones.

4. Prueba este código import java.util.EmptyStackException; public classTestProgram { public static void main(String[] args) { int size=0; if (size == 0) { //lanzamos una excepcion - error al programa throw newEmptyStackException(); } System.out.println("que paso?"); } }

5. Handle Exceptions – Manejo excepciones El primer paso para poder manejar el código que genera una excepción es envolver el código con try – catch – finally try { code } catch and finally blocks . . .

6. Ejemplo

7. Una excepción en un objeto… de tipo Exception

8. El control de flujo en el bloque try/catch Cuando el intento es exitoso Cuando el intento es fallido

9. Finally Hay veces en las que se deseas estar seguro que un bloque de código se ejecute, se produzcan o no excepciones. Se puede hacer esto añadiendo un bloque finally después del último catch.

10. Si Exception es un objeto, podemos extenderlo public classMyExceptionextendsException { public MyException(String message) { super(message); } }

11. Ahora prueba este código //le avisamos al compilador que este método puede lanzar un MyException public static void main(String[] args) throwsMyException { int size=0; if (size == 0) throw new MyException("Esto es mi error"); }

12. Archivos Al igual que con las excepciones java provee un conjunto de objetos para manejar archivos. File archivo = new File ("archivo.txt"); FileReader fr = new FileReader (archivo); BufferedReader br = new BufferedReader(fr); ... String linea = br.readLine();

13. Algo extremadamente útil Java provee clases para guardar objetos en archivos. Objetos de objetos, etc. Por lo que podemos guardar en un archivo la información que tengan nuestros objetos y posteriormente recuperarla. Útil para cuando deban programar un guardar/guardar como

14. Paso 1 – Crea la siguiente clase //Java nos dice que para poder guardar un objeto //debe implementar Serializable class Persona implements Serializable { String nombre; int edad; public Persona(String nombre, int edad) { this.nombre=nombre; this.edad =edad; } }

15. Paso 2 – Crea un package para almacenar archivos Crea un package files, que contenga un archivo de nombre guardar

16. Paso 3 – Crear la siguiente clase public class ObjectHandler { public static void saveObject(String filename, Object o) throwsFileNotFoundException, IOException { FileOutputStream saveFile = new FileOutputStream(filename); ObjectOutputStream save = new ObjectOutputStream(saveFile); save.writeObject(o); save.close(); } }

17. Paso 4 – Guardar nuestro objeto public static void main(String[] args) { Persona p1 = new Persona("Juan", 15); try { ObjectHandler.saveObject("src/files/guardar", p1); } catch (FileNotFoundException ex) { System.out.println("Archivo no encontrado"); } catch (IOException ex) { System.out.println("Error de lectura/escritura"); } }

18. ¿Para leer un objeto? Agreguemos otro método a nuestra clase ObjectHandler

20. Probando el método

21. Recursividad

22. Comencemos con un ejemplo GNU = GNU no es Unix GNU GNU no es UnixGNU no es Unix no es UnixGNU no es Unix no es Unix No es Unix … infinitamente

23. El factorial n! = n x (n-1) x (n-2) x … x 1 Ejemplo: 3! = 3 x 2 x 1 = 6 5! = 5 x 4 x 3 x 2 x 1 = 120 10! = 10 x 9 x 8 x 7 x 6 x 5! = 3628800

24. Recursividad es resolver un problema grande, resolviendo pequeñas partes del mismo problema 10! = 10 * 9! 9! = 9 * 8! 8! = 8 * 7! 7! = 7 * 6! 6! = 6 * 5! 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1! 1! = 1

25. En resumen cada n! Es el producto de n*(n-1)! Una definición recursiva se compone de un caso recursivo y de uno o más casos base (que no se escriben en términos de si mismo). Caso base Caso recursivo

26. Resolviendo Fact(4): Fact(4) = 4*Fact(3) Fact(3) = 3*Fact(2) Fact(2) = 2 * Fact(1) Fact(1) = 1 Fact(2) = 2*1, Fact(3) = 3*2, Fact(4) = 4*6

27. Entendiendo la matemática, la programación es lo más sencillo public static intfactorial (int x) { if (x > 1) { //recursive case return factorial(x-1) * x; } else /*base case*/ return 1; }

28. Esto luce como

29. Calcule el n-esimo valor de la serie de fibonacci utilizando recursividad En términos matemáticos la serie de fibonacci se define como sigue: Caso recursivo: Fn = Fn-1+Fn-2, Casos base: F0=0, F1=1 ¿ Fibonnaci(6) ?

30. Ahora programe public static intfibonacci(int number){ }