PAQUETES EN JAVA
Un paquete es un conjunto de clases, lógicamente relacionadas entre si, agrupadas bajo un nombre, por ejemplo (java.io), este paquete por ejemplo agrupa las clases que permiten a un programa gestionar la entrada y salida de información. Incluso, ese paquete puede contener otros paquetes. Los paquetes ayudan a organizar las clases en grupos para facilitar el acceso a las mismas cuando las invoquemos en un programa.
La propia de clases de Java esta organizada en paquetes dispuestos jerárquicamente. En el siguiente diagrama se muestran algunos de ellos
:
Para referirnos a una clase de paquete, tenemos que hacerlo utilizando su nombre completo, excepto cuando haya sido importado implícitamente o explícitamente, como se vera a continuación. Por ejemplo, java.lang.System hace referencia a la clase System del paquete java.lang (java.lang es el nombre completo del paquete lang).
Las clases que guardamos en un fichero cuando escribimos un programa pertenecen al paquete predeterminado sin nombre. De esta forma Java se asegura que toda clase pertenezca a un paquete.
Protección de un Paquete
Este tipo de protección solo puede ser utilizada por las clases de su paquete (no esta disponible para otros paquetes, ni siquiera por los subpaquetes). Por omisión una clase tiene un nivel de protección de paquetes.Sentencia Import
Una clase de un determinado paquete puede hacer uso de otra clase de otro paquete de dos formas:- Utilizando su nombre completo en todas las partes del código donde haya que referirse a ella. Por ejemplo:
Java.lang.System.out.println(gradoscentig):
- Importando la clase, como se indica en el párrafo siguiente, lo que posibilita referirse a ella simplemente por su nombre. Por ejemplo:
System.out.println(gradoscentig):
Crear un Paquete
Para crear un paquete se deben seguir los siguientes pasos:- Seleccionar el nombre del paquete: La idea de esto es la exclusividad del nombre del paquete, con el fin no causar conflictos con los paquetes de otros.
- Crear una estructura jerárquica de carpetas en el disco duro: Esta estructura jerárquica se hace corresponder en el disco duro con una estructura jerárquica de carpetas, de forma que los nombres de las carpetas coincidan con los demás elementos del paquete. La ruta de acceso de la carpeta raíz de esta estructura jerárquica tiene que estar especificada por al variable CLASSPATH.
Por ejemplo:
Set CLASSPATH = c:\java\jdk1.3\misclases:c:\java\jdk1.3
- Especificar el paquete al que pertenece la clase: cuando defina una clase puede especificar a que paquete pertenece utilizando la sentencia:
package nombre_paquete.
Esta es la primera línea de código del fichero fuente.
Bibliografia.
Ceballos, Francisco Javier. Java 2, Curso de programacion. Alfaomega. Pág. 67, 303
realizado por: Octavio Muñoz Londoño Código 221016106
1 comentario:
Los paquetes se utilizan en Java de forma similar a como se utilizan las librerías en C++, para agrupar funciones y clases, sólo que en Java agrupan diferentes clases y/o interfaces. En ellos las clases son únicas, comparadas con las de otros paquetes, y además proporcionan un método de control de acceso. Los paquetes también proporcionan una forma de ocultar clases, evitando que otros programas o paquetes accedan a clases que son de uso exclusivo de una aplicación determinada.
Declaración de Paquetes
Los paquetes se declaran utilizando la palabra package seguida del nombre del paquete. Esto debe estar al comienzo del fichero fuente, en concreto, debe ser la primera sentencia ejecutable del código Java, excluyendo, claro está, los comentarios y espacios en blanco. Por ejemplo:
package mamiferos;
class Ballena {
. . .
}
En este ejemplo, el nombre del paquete es mamiferos. La clase Ballena se considera como parte del paquete. La inclusión de nuevas clases en el paquete es muy sencilla, ya que basta con colocar la misma sentencia al comienzo de los ficheros que contengan la declaración de las clases. Como cada clase se debe colocar en un fichero separado, 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.
Se recuerda que el compilador Java solamente requiere que se coloquen en ficheros separados las clases que se declaren públicas. Las clases no públicas se pueden colocar en el mismo fichero fuente, al igual que las clases anidadas. Aunque es una buena norma de programación que todas las clases se encuentren en un único fichero, la sentencia package colocada el comienzo de un fichero fuente afectará a todas las clases que se declaren en ese fichero.
Java también soporta el concepto de jeraquía de paquetes. Esto es parecido a la jerarquía de directorios de la mayoría de los sitemas operativos. Se consigue especificando múmtiples nombres en la sentencia package, separados por puntos. Por ejemplo, en las sentencias siguientes, la clase Ballena pertenece al paquete mamiferos que cae dentro de la jerarquía del paquete animales.
package animales.mamiferos;
class Ballena {
. . .
}
Esto permite agrupar clases relacionadas en un solo paquete, y agrupar paquetes relacionados en un paquete más grande. Para referenciar a un miembro de otro paquete, se debe colocar el nombre del paquete antes del nombre de la clase. La siguiente sentencia es un ejemplo de llamada al método obtenerNombre() de la clase Ballena que pertenece al subpaquete mamiferos del paquete animales:
animales.mamiferos.Ballena.obtenerNombre();
La analogía con la jerarquía de directorios se ve reforzada por el intérprete Java, ya que éste requiere que los ficheros .class se encuentren físicamente localizados en subdirectorios que coincidan con el nombre del subpaquete. En el ejemplo anterior, si se encontrase en una máquina Unix, la clase Ballena debería estar situada en el camino siguiente:
animales/mamiferos/Ballena.class
Por supuesto, las convenciones en el nombre de los directorios serán diferentes para los distintos sistemas operativos. El compilador Java colocará los ficheros .class en el mismo directorio que se encuentren los ficheros fuentes, por lo que puede ser necesario mover los ficheros .class resultantes de la compilación al directorio adecuado, en el caso de que no se encuentren los fuentes en el lugar correcto del árbol jerárquico. Aunque los ficheros .class también se pueden colocar directamente en el directorio que se desee especificando la opción -d (directorio) a la hora de invocar al compilador. La siguiente línea de comando colocará el fichero resultante de la compilación en el subdirectorio animales/mamiferos/Ballenas, independientemente de cual sea el directorio desde el cual se esté invocando al compilador.
> javac -d animales/mamiferos/Ballena Ballena.java
Todas las clases quedan englobadas dentro de un mismo paquete, si no se especifica explíctamente lo contrario, es decir, aunque no se indique nada, las clases pertenecen a un paquete; ya que, como es normal en Java, lo que no se declara explícitamente, toma valores por defecto. En este caso, hay un paquete sin nombre que agrupa a todos los demás paquetes. Si un paquete no tiene nombre, no es posible para los demás paquetes referenciar a ese paquete, por eso es conveniente colocar todas las clases no triviales en paquetes, para que puedan ser referenciadas posteriormente desde cualquier otro programa.
Acceso a Otros Paquetes
Se decía que se pueden referenciar paquetes precediendo con su nombre la clase que se quiere usar. También se puede emplear la palabra clave import, si se van a colocar múltiples referencias a un mismo paquete, o si el nombre del paquete es muy largo o complicado.
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;
Esta sentencia, o grupo de ellas, deben aparecer antes de cualquier declaración de clase en el código fuente. Por ejemplo:
import animales.mamiferos.Ballena;
En este ejemplo, todos los miembros (variables, métodos) de la clase Ballena están accesibles especificando simplemente su nombre, sin tener que precederlo del nombre completo del paquete.
Esta forma de abreviar tienes sus ventajas y sus desventajas. La ventaja principal es que el código no se vuelve demasiado difícil de leer y además es más rápido de teclear. La desventaja fundamental es que resulta más complicado el saber exactamente a qué paquete pertenece un determinado miembro; y esto es especialmente complicado cuando hay muchos paquetes importados.
En la sentencia import también se admite la presencia del carácter *, asterisco. Cuando se emplea, se indica que toda la jerarquía de clases localizada a partir del punto en que se encuentre, debe ser importada, en lugar de indicar solamente una determinada clase. Por ejemplo, la siguiente sentencia indicaría que todas la clases del subpaquete animales.mamiferos, deben ser importadas:
import animales.mamiferos.*;
Esta es una forma simple y sencilla de tener acceso a todas las clases de un determinado paquete. Aunque el uso del asterisco debe hacerse con cautela, porque al ya de por sí lento compilador, si se pone un asterisco, se cargarán todos los paquetes, lo que hará todavía más lenta la compilación. No obstante, el asterisco no tiene impacto alguno a la hora de la ejecución, solamente en tiempo de compilación.
La sentencia import se utiliza en casi todos los ejemplos del Tutorial, fundamentalmente para acceder a las distintas partes del API de Java. Por defecto, el conjunto de clases bajo java.lang.* se importan siempre; las otras librerías deben ser importadas explícitamente. Por ejemplo, las siguientes líneas de código premiten el acceso a las clases correspondientes a las librerías de manipulacion de imágenes y gráficos:
import java.awt.Image;
import java.awt.Graphics;
Nomenclatura de Paquetes
Los paquetes pueden nombrarse de cualquier forma que siga el esquema de nomenclatura de Java. Por convenio, no obstante, los nombres de paquetes comienzan por una letra minúscula para hacer más sencillo el reconocimiento de paquetes y clases, cuando se tiene una referencia explícita a una clase. Esto es porque los nombres de las clases, también por convenio, empiezan con una letra mayúscula. Por ejemplo, cuando se usa el convenio citado, es obvio que tanto animales como mamiferos son paquetes y que Ballena es una clase. Cuanquier cosa que siga al nombre de la clase es un miembro de esa clase:
animales.mamiferos.Ballena.obtenerNombre();
Java sigue este convenio en todo el API. Por ejemplo, el método System.out.println() que tanto se ha utilizado sigue esta nomenclatura. El nombre del paquete no se declara explícitamente porque java.lang.* siempre es importado implícitamente. System es el nombre de la clase perteneciente al paquete java.lang y está capitalizado. El nombre completo del método es:
java.lang.System.out.println();
Cada nombre de paquete ha de ser único, para que el uso de paquetes sea realmente efectivo. Los conflictos de nombres pueden causar problemas a la hora de la ejecución en caso de duplicidad, ya que los ficheros de clases podrían saltar de uno a otro directorio. En caso de proyectos pequeños no es difícil mantener una unicidad de nombres, pero en caso de grandes proyectos; o se sigue una norma desde el comienzo del proyecto, o éste se convertirá en un auténtico caos.
No hay ninguna organización en Internet que controle esta nomenclatura, y muchas de las aplicaciones Java corren sobre Web. Hay que tener presente que muchos servidores Web incluyen applets de múltiples orígenes, con lo cual parece poco menos que imposible el evitar que alguien duplique nombres.
Javasoft ha reconocido este problema ya en una fase avanzada de su desarrollo, así que han indicado una convención para asegurar que los nombres de los paquetes sean únicos, basándose en los dominios, colocándolos al revés. Es decir, un dominio del tipo miempresa.com, debería colocar delante de todos sus paquetes el prefijo com.miempresa. Esto resolvería el problema de la nomenclatura, ya que los desarrolladores podrían controlar sus propios paquetes y, además, se generaría una estructura jerárquica de paquetes muy limpia. De hecho, el paquete Swing en la versión beta 3 del JDK 1.2 se situó bajo el árbol java.awt, lo cual sugería que las clases Swing dependían del AWT, cuando es un paquete autosuficiente y que no tiene mucho que ver con el AWT, así que Javasoft dió marcha atrás en su nomenclatura y colocó el paquete en su situación actual com.java.Swing.
Como norma y resumen de todo lo dicho, a la hora de crear un paquete hay que tener presente una serie de ideas:
La palabra clave package debe ser la primera sentencia que aparezca en el fichero, exceptuando, claro está, los espacios en blanco y comentarios
Es aconsejable que todas las clases que vayan a ser incluidas en el paquete se encuentren en el mismo directorio. Como se ha visto, esta recomendación se la puede uno saltar a la torera, pero se corre el riesgo de que aparezcan determinados problemas difíciles de resolver a la hora de compilar, en el supuesto caso de que no se hile muy fino
Ante todo, recordar que en un fichero únicamente puede existir, como máximo, una clase con el especificador de acceso public, debiendo coincidir el nombre del fichero con el nombre de la clase
Tonny Peña
Cod 221132204
Publicar un comentario