Instituto Tecnológico de Culiacán

Ing. en Sistemas
Computacionales
Tópicos Avanzados de Programación

Unidad II: Componentes y Librerias

Paquetes
Java permite agrupar las clases en una
colección denominada paquete. Los
paquetes son una forma cómoda de
organizar nuestro trabajo, y también sirven
para separar nuestro trabajo de las
bibliotecas de código que proporcionan
otras personas.
Paquetes
La biblioteca estándar de Java se distribuye en un
cierto número de paquetes denominados java.lang,
java.util, java.net, y así sucesivamente.

Los paquetes estándar de Java son ejemplos de

paquetes jerárquicos. Del mismo modo que se
tienen carpetas anidadas en el disco duro, es
posible organizar los paquetes empleando niveles
de anidamiento.

Todos los paquetes estándar de Java se encuentran

Paquetes
La razón principal por la cual se utilizan
paquetes es para garantizar la exclusividad de los
nombres de clases.

Suponga que hay dos programadores a los cuales

se les ocurre la brillante idea de proporcionar
una clase denominada Empleado. Siempre y
cuando los dos sitúen su clase en paquetes
distintos, no habrá conflicto.
Paquetes
De hecho, para garantizar absolutamente un
nombre de paquete único, Sun recomienda utilizar
el nombre de dominio de la compañía en Internet
(del cual se sabe que es exclusivo) escrito al revés.
Después se utilizan subpaquetes para los distintos
proyectos.

Por ejemplo, horstmann.com es un dominio que a

registrado uno de los autores del libro Core Java
2. Si se escribe por orden inverso, se convierte en
el paquete com.horstmann. Este paquete se puede
subdividir a su vez en otros subpaquetes, como
Paquetes
El único propósito del anidamiento de paquetes
es disponer de nombres exclusivos. Desde el
punto de vista del compilador, no hay
absolutamente ninguna relación entre paquetes
anidados.

Por ejemplos, los paquetes java.util y

java.util.jar no tienen nada que ver entre sí.
Cada uno está formado por una colección
independiente de clases.
Importación de clases
Las clases pueden utilizar todas las clases de su propio
paquete, así como todas las clases públicas de otros
paquetes.

Se puede acceder a las clases públicas de otros paquetes

de dos maneras.

La primera consiste en añadir simplemente el nombre del

paquete completo delante del nombre de todas las clases.
Por ejemplo:

java.util.Date hoy = new java.util.Date();

Importación de clases
Evidentemente, esto es tedioso.

La forma más sencilla, y más frecuente, consiste en

utilizar la sentencia import.

El objetivo de la sentencia import es, simplemente,

proporcionar una notación abreviada para aludir a las
clases del paquete.

Una vez que se ha utilizado import, ya no hace falta dar

a las clases sus nombre completos.
Importación de clases
Se puede importar una clase concreta, o bien todo el paquete.

Las sentencias import se ponen al principio de los archivos de código

fuente (pero por debajo de toda posible sentencia package).

Por ejemplo, se puede importar todas las clases del paquete java.util
empleando la sentencia

import java.util.*;

Y después se puede utilizar

Date hoy = new Date();

Importación de clases
También se puede importar una clase concreta perteneciente a
un paquete:

import java.util.Date;

La sintaxis java.util.* es menos tediosa. No tiene efectos

negativos sobre el tamaño del código. Sin embargo, si se
importan explícitamente las clases, el lector del código sabrá
cuáles son exactamente las clases que utilizamos.

Sin embargo, observe que solo se puede utilizar la notación *

para importar un único paquete.

No se puede utilizar import java.* o import java.*.* para

Importación de clases
En casi todas las ocasiones, solo importamos los paquetes que se necesitan, sin
preocuparnos demasiados por ellos.

El único caso en que es preciso prestar atención es aquel en que se tiene un

conflicto de nombres.

Por ejemplo, tanto el paquete java.util como el paquete java.sql poseen una
clase llamada Date.

Suponga que escribiera un programa que importase los dos paquetes.

import java.util.*;
import java.sql.*;

Si ahora utiliza la clase Date, se producirá un error de compilación:

Importación de clases
El compilador no puede averiguar cuál de las clases Date queremos emplear. Se
puede resolver el problema añadiendo una sentencia de importación específica:

import java.util.*;
import java.sql.*;
import java.util.Date;

¿Y qué hacemos si realmente se necesitan ambas clases Date?

Entonces es preciso utilizar el nombre completo del paquete con todos los nombres
de clase.

java.util.Date fechaLimite = new java.util.Date();

java.sql.Date hoy = new java.sql.Date(…);

La búsqueda de clases dentro de los paquetes es cuestión del compilador. Los

bytecodes de los archivos de clases siempre utilizan el nombre completo del
Importaciones estáticas
A partir de la versión 5 de Java, la sentencia import se ha mejorado para
admitir la importación de métodos y campos estáticos, y no solo de clases.

Por ejemplo, si se añade la directriz

import static java.lang.System.*;

al principio del archivo de código fuente, entonces se pueden utilizar los

métodos y campos estáticos de la clase System sin anteponer el nombre de la
clase:

out.println( “Adiós, Mundo!” ); // esto es, System.out

exit( 0 ); // estos es, System.exit

También se puede importar un método o campo concreto:

Importaciones estáticas
En la práctica, parece improbable que sean muchos los programadores
que quieran abreviar System.out o System.exit.

El código resultante parece menos claro. Pero las importaciones de

características estáticas tiene dos aplicaciones prácticas:

1.- Funciones matemáticas: si se utiliza una importación estática de la

clase Math, se pueden utilizar las funciones matemáticas de manera
más natural. Por ejemplo,

sqrt( pow( x, 2 ) + pow( y , 2 ) );

resulta mucho más claro que

Importaciones estáticas
2.- Constantes engorrosas: si utilizamos muchas
constantes de nombres tediosos, las importaciones
estáticas van a ser muy bien recibidas. Por ejemplo,

if ( d.get( DAY_OF_WEEK ) == MONDAY )

es más fácil de leer que

if ( d.get( Calendar.DAY_OF_WEEK ) == Calendar.MONDAY )

Creación de paquetes
Los pasos para crear una clase reutilizable dentro de un
paquetes son los siguientes:

1.- Declare una clase como public. Si la clase no es

public, sólo podrá ser utilizada por otras clases dentro
del mismo paquete.

2.-Elija el nombre del paquete y agregue una declaración

package al archivo de código fuente para la declaración
de la clase reutilizable. Sólo puede haber una declaración
package en un archivo de código fuente en Java, y ésta
debe ir antes de cualquier otra declaración o instrucción
en el archivo.
Creación de paquetes
3.- Compile la clase, de manera que se coloque en la estructura de directorio
del paquete apropiado.

4.- Importe la clase reutilizable en un programa y utilícela.

Paso a paso
1.- Para el primer punto, supongamos que se tiene una
clase llamada Tiempo1, en un archivo fuente llamado
Tiempo1.java:

// Tiempo1.java

public class Tiempo1

{
…
…
…
}
Paso a paso
2.- Para cumplir con el paso 2, se debe agregar la sentencia package
al inicio del archivo fuente:

// Tiempo1.java

package com.horstmann.corejava.cap04;

public class Tiempo1

{
…
…
…
}
Paso a paso
3.- Cuando se compila un archivo en Java que contiene una
declaración package, el archivo de clase resultante se coloca en la
estructura de directorio especificada por la declaración package.

La declaración package del paso 2 indica que la clase Tiempo1

debe colocarse en el directorio cap04. Los otros nombres (com,
horstmann y corejava) son también directorios.

Los nombres de directorio en la declaración package especifican la

ubicación exacta de las clases en el paquete.

Si estos directorios no existen antes de compilar la clase, el

compilador puede crearlos.
Paso a paso
Al compilar una clase en un paquete, la opción
de línea de comandos ( -d ) hace que el
compilador javac cree los directorios apropiados,
con base a la declaración package de la clase.

Esta opción también especifica dónde crear (o

ubicar) los directorios. Por ejemplo:

javac –d . Tiempo1.java
Paso a paso
El . después de –d en el comando anterior representa la
carpeta actual.

Después de ejecutar el comando de compilación, la

carpeta actual contiene una carpeta llamada com, com
contiene una carpeta llamada horstmann, horstmann
contiene una carpeta llamada corejava y corejava
contiene una carpeta llamada cap04.

En esta carpeta puede encontrase el archivo

Tiempo1.class
Paso a paso
4.- Una vez compilada la clase y almacenada en su paquete, ésta puede
importarse en los programas.

Supongamos que tenemos un programa llamado PruebaTiempo1.java donde

hacemos uso de la clase Tiempo1:

// PruebaTiempo1.java

import com.horstmann.corejava.cap04.Tiempo1;

public class PruebaTiempo1

{
…
…
…
}
¿Cómo localiza las clases la
máquina virtual?
Como hemos visto, las clases se almacenan en carpetas
del sistema de archivos.

La ruta de la clase debe coincidir con el nombre del

paquete.

También se puede utilizar la utilidad JAR para añadir

clases a un archivo .JAR.

Los archivos .JAR contienen múltiples clases en

carpetas, y de este modo se ahorra espacio y se mejora el
rendimiento.
¿Cómo localiza las clases la
máquina virtual?
Por ejemplo, las miles de clases que contiene la biblioteca de ejecución
están almacenados, todas ellas en el archivo de la biblioteca de ejecución,
denominado rt.jar. Este archivo se encuentra en el subdirectorio jre\lib del
JDK.
¿Cómo localiza las clases la
máquina virtual?
En el ejemplo anterior, la carpeta del paquete com.horstmann.corejava era
una carpeta dentro de la carpeta del programa. Sin embargo, esta
disposición no es demasiado flexible. En general, serán muchos los
programadores que tengan que acceder a los archivos de paquetes. Para
compartir paquetes entre múltiples programas, es necesario hacer lo
siguiente:

1.- Poner las clases en una carpeta especificada (por ejemplo: c:\clases.)
Tenga en cuenta que esta carpeta es la carpeta base para el árbol de
paquetes. Si añade la clase com.horstmann.corejava.cap04.Tiempo01,
entonces el archivo de la clase debe estar ubicado en la carpeta c:\clases\
com\horstmann\corejava\cap04.

2.- Especifique la ruta de clases. La ruta de clases es la colección formada

por todas las carpetas cuyas propias carpetas pueden contener archivos de
clases.
¿Cómo localiza las clases la
máquina virtual?
La forma de establecer la ruta de clases depende del sistema operativo. En
Windows se utiliza el formato:

SET CLASSPATH=C:\CLASES;.;C:\ARCHIVOS\ARCHIVO.JAR

(Nota: En Windows esto se hace en el formulario propiedades del sistema,

en la pestaña Opciones avanzadas y haciendo clic en el botón variables de
entorno. Se añade o modifica la variable de entorno CLASSPATH y dentro
del campo de valor, se escribe la ruta de clases deseada.)

Este ejemplo de ruta de clases contiene:

a) El directorio base (c:\clases)

b) El directorio de trabajo (.)
c) El archivo JAR (c:\archivos\archivo.jar)
¿Cómo localiza las clases la
máquina virtual?
Los archivos de la biblioteca de ejecución
(rt.jar y los demás archivos JAR que
residen en las carpetas jre\lib y jre\lib\ext)
siempre se examinan en busca de clases; no
precisa incluirlos explícitamente en la ruta
de clases.

La ruta de clases enumera las carpetas y

archivos que son puntos de arranque para
¿Cómo localiza las clases la
máquina virtual?
Supongamos que el interprete de java busca el archivo class de la
clase com.horstmann.corejava.cap04.Tiempo01. Primero busca
en los archivos de las clases del sistema, que están almacenadas en
los directorios jre\lib y jre\lib\ext. Allí no va a encontrar la clase,
así que recurre a la ruta de clases. Después busca los archivos
siguientes:

a) c:\clases\com\horstmann\corejava\cap04\Tiempo01.class

b) com\horstmann\corejava\cap04\Tiempo01.class partiendo del

directorio de trabajo

c) com\horstmann\corejava\cap04\Tiempo01.class dentro de c:\

archivos\archivo.jar
¿Cómo localiza las clases la
máquina virtual?
Precaución: El compilador javac siempre busca los
archivos en el directorio de trabajo, pero el interprete de
java solo examina el directorio de trabajo si se ha
incluido el directorio “.” en la ruta de clases.

Si no se ha configurado una ruta de clases, no es

problema: la ruta de clases predeterminada esta formada
por el directorio “.”.

Pero si hemos especificado una ruta de clases y hemos

olvidado incluir el directorio “.”, entonces los programas
se compilarán sin errores, pero no se podrán ejecutar.