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

FinallyHay 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 UnixGNU 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 = 120

10! = 10 x 9 x 8 x 7 x 6 x 5! = 3628800

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 = Fn-1+Fn-2,

Casos base: F0=0, F1=1

¿ Fibonnaci(6) ?

Ahora programe

public static int fibonacci(int number){

}