Excepciones y archivos Info 033. Exception El término Exception es la palabra corta para la frase...
-
Upload
teodosio-hay -
Category
Documents
-
view
111 -
download
1
Transcript of Excepciones y archivos Info 033. Exception El término Exception es la palabra corta para la frase...
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){
}