Paquetes de Clases

Todas las clases que se encuentran en archivos de un mismo directorio forman un mismo paquete. Los paquetes se organizan a su vez en una jerarquía de paquetes. En la siguiente figura se aprecia un jerarquía de paquetes.

Los paquetes se referencian en una forma similar a la jerarquía de directorios en Unix o DOS, separando los nombres de paquetes con un '.'. En la figura se aprecian los siguientes paquetes:

P  Q  P.R

Las clases se accesan referenciando primero el paquete en que se encuentran y luego el nombre de la clase:

El paquete P contiene las clases P.B y P.C
El paquete Q contiene las clases Q.B y Q.D
El paquete P.R contiene la clase P.R.D

Si una clase no pertenece a un paquete específico se coloca en un paquete por omisión y en este caso se accesan directamente por su nombre. Este es el caso de las clases A y B.

Consideraciones al usar paquetes:

Toda clase especifica el paquete al cual pertenece con la cláusula package que se coloca al comienzo del archivo:
```
package P.R;
```
Si el archivo no contiene esta cláusula entonces el paquete se coloca en un paquete por omisión.
Una clase se nombra a través de la siguiente sintaxis:
paquete.clase
Por ejemplo en:
```
package Q;

... P.R.D.M() ...

... B.N() ...
```
La primera referencia es la método M de la clase D que está en el paquete P.R.
En la segunda referencia no se especifica el paquete. En este caso se busca la clase B en el mismo paquete en donde aparece la referencia, es decir D. Por lo tanto se trata de Q.B y no P.B.
Para no tener que especificar el paquete cada vez que se menciona una clase (de otro paquete), se usa la cláusula import. La sintaxis es:
import paquete.clase;
import paquete.*;
En el primer caso se interna el nombre de una clase específica de un paquete, la cuál podrá ser nombrada directamente como clase en el archivo que contiene la cláusula import.
En el segundo caso se internan todas las clases de un paquete. Todas ellas se conocerán directamente por su nombre sin necesidad de colocar el paquete.
Por ejemplo:
```
package Q;
import P.C;
... C ... // es P.C
```
O bien en otro archivo del paquete P.R:
```
package P.R;
import Q.*;
... B ... // es Q.B
```
En caso de ambiguedad será necesario incluir el nombre del paquete.
Al referenciar una clase dada, él archivo que la contiene se busca usando la variable de ambiente CLASSPATH (esta variable se define a nivel del intérprete de comandos del sistema operativo). Supongamos que CLASSPATH tiene ".:/home/yo/classes:otrodir", entonces la clase P.R.D se buscará en los siguientes archivos:
```
./P/R/D.class
/home/yo/classes/P/R/D.class
otrodir/P/R/D.class
biblioteca de Java/P/R/D.class
```
Si la clase no se encuentra en ninguno de estos archivos, es un error. Esta búsqueda se realiza tanto al compilar como al ejecutar. Si al momento de accesar una clase ésta todavía no se encuentra compilada, es decir sólo se encuentra el archivo fuente, entonces se compila.

El método main

Un programa se ejecuta con el comando java. Este comando recibe el nombre de una clase seguido de una lista de argumentos:

java paquete.clase argumento, ...

El intérprete busca la clase especificada usando el método descrito anteriormente. Luego en esta clase busca un método que tenga la siguiente declaración:

public static void main(String args[]) { ... }

Si no se encuentra es un error. Posteriormente, el intérprete busca y carga (recursivamente) todas las clases que necesite la clase especificada. Luego ejecuta el código de inicialización de todas las clases.

Finalmente, el intérprete invoca el método main, pasándole en args todos los argumentos encontrados en la línea de comando.