Suplemento Nº 6 de New 2 Java (Dic-2001)
Lenguaje Java Básico
Excepciones y Como Manejarlas
Si miras a la lista de palabras clave del lenguaje Java, podrías pensar en algún deporte con palabras como throw, throws, y catch. Añádele try y finally, y tienes todo lo necesario para que la máquina virtual Java (JVM) señale errores o excepciones en tus programas. Esto también es conocido como "manejo de excepciones"
Definir la terminología:
- Una excepción es una señal a la máquina virtual de que algo ha ido mal..
- Cuando ocurre una excepción, es "lanzada", interrumpiendo la secuencia normal de operaciones.
- Una excepcion lanzada puede ser capturada, transfiriendo el control a nuevo punto del programa.
Estas son las báses del manejo de excepciones, proporcionado poniendo las palabras claves apropiadas juntas. Y a hacer esto es a lo que se dedica el resto de este artículo.
El manejo de excepciones se hace con un bloque try-catch. El código que podría lanzar una excepción se sitúa dentro del bloque try. Proporcionamos bloques catch por cada tipo de excepción en el que estemos interesados y que sea requerido manejarlo basado en los métodos usados dentro de la clausula try. El marco de trabajo de la síntaxis para dicho bloque es el sigiente:
try {
// code which might throw exceptions
} catch (ExceptionType1 exceptionVar) {
// code to handle ExceptionType1
// exceptionVar is local to catch block
} catch (ExceptionType2 exceptionVar) {
// code to handle ExceptionType2
// exceptionVar is local to catch block
}
Cuando haya presente varias clausulas catch, el control se transfiere al primer tipo de excepción que corresponda con la excepción lanzada.
Por ejemplo, si nuestros tipos de excepción son FileNotFoundException y IOException, en este orden, y se lanza una excepción FileNotFoundException, el único código de manejo de excepción que se ejecutará será el del tipo FileNotFoundException. Sin embargo, si se lanzá una EOFException, entonces se ejecutará el código del tipo IOException, ya que EOFException es una subclase de IOException.
Aquí tenemos un ejemplo que usa tipos de excepciones especificas, que es el marco de trabajo para leer un fichero:
try {
// Open file.
FileInputStream fis = new FileInputStream(filename);
// Read from fis.
...
// Close file.
fis.close();
} catch (FileNotFoundException exception) {
System.err.println("Error opening file: " +
filename);
} catch (IOException exception) {
System.err.println("Error accessing file: " +
filename);
}
Hay un pequeño problema con el código de arriba. Si se lanza una excepción mientras se está leyendo el fichero, el FileInputStream no se cierra inmediatamente. Eventualmente se cerrará cuando la variable sea recogida por el recolector de basura, pero es mejor liberar recursos como los ficheros tan pronto como sea posible y no esperar hasta que el recolector de basura decida liberar espacio.
Resolver este problema requiere el uso de la palabra clave finally. Esta clausula es un bloque opcional de un bloque try-catch que siempre se ejecuta, tanto si se lanza una excepción como si no. Para solucionar nuestro problema movemos la llamada fis.close dentro del nuevo bloque finally:
// Declare variable so that it is accessible
// within finally block.
FileInputStream fis = null;
try {
// Open file.
fis = new FileInputStream(filename);
// read from fis
...
} catch (FileNotFoundException exception) {
System.err.println("Error opening file: " +
filename);
} catch (IOException exception) {
System.err.println("Error accessing file: " +
filename);
} finally {
if (fis != null) {
try {
// Close file.
fis.close();
} catch (IOException ignored) {
}
}
}
Observa que la llamada a fis.close también está dentro de un bloque try-catch. Esto es porque close puede lanzar una excepción. En este caso particular, si close falla, no hay forma de recuperarlo, por eso la excepción es simplemente ignorada.
Hasta que aprendas más sobre las librerías, el compilador te dirá cuándo no has capturado una excepción. Entonces sólo tienes que volver atrás y poner el bloque de código apropiado dentro de un bloque try-catch. Recompilar y ya estará todo correcto.
Entender la Librería de Clases Java
FileInputStream y FileOutputStream
El API Java proporciona varias clases que nos permiten crear aplicaciones que leen y escribien en ficheros. Dos de las más populares son FileInputStream y FileOutputStream. Estas crean streams de bytes enlazados a los ficheros. Tanto FileInputStream como FileOutputStream se encuentran en el paquete java.io, y son subclases de InputStream y OutputStream respectivamente. Heredan método útiles:
- read (de InputStream). Hay tres versiones de este método, todas las cuales leen bytes desde el stream de entrada.
- write (de OutputStream). Hay tres versiones de este método, todas las cuales escriben bytes hacia el stream de salida.
- flush (de OutputStream). Este método fuerza los datos contenidos en el buffer a que sean escritos en el stream de salida.
- close (de OutputStream y InputStream). Este método cierra los streams de salida invocados y libera cualquier recurso asignado a ellos.
Leer y escribir ficheros toma cinco pasos:
- Importar el paquete java.io.
- Crear un objeto stream de entrada.
- Crear un objeto stream de salida.
- Llamar a los métodos para leer y escribir.
- Cerar los objetos stream con el método close.
Para crear un objeto stream, llamamos a uno de los siguientes constructores:
FileInputStream:
FileInputStream (String filename)
FileInputStream (File file)
FileInputStream (FileDescriptor desc)
FileOutputStream:
FileOutputStream (String filename)
FileOutputStream (String filename, boolean append)
FileOutputStream (File file)
FileOutputStream (FileDescriptor desc)
Para leer un fichero, creamos un objeto stream del tipo FileInputStream, luego llamamos al método read.
Para escribir en un fichero, creamos un objeto stream del tipo FileOutputStream, luego llamamos al método write.
El siguiente ejemplo lo demuestra:
import java.io.*;
public class FileReaderWriterExample
{
public static void main(String[] args)
throws IOException
{
// Create input stream object.
FileInputStream fis =
new FileInputStream("Data");
// Create output stream object.
FileOutputStream fout =
new FileOutputStream("Data2");
// Set variable for looping through bytes.
int c;
// Loop to read and write bytes.
while ((c = fis.read()) != -1)
fout.write(c);
// Close output and input resources.
fis.close();
fout.close();
}
}
Este ejemplo lee y escribie en ficheros, pero no tiene en cuenta los errores que ocurren frecuentemente cuando se trata con ficheros. como ficheros que no existen, ficheros que están protegidos contra escritura, etc. Para tratar con los posibles errores, encerramos el código en bloques try-catch, y lanzamos excepciones cuando son necesarias, como se describió en la sección anterior.
Además de las clases FileInputStream y FileOutputStream, el paquete java.io tiene muchas otras clases que podemos usar para leer y escribir ficheros. Lee la documentación del paquete I/O, y experimenta, usando las diferentes clases. También puedes estudiar el árbol de clases stream. Hay disponinles muchos métodos útiles heredados, dependiendo de las clases que elijas usar en tu aplicación.
Programa Ejercicio
Usa lo que has aprendido sobre el manejo de excepciones y leer y escribir ficheros para crear un programa llamado CopyFile:
Crea un programa que copie un fichero y lo escriba en otro.
- Debería aceptar dos argumentos:
- El primer argumento es el nombre del fichero de entrada.
- El segundo argumento es el nombre del fichero de salida.
- Encierra el código en blqoues try-catch.
- Captura las excepciones específicas lanzadas.
- Muestra los mensajes de error apropiados.
Un poco de Java
Java 2 Platform, Standard Edition (J2SE) versus Java 2 Platform, Enterprise Edition (J2EE) ¿Cuál es la Diferencia?
Hay muchas tecnologías Java, y entender las diferencias entre las varias plataformas, como J2SE y J2EE, puede ser confuso. ¿Cuál de las dos necesitas, Cómo solaparlas, Necesitas las dos? Las respuestas a estas cuestiones tiene que ver con el tipo de proyecto en el que estés trabajando.
La plataforma J2SE incluye el compilador y otras herramientas, la JVM y las clases principales. Las clases principales proporcionan a los programadores la capcidad de crear applets y aplicaciones simples y complejos en las que se podria incluir lo siguiente:
- Interfaces Gráficos de Usuario proporcionados por las librerías AWT y Swing.
- Funcionalidades de I/O básica, imprimir en la pantalla, un GUI o a ficheros lo propociona el paquete java.io.
- Conectividad a bases de datos. Este se refiere a la tecnología JDBC y a las clases incluidas en el paquete java.sql.
- El manejo de caracteres internacionalizados en J2SE 1.4 está basado en la versión 3.0 del estándard Unicode.
- Procesar XML. Esta es una nueva característica del J2SE 1.4.
- Además, J2SE proporciona clases que hace posible trabajar con redes, crear beans, trabajar con fechas y funciones matemáticas, proporcionar seguridad adicional, usar colecciones, y mucho más.
La plataforma J2EE trabaja con J2SE, extendiendo esas tecnologías para proporcionar los siguientes servicios:
- Uso de Servlets Java
- Páginas HTML dinámicas a través de la tecnología JavaServer Pages.
- Componentes JavaBeans Enterprise.
- Conectividad a bases de datos. Este se refiere a la tecnología JDBC y a las clases incluidas en el paquete java.sql.
- Tecnologia XML.
- Herramientas de despliegue.
Para configurar la plataforma J2EE, debes tener instalado J2SE. J2EE define el estándard para desarrollar aplicaciones empresariales multi-capa, y asegura la portabiliad de las aplicaciones entre un ámplio rango de sistemas empresariales existentes capaces de soportar J2EE.
Por otro lado, puedes usar algunas de las tecnologías anteriores sin instalar la plataforma J2EE. Por ejemplo, puedes hacer uso de los servlets Java instalando J2SE y un motor servlets como Tomcat. Además, Tomcat, también procesa JavaServer Pages.
Para aplicaciones independientes, sólo necesitas:
Para crear aplicaciones Web, usando servlets o páginas JSP, necesitas instalar:
- La plataforma J2SE.
- Un motor de servlets como Tomcat.
Para construir aplicaciones empresariales que requieran el uso de EJBs, servelts, páginas JSP, XML, y conectividad con bases de datos, necesitas:
- La plataforma J2SE.
- La plataforma J2EE, que incluye la base de datos Cloudscape y el motor para servlets y páginas JSP, y contenedores para EJBs.
Además de estas dos plataformas Java, hay otras tecnologías Java. Puedes descargar plataformas Java adicionales como Java 2 Platform, Micro Edition (J2ME) para funcionalidad sin cables, o software opcional como Java Web Start, que hace posible lanzar aplicaciones desde una página Web.
En suma, J2SE proporciona muchas funcionalidades para applets y aplicaciones, mientras que J2EE amplía la plataforma para incluir servicios web empresariales, herramientas de despliegue y más.
Solución al Programa de Ejercicio
Esta es una posible solución al programa del ejercicio:
import java.io.*;
public class CopyFile {
public static void main(String args[]) {
// Check for two command line arguments
if (args.length != 2) {
System.out.println(
"Improper arguments use:" +
" java CopyFile infile outfile");
System.exit(-1);
}
// Get infile argument
String infile = args[0];
// Get outfile argument
String outfile = args[1];
// Create variables for in/out streams
FileInputStream fis = null;
FileOutputStream fos = null;
try {
// Create in stream
fis = new FileInputStream(infile);
// Create out stream
fos = new FileOutputStream(outfile);
// Declare variable for each byte read
int ch;
// Read byte til end of file
while ((ch = fis.read()) != -1) {
// Put bytes read into out stream
fos.write(ch);
}
// Catch FileNotFoundException
} catch (FileNotFoundException e) {
System.err.println("File not found: " + e);
// Catch IOException
} catch (IOException e) {
System.err.println("I/O problems: " + e);
// Close files
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException ignored) {
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException ignored) {
}
}
}
}
}
Descargar la Plataforma Java 2
Para la mayoría del desarrollo Java, necesitas las librerías de clases Java, el compilador, las herramientas, y el entorno de ejecución proporcionado por el kit de desarrollo de Java 2, Standard Edition.
Tutoriales
