POO – Java

Clase 3
 Manejo de errores: Excepciones
Concurrencia: Threads. Sincronización.
Persistencia en Bases de Datos. (JDBC)

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 1

 ¿Qué es una excepción?
• Es un evento no deseado durante la ejecución: acceso
fuera de los límites de un arreglo, intentar acceder a un
URL inválido, dividir por cero. Interrumpe el flujo normal
de ejecución, pero puede manejarse.
• Un error, en cambio es una condición anormal no
recuperable. (ej: JVM intentando correr fuera de
memoria). El programa debe terminar.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 2

 ¿Cómo trata Java las excepciones?
• El método donde ocurre el evento no deseado crea un objeto de
tipo Exception y la referencia a la excepción es lanzada
(throw) fuera del contexto donde se genera.
• El sistema (JVM) busca un lugar (handler). donde capturar
(catch) y resolver la excepción.
• Si no se encuentra un handler apropiado, el programa termina.

objeto
Exception

¿Handler
para esta
Si excepcion? No
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 3
 Ventajas del manejo
de excepciones en Java
• Separar el código que maneja la excepción
• En los lenguajes tradicionales, el manejo de errores
frecuentemente hace más confuso el código.
• Java separa los detalles del manejo de excepciones del
código “normal” del programa.
• El código resultante es más claro para leer y menos
propenso a bugs.
• Permite agrupar y diferenciar los tipos de errores.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 4

 Separando el código
readFirstLine { readFirstLine {
int errorcode = 0; try {
open file; open file;
if (openError) { read file;
errcode = OPEN_ERR; close file;
} }
else { catch (openError) {
read file; handle error;
if (readError) { }
errcode = READ_ERR; catch (readError) {
} handle error;
close file; }
if (closeError) { catch (closeError) {
errcode = errcode handle error;
AND CLOSE_ERR; }
} }
} return errcode; Java
}
Tradicional
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 5
 Pasando la excepción
• El camino es más directo!
Manejo tradicional Excepciones en Java
método1
método1 método1
método1
//trata
//trata error
error Error
Error //handle
//handle ex
ex
code
code
método2
método2 método2
método2
Error
Error
code
code Exception
Exception
método3
método3 método3
método3 ex
Error ex
Error
método4
método4 code
code método4
método4

Cada método debe chequear método4 throws la excepción;

por el error y devolver un código método1 hace el catch y la resuelve
de error al método que lo invocó

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 6

 Tipos de excepciones y errores
• Todos los errores y excepciones extienden la clase Throwable
Throwable

Error Exception

Errores no recuperables Excepciones chequeadas

RuntimeException

Problema fatal. Deben ser capturadas y Excepciones no chequeadas (run-time)

No permite catch.
Ej.: problemas de memoria
o imposibilidad de cargar
una clase.
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java
manejadas en alguna parte.
Regla forzada por el El programador puede elegir que
compilador. hacer con la excepción (capturarla o ignorarla).
Si ocurre y fue ignorada, entonces la JVM termina
el programa mostrando excepción ocurrida.
Ej: división por cero, índice arreglo fuera de límite.
7
 Lanzar una excepción
• Usar la instrucción throw para arrojarla
• Usar throws en la declaración del método, para informar que
puede ocurrir al invocarlo.
throw new Exception1();

public String getValue(int index) throws

IndexOutOfBoundsException {
if (index < 0 || index >= values.length) {
throw new IndexOutOfBoundsException();
}
// sentencias luego del if NO se ejecutan
// si se lanza la excepción
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 8

 ¿Qué hacer con una excepción?
• Al invocar a un método que podría generar una
excepción, existen tres opciones:
– Capturar (catch) la excepción y manejarla.
– Capturar la excepción y generar una excepción diferente
(throw); esta nueva excepción deberá ser manejada en
algún lugar.
– Dejar pasar la excepción, otro handler la manejará...

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 9

 Cómo capturar y manejar una excepción
• Encerrar el llamado al
try {
método dentro de un bloque
// llamar al metodo
try. }
• Manejar cada excepción en catch (exception1) {
un bloque catch. // manejar exception1
}
• Poner cualquier catch (exception2) {
procesamiento final dentro // manejar exception2
de un bloque finally. }…
finally {
// procesamiento final
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 10

 Capturando una excepción
int qty;
String s = getCantidadDesdeForm();
try {
// Puede generar NumberFormatException
qty = Integer.parseInt(s);
}
catch ( NumberFormatException e ) {
// Manejar la excepcion
qty = 0;
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 11

 Capturando varias excepciones
try {
// Puede generar MalformedURLException
URL u = new URL(str);
// Puede generar IOException
URLConnection c = u.openConnection();
}
catch (MalformedURLException e) {
System.err.println(“No puede abrir URL: " + e);
}
catch (IOException e) {
System.err.println(“No puede conectarse: " + e);
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 12

 Utilizando la cláusula finally
FileInputStream f = null;
try {
f = new FileInputStream(pathArchivo);
while (f.read() != -1)
cantCaracteres++;
}
catch (IOException e) {
System.err.println("Error al acceder file" + e);
}
finally {
// Este bloque siempre se ejecuta
f.close();
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 13

 Capturar una excepción y
arrojarla como una diferente
catch (exception1 e) {
throw new exception2(…);
}

void ReadUserFile throws UserFileException {

try {
// codigo para abrir y cerrar un archivo
}
catch (IOException e) {
throw new UserFileException(e.toString());
}
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 14

 Dejar pasar la excepción
• Usar throws en la declaración del método.
• La excepción se propaga al método que llama.
public int myMethod() throws exception1 {
// codigo que podria generar la excepción
}

public URL cambiarURL(URL oldURL)

throws MalformedURLException {
return new URL("http://www.oracle.com");
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 15

 Excepciones encadenadas
• Cuando se captura una excepción y se arroja como una
diferente, puede resultar útil conocer la causante de la nueva
excepción.
• Constructores sobrecargados y los métodos initCause,
getCause permiten el soporte de excepciones encadenadas

try {
// . . .
} catch (Exception e) {
e.printStackTrace(System.out);
System.out.println("###what was the cause:");
e.getCause().printStackTrace(System.out);
}

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 16

 Log de excepciones
• El paquete java.util.logging provee facilidades para
llevar un log de excepciones
try {
Handler handler = new FileHandler("OutFile.log");
Logger.getLogger("").addHandler(handler);
} catch (IOException e) {
Logger logger = Logger.getLogger("package.name");
StackTraceElement elements[] = e.getStackTrace();
for (int i = 0, n = elements.length; i < n; i++) {
logger.log(Level.WARNING,
elements[i].getMethodName());
}
}
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 17
 Creando una excepción propia
class MyException extends Exception {
public MyException(String msg) {
super(msg);
}
}
public class FullConstructors {
public static void g() throws MyException {
throw new MyException("Originated in g()");
}
public static void main(String[] args) {
try {
g();
} catch(MyException e) {
e.printStackTrace(System.err);
}
} MyException: Originated in g()
} at FullConstructors.g(FullConstructors.java:22)
at FullConstructors.main(FullConstructors.java:31)
Process Exit...
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 18
 Excepciones propias: chequeadas o no?
• Al crear una excepción propia, esta se puede extender de
Exception (chequeada), o de RuntimeException (no
chequeada).
• Algunos programadores extienden siempre de
RuntimeException para evitar especificar las
excepciones que un método puede generar. No es conveniente
seguir esta práctica: ya que las excepciones posibles son parte
de la interfaz pública del método.
• ¿Cómo decidir?: Si el cliente puede recuperarse de la excepción,
hacer una excepción chequeada. Sino puede hacer nada,
entonces hacer que la excepción sea no chequeada.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 19

 Excepciones: malas prácticas
• Silenciar excepción. Viola principio de gestión de excepciones
chequeadas (“gestionar o relanzar”)
try { // Código que declara lanzar excepciónes
} catch (Exception ex) { }

• Intentar escribir código que mejore rendimiento de la aplicación.

Las excepciones no están diseñadas para ello.
try {
int i = 0;
while(true) {
System.out.println(numerosPrimos[i++]);
}
} catch(ArrayIndexOutOfBoundsException aioobex) {}
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 20
 Excepciones: malas prácticas
• Lanzar excepciones en forma genérica. No informa “nada”
public void miMetodo() throws Exception {
// Código lanza muchas excepciones.
// Se informa lanzar una única super-clase
}

• Convertir excepciones chequeadas en no chequeadas. Debate

abierto sobre pros y contras.
public void noLanzoExcepcionesChecked() {
try { // Código que lanza una o más excepciones de
// tipo checked
} catch (Exception ex) {
throw new RuntimeException(“Excepcion con el
mensaje: " + ex.getMessage(), ex);
} Mdp
UCAECE } – Algoritmos y Estructuras de Datos II - Java 21
 Concurrencia: programación multihilos
• Implica “hacer más de una cosa al mismo tiempo”
• Se conmuta entre distintas partes del código de un mismo
programa durante la ejecución. Cada una de estas partes
individuales y atómicas (no divisibles) se llama hilo (thread).
• Los hilos existen dentro de un proceso, todo proceso tiene al
menos uno.
• Java soporta desde el principio programación concurrente.
Desde JSE5 (paquete java.util.concurrent) se
incluyen clases para manejar concurrencia a más alto nivel de
abstracción.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 22

 Programación concurrente: precauciones
• Las secciones de código potencialmente peligrosas por el uso de
recursos compartidos se conocen como secciones críticas.
• Las secciones críticas deben ser lo más pequeñas posible de
forma que los mecanismos de protección no degraden el
funcionamiento del sistema.
• Se debe evitar que:
– varios hilos entren en una sección crítica (exclusión mutua o mutex).
– los hilos se bloqueen entre sí (deadlock) para que no haya vistas
inconsistentes de la memoria compartida.
– haya inanición (starvation): un hilo se queda esperando indefinidamente para
acceder a la sección crítica.
• Cumplir la propiedad de equitatividad (fairwess) repartiendo el
tiempo de la forma más justa entre todos los hilos.
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 23
 Exclusión mutua: sincronización
• Java proporciona un mecanismo de exclusión mutua muy sencillo, mediante
el uso de la palabra reservada synchronized.
• Basta con declarar un método como synchronized para que dos o más hilos
no puedan ejecutar dicho método sobre el mismo objeto a la vez.
• La sincronización en Java está basada en una entidad interna: “lock
intrínseco” o monitor.
• Los constructores no pueden sincronizarse. No tiene sentido porque solo el
hilo que crea un objeto debe tener acceso a él mientras se está construyendo.
• Se puede afinar más la exclusión y evitar el acceso simultáneo a nivel de un
fragmento de código, también mediante la palabra reservada synchronized.

synchronized(this)
{
...
}
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 24
 Hilos (Threads)
• Java utiliza en su API programación concurrente que suele ser
transparente para el desarrollador (ej, método service en
Servlets).
• En Java, una instancia de la clase java.lang.Thread
representa un hilo de proceso. Este objeto se emplea para
iniciar, detener o cancelar la ejecución del hilo.
• También puede hacerse mediante una clase que implemente la
interface java.lang.Runnable, que define un método
llamado run() que inicia la vida del hilo. Esta opción es más
flexible, porque permite que la clase descienda de otra que no
sea Thread.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 25

 Hilos (Threads)
• Un hilo de proceso que acaba de crearse permanece inactivo
hasta que se ejecuta su método start(). Solamente se
puede llamar una vez a este método durante el ciclo de vida de
un hilo.
• Un hilo sigue ejecutándose hasta que suceda alguna de las sig.
cosas:
– se acabe de ejecutar el código contenido en el método run().
– se produzca una excepción sin capturar durante la ejecución.
– se llame de manera explícita al método stop() (no aconsejable).
– Si no ocurre ninguna de estas tres cosas, el hilo continúa ejecutándose,
incluso después de que la aplicación que lo creó haya terminado.

(Ver ejemplo en Clase 3 – Referencias)

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 26
 Thread: métodos básicos
• Thread.sleep: método estático que causa la suspensión
del hilo corriente por un periodo especificado.
– Se usa para generar tiempo de procesador disponible, o esperar a otro hilo.
Puede generar una InterruptedException cuando otro hilo interrumpe el hilo
“dormido”.
• interrupt: indica a un hilo que detenga lo que está
haciendo. El programador debe decidir cómo el hilo responderá
a una interrupción (generalmente su terminación).
• join: método que permite a un hilo esperar por la terminación
de otro. Puede generar una InterruptedException

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 27

 Concurrencia: Acceso atómico
• Una acción atómica no puede detenerse en el medio, debe
suceder completa o no suceder.
• En Java las lecturas y escrituras son atómicas para las variables
de referencia y la mayoría de los tipos primitivos, o todas las
variables que tengan el modificador volatile.
• El uso de variables volatile reduce el riesgo de errores de
consistencia de memoria.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 28

 Coordinación de hilos: “Guarded blocks”
• Situación donde debe cumplirse una condición para que un bloque de código
comience.
public void guardedJoy() {
// Malgasta tiempo procesador. Evitar!!
while(!joy) {}
System.out.println("Joy has been achieved!"); }

public synchronized guardedJoy() {

// Solo se cicla una vez por cada evento especial,
// que puede no ser el esperado
while(!joy) {
try {
wait();
} catch (InterruptedException e) {}
}
System.out.println("Joy and efficiency have been achieved!");
}
…
public synchronized notifyJoy() {
joy = true;
notifyAll(); }

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 29

 Concurrencia: Objetos inmutables
• No pueden cambiar su estado (valores de sus atributos) luego
de ser construidos.
• Muy usados en aplicaciones concurrentes, ya que se evita que
sean corrompidos por interferencia de hilos u observados en
estado inconsistente.
• Estrategia para crear objetos inmutables:
– Todos los campos son private y final.
– Ausencia de métodos “setters”
– No permitir que las subclases sobrescriban métodos

(Ver ejemplo en Clase 3 – Referencias)

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 30

 Concurrencia: Objetos de alto nivel (JSE5)
• Objetos de “Lock” que simplifican aplicaciones concurrentes
– paquete java.util.concurrent.locks . Lock como interface base con objetos
Condition asociados. Mejora el bloqueo implícito de synchronized, evitando
deadlocks.
• “Executors” para lanzar y administrar hilos
– Interfaces Executor, ExecutorService y
ScheduledExecutorService.
– “Thread pools” que minimizan la sobrecarga al crear los hilos.
• Colecciones concurrentes que reducen la necesidad de sincronización.
– Estructura BlockingQueue, ConcurrentMap (subinterface de Map),
interface ConcurrentNavigableMap
• Variables atómicas que minimizan la sincronización
– Paquete java.util.concurrent.atomic. Ej: AtomicInteger con métodos como
incrementAndGet

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 31

 JDBC: Java DataBase Connectivity
• Provee una forma de comunicarse con bases de datos sin necesidad de
escribir código adicional para las diferentes plataformas.
• Packages java.sql y java.text .
• Un driver JDBC es lo que usa la JVM para traducir las instrucciones generales
de JDBC a instrucciones específicas para cada base de datos en particular.

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 32

 JDBC: Java DataBase Connectivity
• Los drivers son clases Java cargadas en tiempo de ejecución.

String driver = "org.gjt.mm.mysql.Driver";

try {
Class.forName(driver);
} catch(ClassNotFoundException cnfe) {
System.err.println("No existe clase: " + driver);

• JSE6 incorpora JDBC 4.0 API (paquete javax.sql) que extiende la

funcionalidad, y es parte de JavaEE.
• JSE7 incorpora JDBC 4.1 API: uso de try-with-resources y RowSet 1.1
(RowSetFactory y RowSetProvider)

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 33

 JDBC: Pasos para consultar una BD

1. Cargar el driver JDBC

2. Definir una conexión (Connection) de tipo URL, host, port y
base de datos.
3. Establecer la conexión.
4. Crear un objeto de tipo sentencia (Statement).
5. Ejecutar la sentencia (consulta o actualizacion).
6. Procesar el resultado (ResultSet)
7. Cerrar la conexión

(Ver ejemplo en Clase 3 – Referencias)

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 34
 DataSource como mejor alternativa a
DriverManager (JSE6)
• Más portable: no se debe “hardcodear” el nombre del driver o la
URL JDBC en la aplicación.
• Código más simple: métodos para adaptar conexiones (ej:
serverName)
• Pool automático de conexiones con transacciones distribuidas.

com.dbaccess.BasicDataSource ds =
new com.dbaccess.BasicDataSource();
ds.setServerName("grinder");
ds.setDatabaseName("CUSTOMER_ACCOUNTS");
ds.setDescription(
"Customer accounts database for billing);

UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java 35

 try-with-resources (JSE7)
public static void viewTable(Connection con) throws SQLException {
String query = "select COF_NAME, TOTAL from COFFEES";
try (Statement stmt = con.createStatement()) {
ResultSet rs = stmt.executeQuery(query);
while (rs.next()) {
String coffeeName = rs.getString("COF_NAME");
int total = rs.getInt("TOTAL");
System.out.println(coffeeName + ", " + total);
}
} catch (SQLException e) {
JDBCTutorialUtilities.printSQLException(e);
} }

• El try-with-resources declara 1 o más recursos (objeto que debe ser

cerrado por el programa luego de ser usado) que son cerrados
automáticamente al finalizar el try-with. Los recursos deben implementar
java.lang.AutoCloseable.
• Los bloques catch y finally (si existen) se ejecutan luego del cierre de los
36
recursos.
UCAECE Mdp – Algoritmos y Estructuras de Datos II - Java