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:
- La plataforma J2SE.
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.
- Descarga el Paquete de Software J2SE 1.4.
- A�ade a tu Bookmark las Especificaciones del API