Excepciones y archivos Info 033

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

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

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

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...

Ejemplo

Una excepción en un objeto… de tipo Exception

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

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.

Si Exception es un objeto, podemos extenderlo public class MyException extends Exception { public MyException(String message) { super(message); }

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

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();

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

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; }

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

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

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"); }

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

Probando el método

Recursividad

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

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 = ! = 10 x 9 x 8 x 7 x 6 x 5! =

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

En resumen cada n! Es el producto de n*(n-1)! Caso recursivo Caso base 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).

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

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

Esto luce como

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 = F n-1+ F n-2, Casos base : F 0= 0, F 1= 1 ¿ Fibonnaci(6) ?

Ahora programe public static int fibonacci(int number){ }