Download Descargar clase: Try, Catch, Ficheros y Recursividad

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();
}
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);
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) {
¿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 = 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!
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
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){
}