Manejo de Excepciones.

Las excepciones son la manera que ofrece Java de manejar los errores en tiempo de ejecucin. Muchos lenguajes imperativos, cuando tenan un error de este clase lo que hacan era detener la ejecucin del programa. Las excepciones nos permiten escribir cdigo que nos permita manejar ese error y continuar (si lo estimamos conveniente) con la ejecucin del programa. El error en ejecucin ms clsico en Java es el de desbordamiento. Es decir, el intento de acceso a una posicin de un vector que no existe. Por ejemplo:

Desbordamiento.java public class Desbordamiento { static String mensajes[] = {"Primero", "Segundo", "Tercero" }; public static void main(String[] args) { for (int i=0; i<=3; i++) System.out.println(mensajes[i]); System.out.println("Ha finalizado la ejecucin"); } }

Este programa tendr un serio problema cuando intente acceder a mensajes[3], pues no existe dicho valor. Al ejecutarlo nos dir lo siguiente (o algo parecido):

Primero Segundo Tercero Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException at Desbordamiento.main(Desbordamiento.java, Compiled Code)

Nos da un error de ejecucin (en esta terminologa se dira que se lanz una excepcin) al intentar acceder a dicho valor inexistente. Vemos que, por ahora, el comportamiento de nuestro cdigo es el mismo que en los lenguajes imperativos. Cuando encuentra el error, se para la ejecucin. Ahora veremos como evitar esto.

try...catch...finally

Existe una estructura que nos permitir capturar excepciones, es decir, reaccionar a un error de ejecucin. De este modo podremos imprimir mensajes de error "a la medida" y continuar con la ejecucin del programa si consideramos que el error no es demasiado grave. Para ver como funcionan vamos a modificar el ejemplo anterior, pero asegurandonos ahora de que capturamos las excepciones:

NuestroPrimerCatch.java public class NuestroPrimerCatch { static String mensajes[] = {"Primero", "Segundo", "Tercero" }; public static void main(String[] args) { try { for (int i=0; i&lt;=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 ejecucin"); }

} }

Dentro del bloque que sigue a try colocamos el cdigo a ejecutar. Es como si dijeramos que vamos a intentar ejecutar dicho cdigo a ver qu pasa. Despus de try deberemos colocar al menos un bloque catch o un bloque finally, pudiendo tener ambos e incluso ms de un bloque catch.

En el bloque finally ponemos el cdigo que se ejecutar siempre, tanto si se lanza la excepcin como si no. Su utilidad no es mucha, ya que si se permite continuar con la ejecucin del programa basta con poner el cdigo despus del bloque try...catch. En nuestro ejemplo podramos haber puesto lo siguiente:

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"); } System.out.println("Ha finalizado la ejecucin");

Y habra funcionado exactamente igual. La miga est en los bloques catch.

Clase Exception

Cuando se lanza una excepcin, en nuestro mundo orientado objetos lo que se hace es lanzar una instancia de Exception o de una clase derivada de l. Normalmente las clases derivadas no aaden mucha funcionalidad (muchas veces

ninguna en absoluto), pero al ser distintas nos permiten distinguir entre los distintos tipos de excepciones.

En el programa anterior, por ejemplo, en el bloque catch capturbamos una excepcin del tipo ArrayIndexOutOfBoundsException, ignorando cualquier otro tipo de excepcin.

Esta clase tiene como cositas interesantes dos constructores y dos mtodos (tiene ms mtodos pero slo vamos a ver stos):

Exception e = new Exception() Crea una excepcin si ningn mensaje especfico. Exception e = new Exception ( String ) Crea una excepcin con un mensaje que detalla el tipo de excepcin. String e.getMessage() Devuelve el mensaje detallado si existe o null en caso contrario. void e.printStackTrace() Escribe por la salida de error estndar una traza que nos permitir localizar donde se gener el error. Es muy til para depurar, pero no es conveniente que lo usuarios finales vean estas cosas. Capturar excepciones

Ahora sabemos lo suficiente como para entender cmo funcionan los catch. Entre parntesis, cual parmetro se pone la declaracin de una excepcin, es decir, el nombre de una clase derivada de Exception (o la misma Exception) seguido por el nombre de la variable. Si se lanza una excepcin que es la que deseamos

capturar o una derivada de la misma se ejecutar el cdigo que contiene el bloque. As, por ejemplo:

catch (Exception e) { ... } Se ejecutar siempre que se produzca una excepcin del tipo que sea, ya que todas las excepciones se derivan de Exception. No es recomendable utilizar algo as ya que estamos capturando cualquier tipo de excepciones sin saber si eso afectar a la ejecucin del programa o no.

Se pueden colocar varios bloques catch. En ese caso, se comprobar en orden si la excepcin lanzada es la que deseamos capturar y si no pasa a comprobar la siguiente. Eso s, slo se ejecuta un bloque catch. En cuanto captura la excepcin deja de comprobar los dems bloques. Por eso, lo siguiente: catch (Exception e) { ... } catch (DerivadaDeException e) { ... } Regresar.

Anterior - ndice - Siguiente

II.8. GESTIN DE EXCEPCIONES Y ERRORES A. Introduccin El control de flujo en un programa Java puede hacerse mediante las ya conocidas sentencias estructuradas (if, while, return). Pero Java va mucho ms all, mediante una tcnica de programacin denominadagestin de excepciones. Mediante las excepciones se podr evitar repetir continuamente cdigo, en busca de un posible error, y avisar a otros objetos de una condicin anormal de ejecucin durante un programa. Durante este captulo estudiaremos la gestin de excepciones y errores, sin pretender profundizar demasiado, pero s fijando la base conceptual de lo que este modo de programacin supone. Mediante la gestin de excepciones se prescindir de sentencias de control de errores del tipo:
if ( error == true )

return ERROR;

B. Tipos de excepciones Existen varios tipos fundamentales de excepciones:

Error: Excepciones que indican problemas muy graves, que suelen ser no recuperables y no deben casi nunca ser capturadas. Exception: Excepciones no definitivas, pero que se detectan fuera del tiempo de ejecucin.

RuntimeException: Excepciones que se dan durante la ejecucin del programa.

Imagen 5: Herencia de excepciones Java Todas las excepciones tienen como clase base la clase Throwable, que est incluida en el paquete java.lang, y sus mtodos son:

Trowable( String mensaje ); Constructor. La cadena es opcional Throwable fillInStackTrace(); Llena la pila de traza de ejecucin. String getLocalizedMessage(); Crea una descripcin local de este objeto. String getMessage(); Devuelve la cadena de error del objeto. void printStackTrace( PrintStream_o_PrintWriter s ); Imprime este objeto y su traza en el flujo del parmetro s, o en la salida estndar (por defecto). String toString; Devuelve una breve descripcin del objeto.

C. Funcionamiento
a.) Introduccin

Para que el sistema de gestin de excepciones funcione, se ha de trabajar en dos partes de los programas:

Definir qu partes de los programas crean una excepcin y bajo qu condiciones. Para ello se utilizan las palabras reservadas throw y throws. Comprobar en ciertas partes de los programas si una excepcin se ha producido, y actuar en consecuencia. Para ello se utilizan las palabras reservadas try, catch y finally.

b.) Manejo de excepciones: try - catch - finally

Cuando el programador va a ejecutar un trozo de cdigo que pueda provocar una excepcin (por ejemplo, una lectura en un fichero), debe incluir este fragmento de cdigo dentro de un bloque try:

try {

// Cdigo posiblemente problemtico

Pero lo importante es cmo controlar qu hacer con la posible excepcin que se cree. Para ello se utilizan las clausulas catch, en las que se especifica que accin realizar:
try {

// Cdigo posiblemente problemtico

} catch( tipo_de_excepcion e) {

// Cdigo para solucionar la excepcin e

} catch( tipo_de_excepcion_mas_general e) {

// Cdigo para solucionar la excepcin e

En el ejemplo se observa que se pueden anidar sentencias catch, pero conviene hacerlo indicando en ltimo lugar las excepciones ms generales (es decir, que se

encuentren ms arriba en el rbol de herencia de excepciones), porque el intrprete Java ejecutar aquel bloque de cdigo catch cuyo parmetro sea del tipo de una excepcin lanzada. Si por ejemplo se intentase capturar primero una excepcin Throwable, nunca llegaramos a gestionar una excepcin Runtime, puesto que cualquier clase hija de Runtime es tambin hija de Throwable, por herencia. Si no se ha lanzado ninguna excepcin el cdigo contina sin ejecutar ninguna sentencia catch. Pero, y si quiero realizar una accin comn a todas las opciones?. Para insertar fragmentos de cdigo que se ejecuten tras la gestin de las excepciones. Este cdigo se ejecutar tanto si se ha tratado una excepcin (catch) como sino. Este tipo de cdigo se inserta en una sentencia finally, que ser ejecutada tras el bloque try o catch:
try {

} catch( Exception e ) {

} finally {

// Se ejecutara tras try o catch

c.) Lanzamiento de excepciones: throw - throws

Muchas veces el programador dentro de un determinado mtodo deber comprobar si alguna condicin de excepcin se cumple, y si es as lanzarla. Para ello se utilizan las palabras reservadas throw y throws. Por una parte la excepcin se lanza mediante la sentencia throw:

if ( condicion_de_excepcion == true )

throw new miExcepcion();

Se puede observar que hemos creado un objeto de la clase miExcepcion, puesto que las excepciones son objetos y por tanto debern ser instanciadas antes de ser lanzadas. Aquellos mtodos que pueden lanzar excepciones, deben cules son esas excepciones en su declaracin. Para ello se utiliza la sentencia throws:
tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 {

// Codigo capaz de lanzar excepciones miExcep1 y miExcep2

Se puede observar que cuando se pueden lanzar en el mtodo ms de una excepcin se deben indicar en su declaracin separadas por comas.
d.) Ejemplo de gestin de excepciones

Ahora que ya sabemos cmo funciona este sistema, conviene ver al menos un pequeo ejemplo, que ilustre al lector en el uso de las excepciones:
// Creo una excepcin personalizada

class MiExcepcion extends Exception {

MiExcepcion(){

super(); // constructor por defecto de Exception

MiExcepcion( String cadena ){

super( cadena ); // constructor param. de Exception

// Esta clase lanzar la excepcin

class Lanzadora {

void lanzaSiNegativo( int param ) throws MiExcepcion {

if ( param < 0 )

throw new MiExcepcion( "Numero negativo" );

class Excepciones {

public static void main( String[] args ) {

// Para leer un fichero

Lanzadora lanza = new Lanzadora();

FileInputStream entrada = null;

int leo;

try {

entrada = new FileInputStream( "fich.txt" );

while ( ( leo = entrada.read() ) != -1 )

lanza.lanzaSiNegativo( leo );

entrada.close();

System.out.println( "Todo fue bien" );

} catch ( MiExcepcion e ){ // Personalizada

System.out.println( "Excepcion: " + e.getMessage() );

} catch ( IOException e ){ // Estndar

System.out.println( "Excepcion: " + e.getMessage() );

} finally {

if ( entrada != null )

try {

entrada.close(); // Siempre queda cerrado

} catch ( Exception e ) {

System.out.println( "Excepcion: " + e.getMessage() );

System.out.println( "Fichero cerrado." );

class Excepciones {

public static void main( String[] args ) {

// Para leer un fichero

FileInputStream entrada = null;

Lanzadora lanza = new Lanzadora();

int leo;

try {

entrada = new FileInputStream("fich.txt");

while ( ( leo = entrada.read() ) != -1 )

lanza.lanzaSiNegativo( leo );

System.out.println( "Todo fue bien" );

} catch ( MiExcepcion e ){ // Personalizada

System.out.println( "Excepcion: " + e.getMessage() );

} catch ( IOException e ){ // Estndar

System.out.println( "Excepcion: " + e.getMessage() );

} finally {

entrada.close(); // As el fichero siempre queda cerrado

System.out.println( "Fichero cerrado" );

Este programa lee un fichero (fichero.txt), y lee su contenido en forma de nmeros. Si alguno de los nmeros ledos es negativo, lanza una excepcin MiExcepcion, Adems gestiona la excepcin IOException, que es una excepcin de las que Java incluye y que se lanza si hay algn problema en una operacin de entrada/salida. Ambas excepciones son gestionadas, imprimiendo su contenido (cadena de error) por pantalla. La salida de este programa, suponiendo un nmero negativo sera: Excepcion: Numero negativo Fichero cerrado En el caso de que no hubiera ningn nmero negativo sera: Todo fue bien Fichero cerrado En el caso de que se produjese un error de E/S, al leer el primer nmero, sera: Excepcion: java.io.IOException Fichero cerrado
e.) Conclusiones

En cualquier caso se recomienda al programador no abusar de este sistema como control de flujos simples, sino utilizarlo slo en aquellos estados del programa que realmente creen un problema de ejecucin que pueda ser letal para el programa. Para ms informacin sobre las excepciones Java, vanse [Zolli, 1997] y [Naughton, 1996].

D. Excepciones que incorpora Java 1.2

a.) Clases de Error

LinkageError: Una clase no satisface la dependencia que tiene respecto a otra.

ClassCircularityError: Se detect una herencia circular entre clases. ClassFormatError: Una clase cargada no ha sido incompletamente descrita. o UnsupportedClassVersionError: La versin de una clase no es correcta. ExceptionInInitializerError: Error al iniciar un miembro static. IncompatibleClassChangeError: En una clase, su interfaz no es igual al declarado o AbstractMethodError: Se ha invocado un mtodo abstracto. o IllegalAccessError: La aplicacin intent acceder a algn miembro no visible. o InstantiationError: Se intent instanciar una clase abstracta o interfaz. o NoSuchFieldError: No se encontr determinado atributo. o NoSuchMethodError: No se encontr determinado mtodo. NoClassDefFoundError: No se encontr una clase cuando se necesitaba. UnsatisfiedLinkError: Se encontr un enlace insatisfecho en un mtodo nativo. VerifyError: Se ha producido un error de verificacin al cargar una clase.

ThreadDeath: Se ha lanzado en el thread vctima tras llamar a stop(). VirtualMachineError: La mquina virtual se ha averiado o quedado sin recursos.

InternalError: Error interno en tiempo de ejecucin. OutOfMemoryError: El lector ha agotado la memoria. StackOverflowError: Desbordamiento de pila. Recursin infinita?. UnknownError: Grave error desconocido.

b.) Clases de Exception

CloneNotSupportedException: No se pudo copiar un objeto mediante clone(). IllegalAccessException: Algn mtodo invocado es no visible. InstantiationException: Se ha intentado instanciar una interfaz o una clase abstracta.

InterruptedException: Cuando se invoca a interrupt() sobre un thread dormido. NoSuchFieldException: La clase no tiene un atributo con ese nombre. NoSuchMethodException: La clase no tiene un mtodo con ese nombre.
c.) Clases de RuntimeException

ArithmeticException: Error de clculo (como divisin por cero...). ArrayStoreException: Intento de almacenar un objeto equivocado en un vector. ClassCastException: Intento de conversin invlida. IllegalArgumentException: Se ha pasado un argumento invlido a un mtodo:

IllegalThreadStateException: Un thread no estaba en el estado adecuado. NumberFormatException: Una cadena contenedora de un nmero, no lo contiene.

IllegalMonitorStateException: Se ha usado wait/notify fuera de cdigo sincronizado. IllegalStateException: Mtodo invocado en un momento inapropiado. IndexOutOfBoundsException: Acceso a un vector fuera de sus lmites:

ArrayIndexOutOfBoundsException: Idem, para una matriz. StringIndexOutOfBoundsException: Idem, para una cadena.

NegativeArraySizeException: Intento de creacin de un vector de tamao negativo. NullPointerException: Se ha usado una referencia null para acceder a un campo. SecurityException: Algo ha sido vedado por el sistema de seguridad. UnsupportedOperationException: Una operacin invocada no se soporta. Para ms informacin vase la documentacin del JDK que usted vaya a utilizar.

Anterior - ndice - Siguiente

(anterior) En esta seccin se exponen ejemplos en Java acerca del manejo de excepciones, un tema importante en la construccin de aplicacionesde misin crtica o de comercio crtico. Para utilizar un componente de Java, es necesario saber no slo la manera como se comporta ese componente cuando las cosas salen bien, sino tambin cuando las cosas salen mal. En esta seccin se introducen instrucciones imprescindibles en el manejo de excepciones (try, catch, finally).

Demostracin de la limpieza de la pila

?

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22

public class UsoExcepciones {

public static void main( String args[] ) { // llamar a lanzaExcepcion para demostrar la limpieza de la pila try { lanzaExcepcion(); }

// atrapar excepcin lanzada en lanzaExcepcion catch ( Exception excepcion ) { System.err.println( "La excepcion se manejo en main" ); } }

// lanzaExcepcion lanza la excepcin que no es atrapada en este mtodo public static void lanzaExcepcion() throws Exception { // lanzar una excepcin y atraparla en main try { System.out.println( "El metodo lanzaExcepcion" ); throw new Exception(); } // generar excepcin

23 24 25 26

// catch es del tipo incorrecto, por lo que la excepcin no es atrapada catch( RuntimeException excepcionTiempoEjecucion ) { System.err.println( "La excepcion se manejo en el metodo lanzaExcepcion" ); }

27 28 29 30 31 32 33 34 35 36 37 38
#java El Finally siempre se La excepcion se manejo en main UsoExcepciones metodo lanzaExcepcion ejecuta

// la clusula finally siempre se ejecuta finally { System.err.println( "Finally siempre se ejecuta" ); }

} // fin del mtodo lanzaExcepcion

Descargar cdigo fuente

Demostracin de getMessage y printStackTrace de la clase Exception

?

01 02 03 04 05 06 07

public class UsoExcepciones {

public static void main( String args[] ) { try { metodo1(); // llamar a metodo1 }

08 09 10 11 12

// atrapar las excepciones lanzadas desde metodo1 catch ( Exception excepcion ) { System.err.println( excepcion.getMessage() + "\n" ); excepcion.printStackTrace();

// obtener la informacin de rastreo de la pila

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
}

StackTraceElement[] elementosRastreo = excepcion.getStackTrace();

System.out.println(

"\nRastreo de pila proveniente de getStackTrace:" );

System.out.println( "Clase\t\tArchivo\t\t\tLinea\tMetodo" );

// iterar a travs de elementosRastreo para obtener descripcin de las exc for ( int i = 0; i < elementosRastreo.length; i++ ) { StackTraceElement elementoActual = elementosRastreo[ i ]; System.out.print( elementoActual.getClassName() + "\t" ); System.out.print( elementoActual.getFileName() + "\t" ); System.out.print( elementoActual.getLineNumber() + "\t" ); System.out.print( elementoActual.getMethodName() + "\n" );

} // fin de la instruccin for

} // fin de la instruccin catch

} // fin del mtodo main

// llamar a metodo2; lanzar excepciones de vuelta hacia main public static void metodo1() throws Exception { metodo2();

36 37 38 39

// llamar al mtodo3; lanzar excepciones de vuelta hacia metodo1 public static void metodo2() throws Exception { metodo3(); }

40 41 42 43 44 45 46 47 48 49 50 51 52
#java La excepcion se excepcion se lanzo lanzo en en UsoExcepciones metodo3 metodo3

// lanzar excepcin de vuelta a metodo2 public static void metodo3() throws Exception { throw new Exception( "La excepcion se lanzo en metodo3" ); }

} // fin de la clase UsoExcepciones

java.lang.Exception: La at at at at Rastreo de Clase UsoExcepciones UsoExcepciones UsoExcepciones pila

UsoExcepciones.metodo3(UsoExcepciones.java:50) UsoExcepciones.metodo2(UsoExcepciones.java:44) UsoExcepciones.metodo1(UsoExcepciones.java:38) UsoExcepciones.main(UsoExcepciones.java:7) proveniente UsoExcepciones.java UsoExcepciones.java UsoExcepciones.java de 50 44 38 getStackTrace: Archivo Linea Metodo metodo3 metodo2 metodo1

UsoExcepciones UsoExcepciones.java 7 main

Descargar cdigo fuente

Demostracin de las excepciones encadenadas

?

01 02 03 04 05 06 07 08

public class UsoExcepcionesEncadenadas {

public static void main( String args[] ) { try { metodo1(); // llamar a metodo1 }

// atrapar las excepciones lanzadas desde metodo1

09 10 11 12 13 14 15 16 17 18
}

catch ( Exception excepcion ) { excepcion.printStackTrace(); }

// llamar al metodo2; lanzar excepciones de vuelta a main public static void metodo1() throws Exception { try { metodo2(); // llamar a metodo2 }

19 20 21 22 23 24 25 26 27
// llamar a metodo3; lanzar excepciones de vuelta a metodo1 public static void metodo2() throws Exception } } // atrapar la excepcin lanzada desde metodo2 catch ( Exception excepcion ) { throw new Exception( "Excepcion lanzada en metodo1", excepcion );

28 29 30 31 32

{ try { metodo3(); // llamar a metodo3 }

// atrapar la excepcin lanzada desde metodo3

33 34 35 36 37 38 39 40 41 42 43
} }

catch ( Exception excepcion ) { throw new Exception( "Excepcion lanzada en metodo2", excepcion ); }

// lanzar excepcin de vuelta a metodo2 public static void metodo3() throws Exception { throw new Exception( "Excepcion lanzada en metodo3" );

} // fin de la clase UsoExcepcionesEncadenadas

44 45 46 47
#java java.lang.Exception: Excepcion lanzada at at Caused at at Caused at at 2 more by: by: en UsoExcepcionesEncadenadas metodo1 UsoExcepcionesEncadenadas.metodo1(UsoExcepcionesEncadenadas.java:25) UsoExcepcionesEncadenadas.main(UsoExcepcionesEncadenadas.java:7) java.lang.Exception: Excepcion lanzada en metodo2 UsoExcepcionesEncadenadas.metodo2(UsoExcepcionesEncadenadas.java:38) UsoExcepcionesEncadenadas.metodo1(UsoExcepcionesEncadenadas.java:20) 1 java.lang.Exception: Excepcion lanzada en more metodo3

UsoExcepcionesEncadenadas.metodo3(UsoExcepcionesEncadenadas.java:45) UsoExcepcionesEncadenadas.metodo2(UsoExcepcionesEncadenadas.java:33)

Descargar cdigo fuente Los ejercicios utilizados en este post estn basados en ejemplos del libro Cmo programar en Java de Deitel, y por lo tanto estn bajo la licencia que esta editorial disponga.
8 Comentarios | deja el tuyo

8 Comentarios en [cdigo] Manejo de Excepcion

Captura de Excepciones
Anterior | Siguiente Las excepciones lanzadas por un mtodo que pueda hacerlo deben recoger en bloque try/catch otry/finally. int valor; try { for( x=0,valor = 100; x < 100; x ++ ) valor /= x; } catch( ArithmeticException e ) { System.out.println( "Matemticas locas!" ); } catch( Exception e ) { System.out.println( "Se ha producido un error" ); }

try
Es el bloque de cdigo donde se prev que se genere una excepcin. Es como si dijsemos "intenta estas sentencias y mira a ver si se produce una excepcin". El bloque try tiene que ir seguido, al menos, por una clusula catch o una clusula finally. La sintaxis general del bloque try consiste en la palabra clave try y una o ms sentencias entre llaves. try { // Sentencias Java } Puede haber ms de una sentencia que genere excepciones, en cuyo caso habra que proporcionar un bloque try para cada una de ellas. Algunas sentencias, en especial aquellas que invocan a otros mtodos, pueden lanzar, potencialmente, muchos tipos diferentes de excepciones, por lo que un bloque try consistente en una sola sentencia requerira varios controladores de excepciones. Tambin se puede dar el caso contrario, en que todas las sentencias, o varias de ellas, que puedan lanzar excepciones se encuentren en un nico bloque try, con lo que habra que asociar mltiples controladores a ese bloque. Aqu la experiencia del programador es la que cuenta y es el propio programador el que debe decidir qu opcin tomar en cada caso. Los controladores de excepciones deben colocarse inmediatamente despus del bloque try. Si se produce una excepcin dentro del bloque try, esa excepcin ser manejada por el controlador que est asociado con el bloque try.

catch
Es el cdigo que se ejecuta cuando se produce la excepcin. Es como si dijsemos " controlo cualquier excepcin que coincida con mi argumento". No hay cdigo alguno entre un bloque try y un bloquecatch, ni entre bloques catch. La sintaxis general de la sentencia catch en Java es la

siguiente: catch( UnTipoTrhowable nombreVariable ) { // sentencias Java } El argumento de la sentencia declara el tipo de excepcin que el controlador, el bloque catch, va a manejar. En este bloque tendremos que asegurarnos de colocar cdigo que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepcin diferente. No debera intentarse capturar todas las excepciones con una sola clusula, como esta: catch( Excepcion e ) { ... Esto representara un uso demasiado general, podran llegar muchas ms excepciones de las esperadas. En este caso es mejor dejar que la excepcin se propague hacia arriba y dar un mensaje de error al usuario. Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a travs del argumento, excepciones semejantes. Por 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 clausula finally" ); La clusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque. El operador instanceof se utiliza para identificar exactamente cual ha sido la identidad de la excepcin. Cuando se colocan varios controladores de excepcin, es decir, varias sentencias catch, el orden en

que aparecen en el programa es importante, especialmente si alguno de los controladores engloba a otros en el rbol de jerarqua. Se deben colocar primero los controladores que manejen las excepciones ms alejadas en el rbol de jerarqua, porque de otro modo, estas excepciones podran no llegar a tratarse si son recogidas por un controlador ms general colocado anteriormente. Por lo tanto, los controladores de excepciones que se pueden escribir en Java son ms o menos especializados, dependiendo del tipo de excepciones que traten. Es decir, se puede escribir un controlador que maneje cualquier clase que herede de Throwable; si se escribe para una clase que no tiene subclases, se estar implementando un controlador especializado, ya que solamente podr manejar excepciones de ese tipo; pero, si se escribe un controlador para una clase nodo, que tiene ms subclases, se estar implementando un controlador ms general, ya que podr manejar excepciones del tipo de la clase nodo y de sus subclases.

finally
Es el bloque de cdigo que se ejecuta siempre, haya o no excepcin. Hay una cierta controversia entre su utilidad, pero, por ejemplo, podra servir para hacer un log o un seguimiento de lo que est pasando, porque como se ejecuta siempre puede dejar grabado si se producen excepciones y si el programa se ha recuperado de ellas o no. Este bloque finally puede ser til cuando no hay ninguna excepcin. Es un trozo de cdigo que se ejecuta independientemente de lo que se haga en el bloque try. A la hora de tratar una excepcin, se plantea el problema de qu acciones se van a tomar. En la mayora de los casos, bastar con presentar una indicacin de error al usuario y un mensaje avisndolo de que se ha producido un error y que decida si quiere o no continuar con la ejecucin del programa. Por ejemplo, se podra disponer de un dilogo como el que se presenta en el cdigo siguiente: public class DialogoError extends Dialog { DialogoError( Frame padre ) { super( padre,true ); setLayout( new BorderLayout() ); // Presentamos un panel con continuar o salir Panel p = new Panel(); p.add( new Button( "Continuar?" ) ); p.add( new Button( "Salir" ) ); add( "Center",new Label( "Se ha producido un error. Continuar?" ) ) add( "South",p ); } public boolean action( Event evt,Object obj ) { if( "Salir".equals( obj ) ) { dispose(); System.exit( 1 ); } return( false ); }

} Y la invocacin, desde algn lugar en que se suponga que se generarn errores, podra ser como sigue: try { // Cdigo peligroso } catch( AlgunaExcepcion e ) { VentanaError = new DialogoError( this ); VentanaError.show(); } Lo cierto es que hay autores que indican la inutilidad del bloque finally, mientras que desde el Java Tutorial de Sun se justifica plenamente su existencia. El lector deber revisar todo el material que est a su alcance y crearse su propia opinin al respecto. En el programa java904.java, se intenta demostrar el poder del bloque finally. En l, un controlador de excepciones intenta terminar la ejecucin del programa ejecutando una sentencia return. Antes de que la sentencia se ejecute, el control se pasa al bloque finally y se ejecutan todas las sentencias de este bloque. Luego el programa termina. Es decir, quedara demostrado que el bloque finally no tiene la ltima palabra palabra. El programa redefine el mtodo getMessage() de la clase Throwable, porque este mtodo devuelvenull si no es adecuadamente redefinido por la nueva clase excepcin.

throw
La sentencia throw se utiliza para lanzar explcitamente una excepcin. En primer lugar se debe obtener un descriptor de un objeto Throwable, bien mediante un parmetro en una clusula catch o, se puede crear utilizando el operador new. La forma general de la sentencia throw es: throw ObjetoThrowable; El flujo de la ejecucin se detiene inmediatamente despus de la sentencia throw, y nunca se llega a la sentencia siguiente. Se inspecciona el bloque try que la engloba ms cercano, para ver si tiene la clusula catch cuyo tipo coincide con el del objeto o instancia Thorwable. Si se encuentra, el control se transfiere a ese sentencia. Si no, se inspecciona el siguiente bloque try que la engloba, y as sucesivamente, hasta que el gestor de excepciones ms externo detiene el programa y saca por pantalla el trazado de lo que hay en la pila hasta que se alcanz la sentencia throw. En el programa siguiente, java905.java, se demuestra como se hace el lanzamiento de una nueva instancia de una excepcin, y tambin cmo dentro del gestor se vuelve a lanzar la misma excepcin al gestor ms externo. class java905 { static void demoproc() { try { throw new NullPointerException( "demo" ); } catch( NullPointerException e ) { System.out.println( "Capturada la excepcion en demoproc" ); throw e;

} } public static void main( String args[] ) { try { demoproc(); } catch( NullPointerException e ) { System.out.println( "Capturada de nuevo: " + e ); } } } Este ejemplo dispone de dos oportunidades para tratar el mismo error. Primero, main() establece un contexto de excepcin y despus se llama al mtodo demoproc(), que establece otro contexto de gestin de excepciones y lanza inmediatamente una nueva instancia de la excepcin. Esta excepcin se captura en la lnea siguiente. La salida que se obtiene tras la ejecucin de esta aplicacin es la que se reproduce: % java java905 Capturada la excepcion en demoproc Capturada de nuevo: java.lang.NullPointerException: demo

throws
Si un mtodo es capaz de provocar una excepcin que no maneja l mismo, debera especificar este comportamiento, para que todos los mtodos que lo llamen puedan colocar protecciones frente a esa excepcin. La palabra clave throws se utiliza para identificar la lista posible de excepciones que un mtodo puede lanzar. Para la mayora de las subclase de la clase Exception, el compilador Java obliga a declarar qu tipos podr lanzar un mtodo. Si el tipo de excepcin es Error o RuntimeException, o cualquiera de sus subclases, no se aplica esta regla, dado que no se espera que se produzcan como resultado del funcionamiento normal del programa. Si un mtodo lanza explcitamente una instancia deException o de sus subclases, a excepcin de la excepcin de runtime, se debe declarar su tipo con la sentencia throws. La declaracin del mtodo sigue ahora la sintaxis siguiente: type NombreMetodo( argumentos ) throws excepciones { } En el ejemplo siguiente, java906.java, el programa intenta lanzar una excepcin sin tener cdigo para capturarla, y tampoco utiliza throws para declarar que se lanza esta excepcin. Por tanto, el cdigo no ser posible compilarlo. class java906 { static void demoproc() { System.out.println( "Capturada la excepcion en demoproc" ); throw new IllegalAccessException( "demo" ); } } public static void main( String args[] ) { demoproc(); }

El error de compilacin que se produce es lo suficientemente explcito: % javac java906.java java906.java:30: Exception java.lang.IllegalAccessException must be caught, or it must be declared in the throws clause of this method. throw new IllegalAccessException( "demo" ); ^ Para hacer que este cdigo compile, se convierte en el ejemplo siguiente, java907.java, en donde se declara que el mtodo puede lanzar una excepcin de acceso ilegal, con lo que el problema asciende un nivel ms en la jerarqua de llamadas. Ahora main() llama a demoproc(), que se ha declarado que lanza una IllegalAccessException, por lo tanto colocamos un bloque try que pueda capturar esa excepcin. class java907 { static void demoproc() throws IllegalAccessException { System.out.println( "Dentro de demoproc" ); throw new IllegalAccessException( "demo" ); } public static void main( String args[] ) { try { demoproc(); } catch( IllegalAccessException e ) { System.out.println( "Capturada de nuevo: " + e ); } } }

Home | Anterior | Siguiente | Indice | Correo

Paquete Java
Un Paquete en Java es un contenedor de clases que permite agrupar las distintas partes de un programa cuya funcionalidad tienen elementos comunes.
ndice
[ocultar]

1 Ventajas 2 Contenido de un paquete 3 Uso de paquetes 4 Paquetes importantes de Java 5 Enlaces externos

[editar]Ventajas El uso de paquetes proporciona las siguientes ventajas: Agrupamiento de clases con caractersticas comunes. Reutilizacin de cdigo. Mayor seguridad al existir niveles de acceso.

[editar]Contenido

de un paquete

Un paquete puede contener: Clases Interfaces Tipos Enumerados Anotaciones

[editar]Uso

de paquetes

En los ficheros de cdigo Java se usa la palabra reservada package para especificar a qu paquete pertenecen. Suele indicarse como primera sentencia: package java.awt.event; Para usar un paquete dentro del cdigo se usa la declaracin import. Si slo se indica el nombre del paquete: import java.awt.event.*;

se importan todas las clases que contiene. Si adems del nombre del paquete se especifica una clase, slo se importa esa clase: import java.awt.event.ActionEvent; Despus de aadir alguna de estas sentencias, se puede hacer referencia a la clase ActionEvent usando su nombre: ActionEvent myEvent = new ActionEvent(); Si no se hubiera importado la clase o el paquete, cada vez que tuviramos que usarla habra que especificarlo: java.awt.event.ActionEvent myEvent = new java.awt.event.ActionEvent(); [editar]Paquetes

importantes de Java

Estos son los paquetes ms importantes de la API de Java: Paquete Descripcin

java.applet Contiene clases para la creacin de applets.

java.awt

Contiene clases para crear interfaces de usuario con ventanas.

java.io

Contiene clases para manejar la entrada/salida.

java.lang

Contiene clases variadas pero imprescindibles para el lenguaje, como Object, Thread, Math...

java.net

Contiene clases para soportar aplicaciones que acceden a redes TCP/IP.

java.util

Contiene clases que permiten el acceso a recursos del sistema, etc.

java.swing

Contiene clases para crear interfaces de usuario mejorando la AWT.

[editar]Enlaces

externos

Especificacin del lenguaje Java, 3 edicin: Unique Package Names

Convencin para el nombrado de paquetes Java

Anterior - ndice - Siguiente

II.10. PAQUETES A. Introduccin Los paquetes son el mecanismo por el que Java permite agrupar clases, interfaces, excepciones y constantes. De esta forma, se agrupan conjuntos de estructuras de datos y de clases con algn tipo de relacin en comn. Con la idea de mantener la reutilizacin y facilidad de uso de los paquetes desarrollados es conveniente que las clases e interfaces contenidas en los mismos tengan cierta relacin funcional. De esta manera los desarrolladores ya tendrn una idea de lo que estn buscando y fcilmente sabrn qu pueden encontrar dentro de un paquete. B. Creacin de un paquete
a.) Declaracin

Para declarar un paquete se utiliza la sentencia package seguida del nombre del paquete que estemos creando: package NombrePaquete; La estructura que ha de seguir un fichero fuente en Java es:

Una nica sentencia de paquete (opcional). Las sentencias de importacin deseadas (opcional). La declaracin de una (y slo una) clase pblica (public). Las clases privadas del paquete (opcional).

Por lo tanto la sentencia de declaracin de paquete ha de ser la primera en un archivo fuente Java.
b.) Nomenclatura

Para que los nombres de paquete puedan ser fcilmente reutilizados en toda una compaa o incluso en todo el mundo es conveniente darles nombres nicos. Esto puede ser una tarea realmente tediosa dentro de una gran empresa, y absolutamente imposible dentro de la comunidad de Internet. Por eso se propone asignar como paquetes y subpaquetes el nombre de dominio dentro de Internet. Se ver un ejemplo para un dominio que se llamase japon.magic.com, un nombre apropiado seracom.magic.japon.paquete.
c.) Subpaquetes

Cada paquete puede tener a su vez paquetes con contenidos parecidos, de forma que un programador probablemente estar interesado en organizar sus paquetes de forma jerrquica. Para eso se definen lossubpaquetes. Para crear un subpaquete bastar con almacenar el paquete hijo en un directorio Paquete/Subpaquete. As una clase dentro de un subpaquete como Paquete.Subpaquete.clase estar codificada en el fichero Paquete/Subpaquete.java. El JDK define una variable de entorno denominada CLASSPATH que gestiona las rutas en las que el JDK busca los subpaquetes. El directorio actual suele estar siempre incluido en la variable de entornoCLASSPATH. Para ms informacin sobre el JDK vase el "Apndice I. JDK" de este tutorial. C. Uso de un paquete Con el fin de importar paquetes ya desarrollados se utiliza la sentencia import seguida del nombre de paquete o paquetes a importar. Se pueden importar todos los elementos de un paquete o slo algunos. Para importar todas las clases e interfaces de un paquete se utiliza el metacaracter *: import PaquetePrueba.*; Tambin existe la posibilidad de que se deseen importar slo algunas de las clases de un cierto paquete o subpaquete: import Paquete.Subpaquete1.Subpaquete2.Clase1;

Para acceder a los elementos de un paquete, no es necesario importar explcitamente el paquete en que aparecen, sino que basta con referenciar el elemento tras una especificacin completa de la ruta de paquetes y subpaquetes en que se encuentra. Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elem ento En la API de Java se incluyen un conjunto de paquetes ya desarrollados que se pueden incluir en cualquier aplicacin (o applet) Java que se desarrolle. Estos paquetes son explicados con ms detalle en el captulo "III.1.Bibliotecas de la API de Java" de este tutorial. D. mbito de los elementos de un paquete Al introducir el concepto de paquete, surge la duda de cmo proteger los elementos de una clase, qu visibilidad presentan respecto al resto de elementos del paquete, respecto a los de otros paquetes... Ya en la herencia se vieron los identificadores de visibilidad public (visible a todas las clases), private (no visible ms que para la propia clase), y protected (visible a clases hijas). Por defecto se considera los elementos (clases, variables y mtodos) de un mismo paquete como visibles entre ellos (supliendo las denominadas clases amigas de C++).
Situacin del elemento En la misma clase En una clase No en el mismo paquete En una clase hija No en otro paquete En una clase no hija No en otro paquete No No S No S S S S S private S sin modificador S protected S public S

Tabla 19: Visibilidad dentro de un paquete

Todas las reglas explicadas en este apartado son igualmente vlidas para las interfaces Java. Para ms informacin vase [Naughton, 1996].

Anterior - ndice - Siguiente

Paquetes (packages)
Jos A. Maas <jmanas@dit.upm.es> Dept. de Ingeniera de Sistemas Telemticos Universidad Politcnica de Madrid 31 de enero, 2007

Introduccin
Las clases en Java se agrupan por familias que se denominan paquetes (packages).

Todas las clases pertenecen a un paquete. Por ejemplo, la clase String pertenece al paquete java.lang y se dice que el nombre completo de String es
java.lang.String

A la hora de referirnos a una clase, por ejemplo para crear un objeto de dicha clase, podemos poner el nombre completo
java.lang.String nombreAlumno= "Jorge Garca";

lo que puede ser tedioso y, para aliviar la redaccin, Java permite referirnos directamente a las clases del paquete java.lang:
String nombreAlumno= "Jorge Garca";

Otros paquetes lo tienen un poco ms difcil. As, la interface List<E> y la clase ArrayList<E> del paquete java.util requerira la notacin completa:
java.util.List<String> notas= new java.util.ArrayList<String>();

Demasiado texto, verdad? Java permite referirnos a los miembros de un paquete por el sombre sencillo de su clase si previamente lo hemos importado:
import java.util.List; import java.util.ArrayList; ...

List<String> notas= new ArrayList<String>();

La importacin puede ser clase a clase como en el ejemplo anterior, o podemos importar todas clases del paquete al tiempo:
import java.util.*; ... List<String> notas= new ArrayList<String>();

Si existieran clases con el mismo nombre en diferentes paquetes, el sistema se quejara de la ambigedad, requiriendo el nombre completo del paquete. Ntese que al final no podemos tener dos clases con igual nombre en el mismo paquete.

A qu paquete pertenecen nuestras clases?

Lo ms sencillo es indicarlo explcitamente:
package paquete.maravilloso; ... class xxx { ... }

que crea la clase paquete.maravilloso.xxx.

Si no escribimos package, java asigna la clase a un paquete annimo por defecto. Para pequeos experimentos, basta; pero para convivir con otros programadores es muy recomendable asignar las clases siempre a algn paquete.

Utilidad de los paquetes

La primera y ms evidente ventaja del uso de paquetes es que las clases quedan ordenadas y no hay colisin de nombres. Si dos programadores llaman igual a sus clases y luego hay que juntar el cdigo de ambos, basta explicitar a qu paquete nos referimos en cada caso.

En las prcticas del laboratorio usamos los paquetes para discernir una prctica de otra:
package lprg.p1; // para la primera prctica, por ejemplo

mbitos de visibilidad
Los paquetes tambin establecen un permetro de visibilidad para las clases y los miembros (variables y mtodos) de las clases cuando no se dice explcitamente si son pblic(para cualquiera, en este o en otro paquete) o private (exclusivamente para esta clase).

As, la clase C, la variable v y el mtodo m de la siguiente clase

package lprg.p1;

class C { String v= "...";

void m (...) { ... } }

sern accesibles para todas las clases del paquete lprg.p1; pero inaccesibles por clases de otros paquetes.

El resultado es una forma muy cmoda de restringir el mbito a "la familia".

Qu es un Paquete en Java?

Java Package
Package: Como hemos visto para todo proyecto en Java tenemos que crear un paquete, pero qu es realidad este paquete?, para qu sirve?, y fsicamente en el computador dnde se nos genera? Bueno tcnicamente un paquete es un espacio de nombres "namespace" que organiza un conjunto de clases e interfaces relacionadas. Fsicamente en el equipo se crean carpetas y estos son los paquetes con los que trabajamos en Java. Como el software escrito en el lenguaje de programacin Java puede estar compuesta de cientos o miles de clases individuales, tiene sentido mantener las cosas organizadas, colocando relacionados clases e interfaces en paquetes. Creacin de un Nuevo Paquete en NetBeans:

Publicado por Galo Latorre en 1:08:00 a.m. Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con Facebook

1 comentario:

1. JORGE ADRIAN VARGAS GRANDA18 de diciembre de 2012 10:50 Excente ayuda.... breve e intituiva.. Gracias. Responder

QU SON PAQUETES EN JAVA Cuando hacemos programas ms grandes, es normal que el nmero de clases vaya creciendo. Cada vez tenemos ms y ms clases. Meterlas todas en el mismo directorio no suele ser bonito. Es mejor hacer grupos de clases, de forma que todas las clases que traten de un determinado tema o estn relacionadas entre s vayan juntas. Por ejemplo, si hacemos un programa de una agenda de telfonos que los guarde en una base de datos, podemo meter todas las clases que tratan con la base de datos en un paquete (grupo), todas las de ventanas en otro, las de imprimir en otro, etc, etc. Un paquete de clases es un grupo de clases que agrupamos juntas porque consideramos que estn relacionadas entre s o tratan de un tema comn. LA CLASE HOLA MUNDO EN UN PAQUETE Java nos ayuda a organizar las clases en paquetes. En cada fichero .java que hagamos, al principio, podemos indicar a qu paquete pertenece la clase que hagamos en ese fichero. Por ejemplo, si decidimos agrupar nuestros programas de pruebas, incluido el Hola Mundo, en un paquete "prueba", pondramos esto en nuestro fichero HolaMundo.java package prueba; public class HolaMundo { public static void main (String [ ] args) { System.out.println ("Hola mundo"); } } El cdigo es exactamente igual al de nuestro Hola Mundo original, pero hemos aadido la lnea "package prueba;" al principio. Hasta aqu todo correcto. Sin embargo, al hacer esto, para que todo funcione bien, java nos obliga a organizar los directorios, compilar y ejecutar de cierta forma. ESTRUCTURA DE DIRECTORIOS ASOCIADA Si hacemos que HolaMundo.java pertenezca al paquete prueba, java nos obliga a crear un subdirectorio "prueba" y meter el HolaMundo.java ah.

Es decir, debemos tener esto as (unix y windows) /<directorio_usuario>/mi_proyecto_HolaMundo/prueba/HolaMundo.java C:\<directorio_usuario>\mi_proyecto_HolaMundo\prueba\HolaMundo.java Nuevamente, las maysculas y minsculas son importantes. Tal cual lo pongamos en "package", debemos poner el nombre del subdirectorio. COMPILAR UNA CLASE QUE EST EN UN PAQUETE Para compilar la clase que est en el paquete debemos situarnos en el directorio padre del paquete y compilar desde ah $ cd /<directorio_usuario>/mi_proyecto_HolaMundo $ javac prueba/HolaMundo.java C:\> cd C:\<directorio_usuario>\mi_proyecto_HolaMundo C:\> javac prueba\HolaMundo.java Si todo va bien, en el directorio "prueba" se nos crear un HolaMundo.class EJECUTAR UNA CLASE QUE EST EN UN PAQUETE Una vez generado el HolaMundo.class en el directorio prueba, para ejecutarlo debemos estar situados en el directorio padre de "prueba". El nombre "completo" de la clase es "paquete.clase", es decir "prueba.HolaMundo". Por ello, para ejecutar, debemos hacerlo as $ cd /<directorio_usuario>/mi_proyecto_HolaMundo $ java prueba.HolaMundo Hola Mundo C:\> cd C:\<directorio_usuario>\mi_proyecto_HolaMundo C:\> java prueba.HolaMundo Hola Mundo Si todo va como debe, debera salir "Hola Mundo" en la pantalla EL CLASSPATH CUANDO LAS CLASES ESTN EN PAQUETES Cuando las clases estn en paquetes, la variable CLASSPATH debe ponerse de tal forma que encuentre el paquete, NO la clase. Es decir, en nuestro ejemplo

$ CLASSPATH=/<directorio_usuario>/mi_proyecto_HolaMundo $ export CLASSPATH $ java prueba.HolaMundo Hola Mundo C:\> set CLASSPATH="C:\<directorio_usuario>\mi_proyecto_HolaMundo" C:\> java prueba.HolaMundo Hola Mundo o bien, si usamos la opcin -cp en la lnea de comandos $ java cp /<directorio_usuario>/mi_proyecto_HolaMundo prueba.HolaMundo Hola Mundo C:\> java cp "C:\<directorio_usuario>\mi_proyecto_HolaMundo" prueba.HolaMundo Hola Mundo PAQUETES ANIDADOS Para poder organizar mejor las cosas, java permite hacer subpaquetes de los paquetes y subpaquetes de los subpaquetes y as sucesivamente. Por ejemplo, si quiero partir mis clases de prueba en pruebas bsicas y pruebas avanzadas, puedo poner ms niveles de paquetes separando por puntos package prueba.basicas; ... package prueba.avanzadas; ... A nivel de subdirectorios tendra que crear los subdirectorios "basicas" y "avanzadas" debajo de "prueba" y meter ah las clases que correspondan. Para compilar, en el directorio del proyecto habria que compilar poniendo todo el path hasta llegar a la clase. Idem para el CLASSPATH. Para ejecutar, el nombre de la clase va con todos los paquetes separados por puntos, es decir "prueba.basicas.HolaMundo" y "prueba.avanzadas.HolaMundoRemoto". Es decir: /<directorio_usuario>/mi_proyecto_HolaMundo/prueba/basicas/HolaMundo.j ava $ cd /<directorio_usuario>/mi_proyecto_HolaMundo $ javac prueba/basicas/HolaMundo.java

$ java -cp /<directorio_usuario>/mi_proyecto_HolaMundo prueba.basicas.HolaMundo Hola Mundo C:\<directorio_usuario>\mi_proyecto_HolaMundo\prueba\basicas\HolaMundo .java C:\> cd C:\<directorio_usuario>\mi_proyecto_HolaMundo C:\> javac prueba\basicas\HolaMundo.java C:\> java -cp C:\<directorio_usuario>\mi_proyecto_HolaMundo prueba.basicas.HolaMundo Hola Mundo Para la prxima, el cmo empaquetar los .class en ficheros .jar ... Estadsticas y comentarios

Numero de visitas desde el 4 Feb 2007:

Esta pagina este mes: 790 Total de esta pagina: 79246 Total del sitio: 11640754

Todo lo que siempre quise saber de los paquetes en java

Submitted by Shadonwk on Mi, 05/12/2010 - 21:25

Java Standard Edition

Introduccin Siempre que utilizamos alguna librera de terceros para generar graficas o la que acabamos de ocupar para generar archivos pdf, notamos que tenemos que importar dichas clases de una manera similar a: [code lang="java"] import java.io.FileOutputStream; import java.io.IOException; import com.itextpdf.text.Document; [/code] Con lo cual le decimos al compilador que vamos a hacer uso de las clases FileOutputStream, IOException las cuales se encuentran empaquetadas en java.io y que tambin vamos a utilizar la clase Document la cual est en el paquete com.itextpdf.text pero Qu son los paquetes? Segn Wikipedia: Un Paquete en Java es un contenedor de clases que permite agrupar las distintas partes de un programa cuya funcionalidad tienen elementos comunes. Mi definicin: Los paquetes son la forma mediante la cual Java permite agrupar clases, interfaces, excepciones, constantes, etc. De esta forma, se agrupan conjuntos de estructuras de datos y de clases con algn tipo de relacin en comn. Un paquete no es ms que un conjunto o ruta de directorios en los cuales se almacenaran nuestras clases, quedando en un mismo directorio las clases que tengan relacin entre ellas. Java utiliza los paquetes para organizar sus clases y poner juntas o agrupadas las clases relacionadas como ejemplo tenemos el paquete til, que contiene una serie de utileras tales como las listas, arrayList etc. Cmo usar los paquetes? Cuando declaramos una variable en java de tipo String por ejemplo podemos hacerlo de la siguiente manera: [code lang="java"] java.lang.String miNombre=Jos Roberto Len C.; [/code] Sin embargo eso es muy difcil de recordar adems hara que nuestro cdigo se tornara difcil de leer y adems mas pesado, pensando en esto Java permite referirnos al las clases del paquete java.lang directamente con lo cual declararamos nuestra variable asi: [code lang="java"] String miNombre=Jos Roberto Len C.; [/code] Y este ejemplo no es el peor vemos otro:

[code lang="java"] java.util.List meses= new java.util.ArrayList(); [/code] Es todo un royo por suerte los creadores de Java pensaron en todo esto y nos dan la solucin, la cual consiste en importar previamente la clase desde el paquete que la contiene y posteriormente utilizarla simplemente con el nombre por lo que si retomamos el ejemplo anterior quedara de la siguiente manera: [code lang="java"] import java.util.List; import java.util.ArrayList; List meses= new ArrayList(); [/code] Como vemos esto nos facilita mas las cosas, podemos hacerlo todava mas fcil, en el ejemplo anterior notamos que tanto List como ArrayList se encuentran en el mismo paquete por lo cual podemos importar todas las clases del paquete y nos quedara de la siguiente forma: [code lang="java"] import java.util.*; [/code] Con lo cual le indicamos a java que vamos a utilizar una o mas clases del paquete java.util. cmo creo mis propios paquetes? Para declarar un paquete se utiliza la sentencia package seguida del nombre del paquete que estemos creando: [code lang="java"] package NombrePaquete; [/code] La estructura que ha de seguir un codigo fuente en Java es: Una nica sentencia de paquete (opcional). Las sentencias de importacin deseadas (opcional). La declaracin de una (y slo una) clase pblica (public). Las clases privadas del paquete (opcional). Por lo tanto la sentencia de declaracin de paquete ha de ser la primera en un archivo fuente Java. Y las reglas? ,Puedo poner los paquetes como se me d la gana? Pues en teora si, puedes hacer los paquetes como se te ocurra, no hay ninguna limitacin en cuanto a este tema se refiere, sin embargo, java propone una nomenclatura que har mas fcil la tarea de asignar nombres a nuestros paquetes lo siguiente no es una regla sino mas bien es un convenio que propone java para hacer mas legible nuestro cdigo: * Los nombres de los paquetes deben empezar siempre con minsculas.- Esto es para hacer ms sencillo el reconocimiento tanto de los paquetes como de las clases, ya que por convenio todas las clases empiezan con una letra mayscula por lo cual si tuviramos: [code lang="java"]

com.roberto.leon.ejemplos.Ejemplo01.getHola(); [/code] si seguimos el convenio citado es obvio que com, roberto, leon, ejemplos son paquetes y que Ejemplo01 es el nombre de mi clase y tambin podemos deducir con toda certeza que getHola es un mtodo o miembro de esa clase. Actualmente no hay ninguna organizacin en Internet que controle esta nomenclatura(al menos hasta donde yo s) Javasoft ha reconocido este problema ya en una fase avanzada de su desarrollo, as que han indicado una convencin para asegurar que los nombres de los paquetes sean nicos, basndose en los dominios, colocndolos al revs. Es decir, un dominio del tipo miempresa.com, debera colocar delante de todos sus paquetes el prefijo com.miempresa. Para poner un ejemplo vamos a poner el ejemplo01.java y lo vamos asignar al paquete com.roberto.leon.ejemplos. [code lang="java"] /** * @(#)Ejemplo01.java * * @author Roberto Len Cruz * @version 1.00 2010/5/10 */ package com.roberto.leon.ejemplos; public class Ejemplo01 { public Ejemplo01() { System.out.println("Hola Mundo Cruel"); System.out.println("By Roberto Len Cruz"); } public static void main (String[] args) { new Ejemplo01(); } } [/code] Veremos que al compilar nuestro archivo nos creara los directorios correspondientes al paquete indicado y adems en ejemplos nos creara el archivo .class correspondiente a mi clase que acabo de compilar.

Ventajas del uso de paquetes en java Pues creo que es evidente las ventajas que los paqutes nos ofrecen para empezar nuestras clases quedan ordenadas, esto hace que si trabajamos en equipo con varios programadores y

alguno de llos crea una clase con el nombre mtodos por ejemplo y yo hago una que se llame igual mtodos entonces esto seria un problema a la hora de unir nuestros cdigos, sin embargo si estn distribuidas en diferentes paquetes, bastara con indicar a que paquete pertenece la clase que voy a utilizar, otra de las ventajas es que permite hacer tus clases mas propietarias. Les cuento que al fin he podido conseguir un hosting y un dominio donde explicare otras cosas reelevantes e interezantes ademas de java pueden visitar: http://robertoleon.com.mx Espero sus comentarios sobre este post.!!

Shadonwk's blog

Inicie sesin o regstrese para enviar comentarios

Comentarios Opciones de visualizacin de comentarios

Lista plana: expandida

Fecha: primero los ms antiguos

50 comentarios por pgina

Guardar las opciones

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en Guardar las opciones para activar los cambios.

Buena info
Submitted by CARRARO on Jue, 05/13/2010 - 09:03.

Detallada y simple... esta bien ): Saludos

Inicie sesin o regstrese para enviar comentarios

Muy bien explicado,

Submitted by elyager on Jue, 05/13/2010 - 13:29.

Muy bien explicado, simplicidad ante todo como debe de ser :) buen artculo

Inicie sesin o regstrese para enviar comentarios

Felicitaciones, slo una cosa

Submitted by CharlieCorner on Jue, 05/13/2010 - 13:45.

El artculo est bastante bastante claro, vas al punto sin rodeos y se entiende hasta por un principiante. Algo que le dara un plus bastante bastante bueno es que lo editaras para agregar un apartado donde expliques la nomenclatura convencional para la organizacin de paquetes, porque si bien la usas no explicas por qu XD Me refiero a decir: Por qu usas com.roberto.leon.ejemplos? Por qu no slo ejemplos? Cosas as, de que va la URL de la pgina personal o de la empresa en sentido inverso separado por puntos. Por lo dems, reitero, es un artculo excelente!

Inicie sesin o regstrese para enviar comentarios

s!!
Submitted by Shadonwk on Jue, 05/13/2010 - 17:50.

tienes razon Charlie jeje nose porque se me paso pero ahora hago la correcin... gracias a quienes han comentado mi post, espero le hayan entendido, y recuerden que si quieren ver otros temas de programacion y de otras cositas muy utiles pueden darse una vueltesita por mi web. que apenas inicia pero con su ayuda se hara grande.

Inicie sesin o regstrese para enviar comentarios

Una pequea aclaracin

Submitted by 1a1iux on Lun, 05/24/2010 - 09:24.

"Siempre que utilizamos alguna librera de terceros para generar graficas o la que acabamos de ocupar para generar archivos pdf, notamos que tenemos que importar dichas clases de una manera similar a.." Yo dira, siempre que se utiliza una clase que no se encuentre en el paquete java.lang se tiene que importar de forma explcita. Es decir, no importa si es una clase propia del API de Java o de una biblioteca de un tercero.

Por lo dems, buen post. Sale y vale Byte

Inicie sesin o regstrese para enviar comentarios

No funciona el domain
Submitted by JesusOsorio on Mi, 09/14/2011 - 09:19.

Domain is out Thank you

Inicie sesin o regstrese para enviar comentarios

tarea

PAQUETES

La palabra clave package permite agrupar clases e interfaces. Los nombres de los paquetes son palabras separadas por puntos y se almacenan en directorios que coinciden con esos nombres. Por ejemplo, los ficheros siguientes, que contienen cdigo fuente Java:
Applet.java, AppletContext.java, AppletStub.java, AudioClip.java

contienen en su cdigo la lnea:

package java.applet;

Y las clases que se obtienen de la compilacin de los ficheros anteriores, se encuentran con el nombre nombre_de_clase.class, en el directorio:
java/applet

Import

Los paquetes de clases se cargan con la palabra clave import, especificando el nombre del paquete como ruta y nombre de clase (es lo mismo que #include de C/C++). Se pueden cargar varias clases utilizando un asterisco.
import java.Date; import java.awt.*;

Si un fichero fuente Java no contiene ningn package, se coloca en el paquete por defecto sin nombre. Es decir, en el mismo directorio que el fichero fuente, y la clase puede ser cargada con la sentencia import:
import MiClase;

Paquetes de Java

El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un sistema de entrada/salida general, herramientas y comunicaciones. En la versin actual del JDK, los paquetes Java que se incluyen son: java.applet Este paquete contiene clases diseadas para usar con applets. Hay una clase Applet y tres interfaces: AppletContext, AppletStub y AudioClip.

java.awt El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y componentes GUI (Interfaz Grfico de Usuario). Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField. java.io El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream y FileOutputStream. java.lang Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread, Exception, System, Integer, Float, Math, String, etc. java.net Este paquete da soporte a las conexiones del protocolo TCP/IP y, adems, incluye las clases Socket, URL y URLConnection. java.util Este paquete es una miscelnea de clases tiles para muchas cosas en programacin. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (nmeros aleatorios) y Stack (pila FIFO).

El paquete (package)

Los paquetes son una forma de organizar grupos de clases. Un paquete contiene un conjunto de clases relacionadas bien por finalidad, por mbito o por herencia. Los paquetes resuelven el problema del conflicto entre los nombres de las clases. Al crecer el nmero de clases crece la probabilidad de designar con el mismo nombre a dos clases diferentes. Las clases tienen ciertos privilegios de acceso a los miembros dato y a las funciones miembro de otras clases dentro de un mismo paquete.

En el Entorno Integrado de Desarrollo (IDE) JBuilder de Borland, un proyecto nuevo se crea en un subdirectorio que tiene el nombre del proyecto. A continuacin, se crea la aplicacin, un archivo .java que contiene el cdigo de una clase cuyo nombre es el mismo que el del archivo. Se pueden agregar nuevas clases al proyecto, todas ellas contenidas en archivos .java situadas en el mismo subdirectorio. La primera sentencia que encontramos en el cdigo fuente de las distintas clases que forman el proyecto es package o del nombre del paquete.
//archivo MiApp.java package nombrePaquete; public class MiApp{ //miembros dato //funciones miembro } //archivo MiClase.java package nombrePaquete; public class MiClase{ //miembros dato //funciones miembro }

La palabra reservada import

Para importar clases de un paquete se usa el comando import. Se puede importar una clase individual
import java.awt.Font;

o bien, se puede importar las clases declaradas pblicas de un paquete completo, utilizando un arterisco (*) para reemplazar los nombres de clase individuales.

import java.awt.*;

Para crear un objeto fuente de la clase Font podemos seguir dos alternativas
import java.awt.Font; Font fuente=new Font("Monospaced", Font.BOLD, 36);

O bien, sin poner la sentencia import

java.awt.Font fuente=new java.awt.Font("Monospaced", Font.BOLD, 36);

Normalmente, usaremos la primera alternativa, ya que es la ms econmica en cdigo, si tenemos que crear varias fuentes de texto. Se pueden combinar ambas formas, por ejemplo, en la definicin de la clase BarTexto
import java.awt.*; public class BarTexto extends Panel implements java.io.Serializable{ //... }

Panel es una clase que est en el paquete java.awt, y Serializable es un interface que est en el paquete java.io

Los paquetes estndar

Paquete java.applet Descripcin Contiene las clases necesarias para crear applets que se ejecutan en la ventana del navegador Contiene clases para crear una aplicacin GUI independiente de la plataforma Entrada/Salida. Clases que definen distintos flujos de datos Contiene clases esenciales, se importa impcitamente sin necesidad de una sentencia import. Se usa en combinacin con las clases del paquete java.io para leer y escribir datos en la red. Contiene otras clases tiles que ayudan al programador

java.awt java.io java.lang

java.net java.util

JAVA Y LA PLATAFORMA J2EE

CAPITULO 1 - EL LENGUAJE JAVA

Siguiente Anterior Indice

1.13. PAQUETES En JAVA las clases e interfaces se pueden agrupar en paquetes, como una forma de ordenarlas, evitar conflictos por nombres de clases similares y organizarlas en grupos de clases para facilitar el acceso a ellas por parte de las aplicaciones JAVA. Si la aplicacin es pequea tal vez no se necesite de la utilizacin de paquetes, pero un programa de un tamao medio o que crece constantemente seguro que s. Cada paquete rene un conjunto de clases o interfaces relacionadas entre s. Las razones que se dan para establecer la utilidad de usar paquetes son [1]:

Organizar las clases en unidades para establecer grupos que estn asociados de alguna forma, ya sea por herencia, propsito o alcance. Si se han creado muchas clases puede que haya nombrado alguna con un nombre que ya est utilizado. Entonces al agrupar las clases se reduce la posibilidad de conflictos de nombres entre las clases. Permite un mejor control de acceso a las clases, mtodos y variables. Los paquetes se pueden usar para identificar las clases, usando los nombres de paquetes como parte del nombre de la clase.

Los paquetes pueden contener otros paquetes, que dicen relacin con implementaciones ms concretas de la aplicacin. Un buena foma de ejemplificar los paquetes es asocindolos a los directorios que tiene subdirectorios, que son ms especficos en cuanto a la informacin que almacenan. De hecho, los paquetes son directorios que almacenan clases, que pueden estar comprimidos o no y su acceso lo determina la variable de entorno CLASSPATH. El J2SE proporciona el compilador y el intrprete JAVA, junto a la API JAVA, que se denomina Biblioteca de Clases de JAVA, cuya documentacin se encuentra disponible en al sitio de Sun Microsystems

La clases de la Biblioteca de Clases de JAVA ( API JAVA), se agrupan en un directorio particular denominado "java". Desde este directorio se tiene acceso a las clases y estn disponibles para todas las aplicaciones. El paquete "java" tiene una serie de subpaquetes con la implementacin de funcionalidades concretas, como manejo de archivos, rutinas grficas, conectividad, etc. Por ejemplo, el paquete "java.lang" incluye una serie de clases que estn disponibles en forma predeterminada para todas las clases que se creen. Otro paquete que vale la pena destacar es"java.util", que contiene clases como Random o Date. Las clases del paquetes "java.lang", se encuentran disponibles en forma predeterminada, es decir, no es necesario invocarlas explcitamente. La llamada a otras clases de otros paquetes debe hacerse en forma especfica, utilizando el operador punto, por ejemplo, para imprimir en consola se llama a : System.out.println(). 1.13.1. Uso de Paquetes Para usar los paquetes en JAVA se utiliza la palabra reservada import. Existen tres reglas que se deben conocer [2]:

Como lo hemos sealado, las clases del paquete "java.lang" estn disponibles en forma automtica para todos los programas. Por ejemplo, el subpaquete "System" o la clase "String", "Integer", "Math", etc. Si se trata de una clase que no est en este paquete, se puede utilizar haciendo mencin de los paquetes en donde se encuentra y. Por ejemplo, si quiere implementar sockets en JAVA puede llamar a la clase Socket con su ruta de paquete completa : java.net.Socket().
java.net.Socket s = new java.net.Socket()

Pero sucede que referirse a la clase de esta manera no es eficiente cuando utilizamos una cantidad de clases de ese mismo paquete. En este caso, tiene relevancia la clusula import. Como lo grficamos en nuestro esquema esta(s) instruccin(es) vienen antes de la definicin del nombre de la clase. Se puede utilizar para importar una clase en particular o todo un paquete de clases :
import java.net.Socket //slo una clase import java.net.* //todas las clases del paquete

class nombreClase { //cuerpo de la clase

Se debe tener en cuenta que el astersco (*), no importa los subpaquetes. Hay que hacer la importacin en forma expresa para todas las definiciones de paquetes, aunque forme parte de otro paquete. Hecha la importacin se puede referir a la clase por su nombre en particular sin referencia al paquete. Por ejemplo :
Socket s = new Socket()

En este caso, al importar clases desde dos paquetes puede causar problemas de conflictos con el nombre de las clases que son idnticos y que pertenecen a dos paquetes importados. El compilador JAVA se quejar y no permitir la compilacin del programa. Para solucionar esta cuestin simplemente se deben usar las clases sealando el paquete al que pertenecen. Para buscar una clase de un paquete, fuera del paquete "java.lang", es necesario que la variable CLASSPATH apunte a los directorios o archivos donde se localizan la clases. Si no ha definido una variable CLASSPHAT, el compilador JAVA las buscar en el directorio 'lib' predeterminado de la instalcin JAVA, o en la carpeta de trabajo actual. Si no se encuentra se gener el error "class not found". 1.13.2. Creacin de Paquetes Para crear un paquete en JAVA se requiere pensar en el nombre, crear una carpeta para guardar nuestras clases y agregar la clase al paquete mediante la palabra reservada package. Existe plena libertad para elegir el nombre del paquete. Se puede denominar de cualquier forma. Pero existe algunas recomendaciones al respecto que se suelen seguir.

Si se quiere distribuir el paquete, se recomienda que el nombre aluda al autor de alguna forma. En este sentido, Sun Microsystems recomienda usar el nombre del dominio en Internet pero en modo inverso. Por ejemplo, si su dominio es dominio.cl, el paquete se llamara : cl.dominio.nombrePaquete. Esto se hace con la idea de darle exclusividad al nombre del paquete para que no se confunda con otros. Adems, se debe crear un estructura de directorio para almacenar las clases del paquete. El directorio que se crea debe tener por nombre el del paquete en cuestin. Pero si su nombre tiene varias partes, como cl.dominio.nombrePaquete, debe crear un directorio 'cl', que contenga al directorio 'dominio', que a su vez contemple a directorio 'nombrePaquete', el cual guardar las clases. Este paquete puede estar comprimido, para lo cual JAVA dispone de una utilidad llamada 'jar', que tiene por objetivo la compresin de datos. Finalmente, debe expresar en el cdigo fuente de las clases que pertenecen al paquete en cuestin. Para ello se usa la instruccin package que va antes de cualquier otra declaracin en el cdigo fuente que no sean comentario o lneas en blanco. Por ejemplo :
//Pertenencia de paquete package cl.dominio.nombrePaquete;

1 Creacin de Paquetes
Los paquetes Java agrupan las clases en libreras (bibliotecas). Los paquetes Java se utilizan de forma similar a como se utilizan las libreras en C++, slo que en Java se agrupan clases y/o interfaces. En los paquetes las clases son nicas, comparadas con las de otros paquetes, y permiten controlar el acceso. Esto es, los paquetes proporcionan una forma de ocultar clases, evitando que otros programas o paquetes accedan a clases que son de uso exclusivo de una aplicacin determinada. Los paquetes se declaran utilizando la palabra reservada package seguida del nombre del paquete. Esta sentencia debe estar al comienzo del fichero fuente. Concretamente debe ser la primera sentencia ejecutable del cdigo Java, excluyendo, los comentarios y espacios en blanco. Por ejemplo:
package figuras; public class Circulo {

. . . }

En este caso, el nombre del paquete es figuras. La clase Circulo se considera como parte del paquete. La inclusin de nuevas clases en el paquete es simple, se ha de colocar la misma sentencia al comienzo de los ficheros que contengan la declaracin de las clases. Cada uno de los ficheros que contengan clases pertenecientes a un mismo paquete, deben incluir la misma sentencia package, y solamente puede haber una sentencia package por fichero. La sentencia package colocada el comienzo de un fichero fuente afectar a todas las clases que se declaren en ese fichero. Se pueden referenciar paquetes precediendo con su nombre la clase que se quiere usar. Tambin se puede usar la palabra reservada import, si se van a colocar mltiples referencias a un mismo paquete. La sentencia import se utiliza para incluir una lista de paquetes en los que buscar una clase determinada, y su sintaxis es:
import nombre_paquete.Nombre_Clase;

Esta sentencia, o grupo de ellas, deben aparecer antes de cualquier declaracin de clase en el cdigo fuente.