Tema 07

FUNDACIÓN GENERAL
Curso para IZAR
Colecciones de Java
y excepciones
El lenguaje Java — Tema 7 — Colecciones y excepciones

Colecciones
Manejo de grupos de datos  colecciones

Máquinas de datos que permiten almacenar, recuperar y
manipular elementos de datos.
Organización de las colecciones
Interfaces  Manipulan los datos independientemente de
los detalles de implementación.
Clases  Implementan las interfaces.
¿Cómo se trabaja con las colecciones?
Se elige una interfaz para la funcionalidad deseada.
Se elige una clase que implemente la interfaz con la eficiencia
deseada o alguna otra característica particular.
Se adapta (extiende) si es necesario.
Las interfaces permiten cambiar de implementación sin modificar el
código que hace uso de la interfaz.
Curso Java para IZAR Tema 7 – Colecciones y excepciones - 2

La arquitectura de colecciones de Java
Como las interfaces y las clases están relacionadas y colaboran

entre sí, se habla del armazón (framework) de colecciones, una
arquitectura completa para facilitar el uso de colecciones.
 Interfaces de colecciones: diferentes tipos de colecciones
en general, en abstracto.
 Implementaciones de propósito general: clases que
implementan las interfaces.
 Implementaciones abstractas: implementaciones parciales
de las interfaces.
 Algoritmos: métodos estáticos que realizan tareas útiles
sobre las colecciones, tal como ordenar una lista.
 Infraestructura: interfaces de soporte para las colecciones.

Interfaces de colecciones
Interfaces para manejar colecciones de datos:

Collection Map
Set List SortedMap

SortedSet
Map y SortedMap, aunque están relacionadas, en realidad
no representan colecciones, sino correspondencias. Se explican
también porque se manejan como las colecciones.
Algunas implementaciones pueden imponer restricciones en
los elementos que se pueden incluir, estableciendo que sean
de un determinado tipo o que no sean null, por ejemplo.
Si se intenta saltar la restricción se elevará una excepción.
Implementaciones abstractas: AbstractCollection,
AbstractSet, AbstractList, AbstractMap, etcétera.

Terminología
 Colección inmodificable: que no soporta operaciones

de modificación (add o remove, por ejemplo).
 Colección modificable: que no es inmodificable.
 Colección inmutable: que, además de inmodificable,
garantiza que no se percibirá ningún cambio en la colección.
 Colección mutable: que no es inmutable.
 Lista de tamaño fijo: aquella en la que el número
de elementos permanece invariable.
 Lista de tamaño variable: que no es de tamaño fijo.
 Lista de acceso aleatorio (o acceso directo): que permite
accesos indexados rápidos a los elementos.
 Lista de acceso secuencial: que no es de acceso aleatorio.

Interfaces de colecciones java.util
 Collection
Representa un grupo de objetos. Sin implementaciones
directas, agrupa la funcionalidad general que todas las
colecciones ofrecen.
 Set
Colección que no puede tener objetos duplicados.
 SortedSet
Set que mantiene los elementos ordenados.
 List
Colección ordenada que puede tener objetos duplicados.
 Map
Colección que mapea claves y valores; no puede tener claves
duplicadas y cada clave debe tener al menos un valor.
 SortedMap
Map que mantiene las claves ordenadas.

La interfaz Collection
add(Object): añade el objeto en la colección (opcional).

addAll(Collection): añade la colección (opcional).
clear(): quita todos los elementos de la colección (opcional).
contains(Object): ¿el objeto se encuentra en la colección?
conatinsAll(Collection): ¿todos esos elementos están?
equals(Object): ¿es igual esta colección y la proporcionada?
isEmpty(): ¿la colección está vacía?
Iterator iterator(): devuelve un iterador para la colección.
remove(Object): elimina una aparición del objeto (opcional).
removeAll(Collection): elimina todos esos objetos (opcional).
retainAll(Collection): se queda sólo con esos objetos (opcional).
size(): número de elementos en la colección
toArray(): devuelve un array con los objetos de la colección.

La interfaz List
Colecciones ordenadas (secuencias) en las que cada elemento

ocupa una posición identificada por un índice. El primer índice
es el 0. Las listas admiten duplicados.
add(int, Object): añade el objeto en la posición indicada (opcional).
add(Object): añade el objeto al final de la lista (opcional).
addAll(int, Collection): añade la colección en la posición (opcional).
addAll(Collection): añade la colección al final (opcional).
clear(): quita todos los elementos de la lista (opcional).
contains(Object): ¿el objeto se encuentra en la lista?
get(int): devuelve el objeto en la posición.
indexOf(Object): devuelve la 1ª posición en la que está el objeto (o –1).
isEmpty(): ¿la lista está vacía? . . .

La interfaz List
Iterator iterator(): devuelve un iterador para la colección.

lastIndexOf(Object): devuelve la última posición del objeto (o –1).
ListIterator listIterator(): devuelve un iterador de lista.
listIterator(int): devuelve un iterador de lista para la sublista.
remove(int): quita de la lista el objeto en esa posición (opcional).
remove(Object): elimina la primera aparición del objeto (opcional).
removeAll(Collection): elimina todos esos objetos (opcional).
retainAll(Collection): se queda sólo con esos objetos (opcional).
set(int, Object): reemplaza el objeto en esa posición por el objeto
que se proporciona (opcional).
size(): número de elementos en la colección
subList(int, int): devuelve la sublista que comienza en el índice que se
proporciona en primer lugar y termina en el elemento anterior al del índice
que se proporciona en segundo lugar.
toArray(): devuelve un array con los objetos de la colección.

La interfaz Map
Pares (clave, valor). No puede haber claves duplicadas

y cada clave se corresponde con al menos un valor.
clear(): quita todos los pares del mapa (opcional).
containsKey(Object): ¿la clave proporcionada se encuentra en el mapa?
containsValue(Object): ¿hay algún par con el valor proporcionado?
equals(Object): ¿es igual este mapa y el proporcionado?
get(Object): devuelve el objeto que se corresponde con la clave dada.
isEmpty(): ¿la lista está vacía?
put(Object clave, Object valor): asocia la clave proporcionada con
el valor proporcionado (opcional).
putAll(Map): incluye los pares de ese mapa (opcional).
remove(Object): quita la clave del mapa, junto con sus correspondencias
(opcional).
size(): devuelve el número de pares que hay en el mapa.
. . .

Implementaciones de propósito general java.util
Tablas hash:
 HashSet: implementa la interfaz Set.
 HashMap: implementa la interfaz Map.
Arrays de tamaño variable:
 Vector: implementa la interfaz List.
 Stack: implementa la interfaz List.
 ArrayList: implementa la interfaz List.
Árboles equilibrados:
 TreeSet: implementa la interfaz Set.
 TreeMap: implementa la interfaz Map.
Listas enlazadas:
 LinkedList: implementa la interfaz List.

Implementaciones de propósito general

La clase Vector
Vectores de objetos que pueden

aumentar o disminuir de tamaño
según se necesite.
Son como arrays sin posiciones
libres entre medias.
La creación de un vector se
realiza de la forma habitual:
Vector v = new Vector();
El índice de la primera posición
del vector es el 0.

La clase Vector
add(int, Object): inserta el objeto en la posición indicada.

add(Object) o addElement(Object): añade el objeto al final del vector.
addAll(int, Collection): añade la colección en la posición indicada.
addAll(Collection): añade los elementos de la colección al final,
en el orden que especifique el iterador de la colección.
capacity(): devuelve el tamaño actual del vector.
clear() o removeAllElements(): quita todos los elementos del vector.
clone(): devuelve un clon del vector.
contains(Object): ¿el objeto se encuentra en el vector?
firstElement(): devuelve el primer elemento del vector (posición 0).
get(int) o elementAt(int): devuelve el objeto en la posición indicada.
. . .

La clase Vector
indexOf(Object): devuelve la 1ª ocurrencia del objeto (o –1). Se usa el

método equals() de la clase del objeto para encontrarlo.
indexOf(Object, int): busca el objeto desde la posición indicada.
insertElementAt(Object, int): inserta el objeto en la posición dada.
isEmpty(): ¿el vector está vacío?
lastElement(): devuelve el último elemento del vector.
lastIndexOf(Object): devuelve la última ocurrencia del objeto (o –1). Se
usa el método equals() de la clase del objeto para encontrarlo.
lastIndexOf(Object, int): busca la última ocurrencia del objeto
desde la posición indicada y hacia el principio del vector.
remove(int) o removeElementAt(int):quita el objeto en esa posición.
remove(Object): elimina la primera aparición del objeto.
removeAll(Collection): elimina todos esos objetos.
. . .

La clase Vector
removeRange(int, int): quita los elementos desde el índice que se

proporciona en primer lugar hasta el elemento anterior al otro índice.
retainAll(Collection): se queda sólo con esos objetos.
set(int, Object) o setElementAt(Object, int): reemplaza el objeto
en esa posición por el objeto que se proporciona.
setSize(int): establece el tamaño del vector.
size(): número de elementos en el vector.
subList(int, int): devuelve el subvector que comienza en el índice
que se proporciona en primer lugar y termina en el elemento anterior
al del índice que se proporciona en segundo lugar.
toArray(): devuelve un array con los objetos del vector.
toString()
trimToSize(): ajusta el tamaño del vector a su número de elementos.

Ejemplo de uso de la clase Vector
// Vectores.java: prueba de la clase Vector
import java.util.Vector;
public class Vectores {
public static void main(String[] args){

Vector v = new Vector();
Persona p = new Persona(223344, 32, "Juan", "Pardo Gil");
v.add(p);
Alumno a = new Alumno(11133322, 21, "Rosa", "Garrido
Aguado", 2, p);
v.add(a);
v.add(p);
muestra(v);
int posicion = v.indexOf(p);
System.out.println("El siguiente objeto:");
System.out.print(p);
System.out.println("... se encuentra en la posición "
+ posicion + " del vector.");
. . .

posicion = v.lastIndexOf(p);
p = new Persona(7654321, 28, "Ana", "Martos Hevia");
posicion = v.indexOf(p);
v.add(p);
Vector otro = (Vector) v.clone();
muestra(otro);
v.clear();
muestra(v);
otro.remove(2);
muestra(otro);
otro.set(0, p);
muestra(otro);
System.out.println(otro); toString()
}
. . .

public static void muestra(Vector vector) {

Persona per;
System.out.println("==================================");
System.out.println();
if(vector.isEmpty()) {
System.out.println("Vector vacío");
}
else
for(int i = 0; i < vector.size(); i++) {
per = (Persona) vector.get(i);
System.out.println(per);
}
}
}

La clase ArrayList
Similar a la clase Vector.

Más moderna.
La clase Vector tiene
mayor funcionalidad,
aunque algunos de
sus métodos
son redundantes.

La clase ArrayList
add(int, Object): inserta el objeto en la posición indicada.

add(Object): añade el objeto al final de la lista.
addAll(int, Collection): añade la colección en la posición indicada.
addAll(Collection): añade los elementos de la colección al final,
en el orden que especifique el iterador de la colección.
clear(): quita todos los elementos de la lista.
clone(): devuelve un clon de la lista.
contains(Object): ¿el objeto se encuentra en la lista?
get(int): devuelve el objeto en la posición indicada.
indexOf(Object): devuelve la 1ª ocurrencia del objeto (o –1). Se usa el
método equals() de la clase del objeto para encontrarlo.
isEmpty(): ¿la lista está vacía?
lastIndexOf(Object): devuelve la última ocurrencia del objeto (o –1). Se
usa el método equals() de la clase del objeto para encontrarlo.
. . .

La clase ArrayList
remove(int): quita el objeto en esa posición.

removeRange(int, int): quita los elementos desde el índice que se
proporciona en primer lugar hasta el elemento anterior al otro índice.
set(int, Object): reemplaza el objeto en esa posición por el objeto que
se proporciona.
size(): número de elementos en la lista.
toArray(): devuelve un array con los objetos de la lista.
trimToSize(): ajusta el tamaño de la lista a su número de elementos.

Ejemplo de uso de la clase ArrayList
// Listas.java: prueba de la clase ArrayList
import java.util.ArrayList; Prácticamente basta con

reemplazar Vector por ArrayList
public class Listas {
public static void main(String[] args){

ArrayList lista = new ArrayList();
Persona p = new Persona(223344, 32, "Juan", "Pardo Gil");
lista.add(p);
Alumno a = new Alumno(11133322, 21, "Rosa", "Garrido
Aguado", 2, p);
lista.add(a);
lista.add(p);
muestra(lista);
int posicion = lista.indexOf(p);
System.out.println("... se encuentra en la posicion "
+ posicion + " de la lista.");
. . .

posicion = lista.lastIndexOf(p);
p = new Persona(7654321, 28, "Ana", "Martos Hevia");
posicion = lista.indexOf(p);
lista.add(p);
ArrayList otra = (ArrayList) lista.clone();
muestra(otra);
lista.clear();
muestra(lista);
otra.remove(2);
muestra(otra);
otra.set(0, p);
muestra(otra);
System.out.println(otra);
}
. . .

public static void muestra(ArrayList l) {

Persona per;
if(l.isEmpty()) {
System.out.println("Lista vacía");
}
else
for(int i = 0; i < l.size(); i++) {
per = (Persona) l.get(i);
System.out.println(per);
}
}
}

Otro ejemplo
// Cuenta.java
public class Cuenta {

private long numero;
private String nombre;
private double saldo;
public Cuenta (long num, String prop, double saldo) {

numero = num;
nombre = prop;
this.saldo = saldo;
}
public long numero() { return numero; }
void imprimeCuenta() {
System.out.println(numero + " " + nombre + " " + saldo);
}
}

Otro ejemplo
// Banco.java
import java.util.ArrayList;
public class Banco {

private ArrayList listaCuentas;
public Banco() {
listaCuentas = new ArrayList();
}
public void crearCuenta(){

System.out.println("Introduce el número de cuenta: ");
long c = MyInput.readLong();
System.out.println("Introduce el propietario: ");
String n = MyInput.readString();
System.out.println("Introduce el saldo inicial: ");
double s = MyInput.readDouble();
listaCuentas.add(new Cuenta(c, n, s));
}
. . .

Otro ejemplo
public void mostrarCuentas() {

for(int i = 0; i < listaCuentas.size(); i++) {
Cuenta c = (Cuenta) listaCuentas.get(i);
c.imprimeCuenta();
}
}
public void borrarCuenta() {

System.out.println("Introduce el código de la cuenta a
borrar: ");
long c = MyInput.readLong();
for(int i = 0; i < listaCuentas.size(); i++) {
Cuenta cuenta = (Cuenta) listaCuentas.get(i);
if(c == cuenta.numero()) {
listaCuentas.remove(i);
System.out.println("Cuenta borrada.");
return;
}
}
System.out.println("No existe esa cuenta.");
}
. . .

Otro ejemplo
public static void main(String[] args) {

Banco b = new Banco();
do {
System.out.println("1.Crear 2.Mostrar 3.Borrar
4.Salir");
System.out.println(">>");
int opcion = MyInput.readInt();
switch(opcion) {
case 1 : b.crearCuenta();; break;
case 2 : b.mostrarCuentas(); break;
case 3 : b.borrarCuenta();break;
case 4 : System.exit(0);
default : System.out.println("Orden desconocida.");
}
} while(true);
}
}

Tipos primitivos y la clase ArrayList
Los elementos de los ArrayList son objetos (Object).

Los enteros, por ejemplo, no son objetos.
Por tanto, un int no se puede insertar en un ArrayList.
¿Qué hacemos entonces? Utilizar la clase envoltorio Integer.
ArrayList lista = new ArrayList();

int unInt = 42;
lista.add(new Integer(unInt));
...
Integer n;
n = (Integer)lista.get(0);
int miEntero = n.intValue();
Otras clases envoltorios son Byte, Float, Double, Long y Short.

La interfaz Iterator
Los iteradores permiten recorrer colecciones sin preocuparse de

la implementación subyacente.
hasNext(): ¿hay un elemento siguiente?
next(): devuelve el siguiente elemento de la colección.
remove(): elimina el último elemento devuelto por el iterador.
public void imprime(Collection col){

Iterator it = col.iterator();
while(it.hasNext())
System.out.println(it.next());
}

Ejemplo de iterador sobre Vector
public class Basedatos {

private Vector vectorPersonas;
public Basedatos() { // Constructor
vectorPersonas = new Vector ();
}
//Añade una persona a la base de datos.
public void aniadePersona(Persona p) {
vectorPersonas.addElement(p);
}
// Muestra las personas de la base de datos.
public void listaTodo () {
for (Iterator it = vectorPersonas.iterator();
it.hasNext();) {
System.out.println(it.next());
}
}
}

Iteradores sobre distintos tipos de colecciones
import java.util.*;
public class PruebaColecciones{
public static void prueba(Collection c) {
String[] lista = {"uno", "dos" , "tres", "cuatro", "tres"};
for(int i = 0; i < lista.length; i++ )
c.add( lista[i] );
Iterator it = c.iterator(); Mismo código de iteración
while(it.hasNext())
System.out.println( it.next() );
System.out.println( "-------------------------");
}
public static void main(String args[]) {
Collection c;
c = new ArrayList(); prueba(c);
c = new LinkedList(); prueba(c);
c = new HashSet(); prueba(c);
c = new TreeSet(); prueba(c);
}
} Las cuatro veces

La interfaz ListIterator
Iteradores más potentes para implementaciones de List.

add(Object): inserta en la posición actual el elemento proporcionado.
hasNext(): ¿hay un elemento siguiente yendo hacia el final de la lista?
hasPrevious(): ¿hay un elemento anterior yendo hacia el principio?
next(): devuelve el siguiente elemento de la lista.
nextIndex(): devuelve el índice del siguiente elemento de la lista.
previous(): devuelve el elemento anterior de la lista.
previousIndex(): devuelve el índice del elemento anterior de la lista.
remove(): elimina el último elemento devuelto por next() o previous().
set(Object): reemplaza el último elemento devuelto por next() o
previous().

Excepciones
Las excepciones son la manera que ofrece Java de manejar

los errores en tiempo de ejecución.
Muchos lenguajes imperativos simplemente detienen la ejecución
de programa cuando surge un error.
Las excepciones nos permiten escribir código que nos permita
manejar el error y continuar (si lo estimamos conveniente)
con la ejecución del programa.
El error de ejecución más clásico en Java es el de

desbordamiento, el intento de acceso a una posición de
un vector que no existe. Veamos un ejemplo...

Excepciones
public class Desbordamiento {

String mensajes[] = {"Primero","Segundo","Tercero" };
for(int i = 0; i <= 3; i++)
System.out.println(mensajes[i]);
}
}
Este programa tendrá un serio problema cuando intente acceder
a mensajes[3], pues no existe dicho valor.
Al ejecutarlo mostrará lo siguiente:
Primero Segundo Tercero Exception in thread "main"

java.lang.ArrayIndexOutOfBoundsException at
Desbordamiento.main(Desbordamiento.java, Compiled Code)

Jerarquía de excepciones
Throwable
Error Exception
RuntimeException IOException

Clases de excepciones
Throwable
Superclase que engloba a todas las excepciones
Error
Representa los errores graves causados por el sistema (JVM, ...);
no son tratados por los programas.
Exception
Define las excepciones que los programas deberían tratar
(IOException, ArithmeticException, etcétera).

try ... catch ... finally
El ejemplo del desbordamiento detecta un error de ejecución

(lanza una excepción) al intentar acceder a la posición inexistente.
Cuando se detecta el error, por defecto se interrumpe la ejecución.
Pero podemos evitarlo.
La estructura try-catch-finally nos permitirá capturar
excepciones, es decir, reaccionar a un error de ejecución.
De este modo podremos imprimir mensajes de error "a la medida"
y continuar con la ejecución del programa si consideramos que el
error no es demasiado grave.
Para ver cómo funcionan vamos a modificar el ejemplo anterior,
pero asegurándonos ahora de que capturamos las excepciones.

try ... catch
try {
// Código que puede hacer que se eleve la excepción
}
catch(TipoExcepcion e) {
// Gestor de la excepción
}
El comportamiento de Java es el siguiente:

Si en la ejecución del código dentro del bloque try se eleva
una excepción de tipo TipoExcepcion (o descendiente de éste),
Java omite la ejecución del resto del código en el bloque try y
ejecuta el código situado en el bloque catch (gestor).

public class EjemploCatch {

String mensajes[] = {"Primero", "Segundo", "Tercero" };
try {
for(int i = 0; i <= 3; i++)
System.out.println(mensajes[i]);
}
catch ( ArrayIndexOutOfBoundsException e ) {
System.out.println("El asunto se nos ha desbordado");
}
finally {
System.out.println("Ha finalizado la ejecución");
}
}
}
Dentro del bloque de la sección try colocamos el código normal.

Después de la sección try debemos colocar al menos una sección
catch o una finally, pudiendo tener ambos e incluso más de una
sección catch.

try
El bloque de código donde se prevé que se eleve una excepción. Al
encerrar el código en un bloque try es como si dijéramos: "Prueba a
usar estas instrucciones y mira a ver si se produce
alguna excepción". El bloque try tiene que ir seguido, al menos, por
una cláusula catch o una cláusula finally.
catch
El código que se ejecuta cuando se eleva la excepción. Controla
cualquier excepción que cuadre con su argumento. Se pueden
colocar varios catch sucesivos, cada uno controlando un tipo
de excepción diferente.
finally
Bloque que se ejecuta siempre, haya o no excepción. Existe cierta
controversia sobre su utilidad, pero podría servir, por ejemplo, para
hacer un seguimiento de lo que está pasando,
ya que al ejecutarse siempre puede dejar grabado un registro (log)
de las excepciones ocurridas y su recuperación o no.

La clase Exception
Cuando se eleva una excepción, lo que se hace es activar un

ejemplar de Exception o de alguna de sus subclases.
Normalmente las clases derivadas nos permiten distinguir
entre los distintos tipos de excepciones.
En el programa anterior, por ejemplo, en el bloque catch se
captura una excepción del tipo ArrayIndexOutOfBoundsException,
ignorando cualquier otro tipo de excepción.
Esta clase tiene dos constructores y dos métodos destacables:
Exception(): crea una excepción si ningún mensaje específico.

Exception(String): crea una excepción con un mensaje que
detalla el tipo de excepción.
String getMessage(): el mensaje detallado, si existe (o null).
void printStackTrace(): muestra una traza que permite ver
donde se generó el error (muy útil para depurar).

Excepciones predefinidas

Captura de excepciones
A catch le sigue, entre paréntesis, la declaración de una

excepción. Es decir, el nombre de una clase derivada de
Exception (o la propia Exception) seguido del nombre de
una variable. Si se lanza una excepción que es la que deseamos
capturar (o una derivada de la misma) se ejecutará el código
que contiene el bloque. Así, por ejemplo:
catch(Exception e) { ... }
se ejecutará siempre que se produzca una excepción del tipo
que sea, ya que todas las excepciones se derivan de Exception.
No es recomendable utilizar algo así, ya que estaremos
capturando cualquier tipo de excepción sin saber si eso afectará a
la ejecución del programa o no.

Captura de excepciones
Se pueden colocar varios bloques catch. Si es así, se comprobará,

en el mismo orden en que se encuentren esos bloques catch,
si la excepción elevada es la que se trata en el bloque catch;
si no, se pasa a comprobar el siguiente.
Eso sí, sólo se ejecuta un bloque catch. En cuanto se captura
la excepción se deja de comprobar el resto de los bloques.
Por esto, lo siguiente:
catch(Exception e) {
...
}
catch(DerivadaDeException e) {
...
}
no sería correcto, ya que el segundo catch no se ejecutará nunca.

Ejemplo: Sin try-catch
public class Excepcion1 {

public static void main(String args[ ]){
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
}
}
Se produce el error
y se interrumpe ...
a = 0
java.lang.ArithmeticException: / by zero
at Excepcion1.main(Excepcion1.java:6)
Exception in thread "main" Process Exit...

Ejemplo: Con try-catch

public static void main(String args[ ]){
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a; Se produce el error
}
catch (ArithmeticException e) { Se captura la excepción
System.out.println("No dividas por 0 (" + e + ")");
}
System.out.println("La ejecución sigue ...");
} Y sigue la ejecución fuera
}
a = 0
No dividas por 0 (java.lang.ArithmeticException: / by zero)
La ejecución sigue ...

Lanzamiento de excepciones explícito
Los métodos en los que se puede producir un error deben avisar al

compilador de que éste se puede producir. Para ello utilizan
la cláusula throws.
Por ejemplo, un método de lectura de un archivo podría elevar
una excepción de tipo IOException:
public String leer(FileInputStream archivo) throws IOException
{
// ...

Se pueden elevar varias excepciones en un mismo método:

public Image cargar(String s) throws EOFException,
MalformedURLException
{
// ...

Lanzamiento de excepciones explícito
Las excepciones se lanzan con la instrucción throw.

Por ejemplo, cuando estamos implementando un método que
efectúa una lectura de un archivo de datos, y se llega
inesperadamente a su final, podemos lanzar una EOFException:
public String leerDatos(DataInput archivo)
throws EOFException {
// ...
while( /* ... */ ) {
if(ch == -1) { // Fin de archivo
if(n < longitud)
throw new EOFException();
}
}
return s;
}

Excepciones a medida
El programador puede crear sus propias excepciones, si resulta

que ninguna de las predefinidas es adecuada. Para ello, se define
una clase que desciende de Exception (o de la clase deseada).
Se suele agregar un constructor con el mensaje de la excepción,
que se inicializa en el constructor llamando al de la clase padre.
Además, toda excepción tiene un método getMessage() que
devuelve un String con el mensaje.
// Define una clase de excepción propia

public class MiExcepcion extends Exception {
public MiExcepcion(){
super("error malísimo...");
}
}

Excepciones a medida
public class MiExcepcion extends Exception {. . .}

public class UnaClase {
public void metodo() throws MiExcepcion {
System.out.println("Lanzo mi excepción desde aquí.");
throw new MiExcepcion();
}
}
UnaClase c = new UnaClase();
try { c.metodo(); }
// Invoco al método que eleva la excepción
catch(MiExcepcion e) {
System.out.println("La pillé! " + e);
}
System.out.println("... y sigo.");
}
} Lanzo mi excepción desde aquí.
La pillé! MiExcepcion: error malísimo...
... y sigo.

Un ejemplo
class Limites extends Exception {}

class demasiadoCalor extends Limites {}
class demasiadoFrio extends Limites {}
class demasiadoRapido extends Limites {}
class demasiadoCansado extends Limites {}
. . .
try {
if(temp > 40 ) throw new demasiadoCalor();
if(dormir < 8 ) throw new demasiado Cansado();
}
catch(Limites lim) {
if(lim instanceof demasiadoCalor ) {
System.out.println("Capturada excesivo calor!");
return;
}
if( lim instanceof demasiadoCansado ) {
System.out.println("Capturada excesivo cansancio!");
return;
}
}
finally System.out.println("En la cláusula finally" ); ...

Otro ejemplo
class NoHayDineroException extends Exception {

private int dinero;
public NoHayDineroException(int n) {
super();
dinero = n;
}
public int getDinero() { return dinero; }
}
class Cuenta {
private int saldo;
public Cuenta() { saldo = 0; }
public Cuenta(int n) { saldo = n; }
public void meterDinero(int n) { saldo += n; }
public void sacarDinero(int n) throws NoHayDineroException {
if(saldo > n) saldo -= n;
else throw new NoHayDineroException(n - saldo);
}
}

Otro ejemplo
class Test {
public static void main(String a[]) {
Cuenta c = new Cuenta(5000);
try {
c.sacarDinero(60000);
}
catch(NoHayDineroException e) {
System.out.println("Te has pasado en " + e.getDinero());
}
}
}

Tema 07

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 07

Cargado por

Copyright:

Formatos disponibles

FUNDACIÓN GENERAL

Curso para IZAR

El lenguaje Java — Tema 7 — Colecciones y excepciones

Manejo de grupos de datos  colecciones

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 2

Como las interfaces y las clases están relacionadas y colaboran

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 3

Interfaces para manejar colecciones de datos:

Set List SortedMap

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 4

 Colección inmodificable: que no soporta operaciones

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 5

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 6

add(Object): añade el objeto en la colección (opcional).

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 7

Colecciones ordenadas (secuencias) en las que cada elemento

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 8

Iterator iterator(): devuelve un iterador para la colección.

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 9

Pares (clave, valor). No puede haber claves duplicadas

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 10

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 11

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 12

Vectores de objetos que pueden

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 13

add(int, Object): inserta el objeto en la posición indicada.

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 14

indexOf(Object): devuelve la 1ª ocurrencia del objeto (o –1). Se usa el

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 15

removeRange(int, int): quita los elementos desde el índice que se

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 16

// Vectores.java: prueba de la clase Vector

public class Vectores {

public static void main(String[] args){

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 17

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 18

public static void muestra(Vector vector) {

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 19

Similar a la clase Vector.

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 20

add(int, Object): inserta el objeto en la posición indicada.

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 21

remove(int): quita el objeto en esa posición.

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 22

// Listas.java: prueba de la clase ArrayList

import java.util.ArrayList; Prácticamente basta con

public static void main(String[] args){

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 23

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 24

public static void muestra(ArrayList l) {

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 25

public class Cuenta {

public Cuenta (long num, String prop, double saldo) {

public long numero() { return numero; }

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 26

public class Banco {

public void crearCuenta(){

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 27

public void mostrarCuentas() {

public void borrarCuenta() {

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 28

public static void main(String[] args) {

Curso Java para IZAR Tema 7 – Colecciones y excepciones - 29

Los elementos de los ArrayList son objetos (Object).