¡Descarga Excepciones en Java - Apuntes - Programación y más Apuntes en PDF de Ingeniería Infórmatica solo en Docsity!
Agenda
Contents
1 Excepciones 1 1.1 Introduccion............................... 1 1.2 Excepciones en Java.......................... 1 1.3 Captura de excepciones........................ 2 1.4 Relanzamiento de excecpciones.................... 2 1.5 Creacion de una excepcion....................... 3 1.6 Herencia de excepciones........................ 3 1.7 Sumario................................. 4
2 Entrada y Salida en Java 4 2.1 InputStream............................... 5 2.2 OutputStream............................. 5 2.3 Filters.................................. 5 2.3.1 FilterInputStreams....................... 6 2.3.2 FilterOutputStreams...................... 6 2.3.3 RandomAccessFile....................... 6 2.4 Ejemplo................................. 6 2.5 Nuevos Streams version 1.1...................... 7 2.6 Serializacion............................... 7
3 Threads 7
1 Excepciones
1.1 Introduccion
Introducci´on
- Errores
- En tiempo de compilacion. Ej. % javac hola.java
- En tiempo de ejecucion. Ej. % java hola
- Gestion de errores
- Antigua usanza, e.g., utilizar estructuras del tipo if-then-else
- Soporte generico para el manejo de errores. Ej. Excepciones o excep- tions en Java
- Tipos de excepciones en Java
- Irrecuperables. Debe terminar el programa ordenada y limpiamente posible.Ej. No se encuentre el metodo main.
- Recuperables. Oportunidad para corregir el error. Ej. No encuentra un archivo.
1.2 Excepciones en Java
Clases para el manejo de excepciones en Java
Lanzamiento de excepciones
- Se crea un objeto Exception de la clase adecuada
- Se lanza con throw seguida del objeto Exception creado.
- El m´etodo termina de inmediato
- Si est´a dentro de un bloque try/catch/finally se ejecuta el bloque catch.
... //Lanza la excepcion MyException una vez detectado el error MyException me = new MyException(’’MyException Message’’); throw me; ...
1.3 Captura de excepciones
Captura de excepciones
- Si un m´etodo puede incurrir en algunas excepciones:
- Utilizamos las sentencias try/catch/finally
- Declaramos la excepcion correspondiente en el encabezamiento del metodo
public void leeFichero(String _f) throws EOFException, FilenotfoundException { ... }
public void leeFichero(String _f) throws IOException { ... }
Captura de excepciones
- Excepciones que no pertenece a RuntimeException
- Todas las sentecias dentor del bloque try estara vigilado
... // Lanza la excepcion MyException una vez detectado el error void metodo1(){ ... try { //Las excepciones IOException y MyException } catch (IOException e1) { System.out.println(e1.getMessage()); } catch (MyException e2) { System.out.println(e2.getMessage()); return; } finally { Sentencias que se ejecutar\’an siempre, e.g. ocurra o no la excepcion } }
Class MiClase { public produceExcepcion() throws MyExcepcion, IOException{ ... }
Class MiClase2 extends MiClase { public produceExcepcion() throws MyExcepcion { ... }
// Forma NO VALIDA Class MiClase2 extends MiClase { public produceExcepcion() throws MyExcepcion, IOException, MyExcepcion2 { ... }
Ejemplo ver ejemplo Relanzar.java
1.7 Sumario
Sumario Si un m´etodo llama a otros m´etodos que pueden lanzar excepciones:
- Capturar las posibles excepciones y gestionarlas mediante las sentencias try/catch/finally
- Desentenderse de ellas y remitirlas hacia otro m´etodo anterior para que las gestione la sentencia throws.
2 Entrada y Salida en Java
I/O. Entrada y Salida de datos Streams o flujos de datos:
- Flujo de datos
- Conexi´on entre programa y la fuente o destino de datos
- Los datos se trasladan en serie
- Ejemplos. Imprimir en pantalla, escribir en un fichero, leer de una conexi´on en red, entre otros.
I/O. Entrada y Salida de datos Diferentes tipos de I/O
- Archivo
- Consola
- Bloques de memoria
- Conexion de redes. Diferentes tipos de operaciones
- Secuencial
- Acceso aleatorio
- Binario
- Caracteres
- Por lineas, etc.
I/O. Entrada y Salida de datos Caracteristicas
- Parece que hay muchas clases
- Cuando se programa parece un c´odigo muy largo: Se requiere escribir mucho Versiones de las clases
- Streams de Java 1.
- Streams de Java 1.1 (Mejoradas)
I/O. Entrada y Salida de datos InputStream
- Todos tiene el m´etodo read(), que no usaremos.
- A veces es dificil averiguar cuando hemos llegado al final
OutputStream
- Todos tiene el m´etodo write(), que no usaremos.
Usaremos ”decoradores” para a˜nadir funcionalidad
2.1 InputStream
InputStream Tipos
- FileInputStream → Archivos
- PipedInputStream → ”tuberias” de otro hilo
- ByteArrayInputStream → bloques de memoria
- StringBufferInputStream → Strings
- FilterInputStream → No para leer. Clases abstractas para a˜nadir funcional- idad
- SequenceInputStream → Streams combinados
2.2 OutputStream
OutputStream Tipos
- FileOutputStream → Archivos
- PipedOutputStream → ”tuberias” de otro hilo
- ByteArrayOutputStream → bloques de memoria
- FilterOutputStream → No para escribir. Clases abstractas para a˜nadir fun- cionalidad
2.3.3 RandomAccessFile
RandomAccessFile No forma parte de la jerarqua de clases de InputStream y OuputStream.
- Permite movernos usando el m´etodo seek(), y poder leer y escribir datos
- Necesita implementar los interfaces DataInput y DataOuput
- Es muy diferente conceptualmente. Los dem´as Streams solos se leen o es- criben hacia adelante, no exista el concepto de movimiento
2.4 Ejemplo
Ejemplo Ver archivo IOStreamDemo.java
- Lectura de archivo con Buffer
- Lectura desde memoria
- Lectura de memoria con formato String
- Numeraci´on de lineas y salida a fichero
- Guardando y recuperando datos
- Leyendo y escribiendo archivos con acceso aleatorio
2.5 Nuevos Streams version 1.
Streams v1.
- Nuevas clases Reader y Writer
- Internacionalizaci´on (usa char de 16-bits, en vez de byte de 8-bits)
- Dise˜nados para una mayor velocidad
- Algunas veces pueden reemplazar a InputStream y OutputStream
- Otras veces se usan las antiguas en combinaci´on con las nuevas
- Es un poco confuso.
Diagrama de clases de los Streams v1.
Figure 1: Threads
2.6 Serializacion
Serializacion
- La clase a serializar debe implementar Serializable
- Se usa ObjectOutputStream y ObjectInputStream
- Los m´etodos para escribir y leer el objeto: writeObject() y readObject()
- Todas las partes relevantes del objeto quedan guardadas.
- Muy til para guardar en disco el estado de un programa.
- til tambi´en para envio de objetos por red (RMI)
Serializacion. Ejemplo
//Escribiendo un objeto ObjectOutput out = new ObjectOutputStream (new FileOutputStream ("object.x")); Rectangulo r = new Rectangulo(); out.writeObject(r);
// Leyendo un objeto ObjectInput in = new ObjectInputStream (new FileInputStream ("object.x")); Rectangulo r = (Rectangulo)in.readObject();
3 Threads
Proceso
- Un programa ejecutndose independientemente
- Espacio propio de memoria
- SO Multitarea: Ejecuta mltiples procesos simultaneamente
Thread o hebra o hilo
- Flujo secuencia simple dentro de un proceso: Daemon o no daemon
ver 1 Los procesadores y los SO modernos permiten la ejecucion de multiples tareas, e.g., la realizacion de dos o mas actividades de forma simultanea, mediante el concepto de timesharing
- Un PC con una solo microprocesador no puede realizar fisicamente dos tareas a la vez
- Puede ”distribuir” su tiempo entre dos o mas actividades, o utilizar los tiem- pos muertos (idle time) de una actividad para trabajar en otra.
class TRunnable extends Applet implements Runnable{ private Thread hebra == null; public void start(){ if(hebra == null){ hebra = new Thread(this); hebra.start(); //start() llama a run() } } }
El argumento this hace referencia al objeto cuyo metodo run() debe ser llamado cuando la hebra ejecutada es un objeto de TRunnable Una hebra puede realizar cualquier tarea de un programa normal y corriente. Basta con programar las tareas correspondientes en el metodo run() La eleccion de derivar Thread o implementar Runnable
- Si la clase a utilizar ya hereda de otra clase, entonces utilizamos la interfaz Runnable
- En casos donde se posee poca experticia se recomienda derivar de Thread
Creando una hebra Cuando se crea una hebra o hilo, este debe estar limitado permanentemente en un objeto con un metodo run(). Cuando se inicia una hebra, se invocara el metodo run() del objeto. Otra forma mas sofisticada consiste en la implementacion de la interfaz Runnable. Hay dos formas de crear un hilo: La primera es declarar una clase que extienda a Thread. Cuando la clase es instanciada, el hilo y el objeto son creados juntos y el objeto es automaticamente limitado al hilo. Se llama al metodo start() del objeto e inmediatamente se llama a al metodo run().
// This class extends Thread class BasicThread1 extends Thread { // This method is called when the thread runs public void run() { } }
// Create and start the thread Thread thread = new BasicThread1(); thread.start();
La segunda forma es crear un hilo y alimentarlo con un objeto con el metodo run(). Este objeto debera estar asociado permanentemente con el hilo. El objeto con el metodo run() sera invocado cuando el hilo sea inicializado. Este metodo de creacion de hilos es muy util cuando se desea que muchos hilos compartan un objeto.
class BasicThread2 implements Runnable { // This method is called when the thread runs public void run() { } } // Create the object with the run() method Runnable runnable = new BasicThread2();
// Create the thread supplying it with the runnable object Thread thread = new Thread(runnable);
// Start the thread thread.start();
Deteniendo una hebra La forma apropiada para detener el hilo que esta corriendo el hilo consiste en configurar una variable que cheque ocasionalmente el hilo. Nota: Thread.suspend() y Thread.stop() proporciona metodos asincronos para detenr el hilo. Sin embargo, estos metodos han sido descontinuados por se inseguros. Usarlos frecuentemente resulta en deadlocks e incorrecta limpieza de los recursos.
// Create and start the thread MyThread thread = new MyThread(); thread.start();
// Do work...
// Stop the thread thread.allDone = true;
class MyThread extends Thread { boolean allDone = false;
// This method is called when the thread runs public void run() { while (true) { // Do work... if (allDone) { return; } // Do work... } } }
Determinando cuando finaliza un hilo
// Create and start a thread Thread thread = new MyThread(); thread.start(); // Check if the thread has finished in a non-blocking way if (thread.isAlive()) { // Thread has not finished } else { // Finished } // Wait for the thread to finish but don’t wait longer than a // specified time long delayMillis = 5000; // 5 seconds try { thread.join(delayMillis); if (thread.isAlive()) { // Timeout occurred; thread has not finished } else { // Finished } } catch (InterruptedException e) { // Thread was interrupted } // Wait indefinitely for the thread to finish try { thread.join(); // Finished } catch (InterruptedException e) { // Thread was interrupted }
Deteniendo temporalmente una hebra Este ejemplo demuestra como una hebra puede detenerse temporalmente
try { // 5 seconds long numMillisecondsToSleep = 5000; Thread.sleep(numMillisecondsToSleep); } catch (InterruptedException e) { }
Ciclo de vida de una hebra
Ejemplo Ver programa Consumer-Producer...
