Cómo entender y utilizar paquetes Java
[java] ver copia simple
importar java.util.*
clase pública SingleImport
{
public static void main(Strin[] args )
{
ArrayList list=nwe ArrayList()
}
<; p >}Aquí, ArrayList es una clase en el paquete java.util, pero el programa carga el paquete java.util usando la palabra clave import. Pero dado que el programa se carga usando la palabra clave import, no hay una definición o declaración de la clase ArrayList y no hay ningún calificador delante de la clase, por lo que puede usar la clase directamente.
La razón por la que importamos nombres de paquetes es para proporcionar un mecanismo para administrar espacios de nombres. Sabemos que si hay dos clases (Clase A y Clase B) que contienen un método f() con la misma etiqueta de rasgo (lista de parámetros), incluso si usa ambos métodos f() en el mismo código, Tampoco habrá conflicto porque hay dos nombres de clase diferentes como calificadores antes de la portada, por lo que incluso si los dos métodos tienen el mismo nombre, no habrá conflicto. Pero ¿qué pasa si los nombres de las clases entran en conflicto entre sí? Supongamos que escribe una clase de Apple y la instala en una máquina que ya tiene una clase de Apple escrita por otra persona. Debido a que no es fácil determinar qué clases ya están instaladas en una máquina, siempre existe la posibilidad de que se produzcan conflictos potenciales entre los nombres de las clases. En Java resulta muy importante tener control total sobre el espacio de nombres y crear una combinación única de identificadores para cada clase. Si desea escribir una biblioteca de clases o un programa que sea compatible con otros programas Java en la misma máquina, debe considerar cómo evitar conflictos de nombres de clases.
Cuando escribes un archivo de código fuente Java, el archivo a menudo se denomina unidad de compilación. El sufijo de cada unidad de compilación debe ser .java y solo hay una clase pública en la unidad de compilación; de lo contrario, el compilador no aceptará la clase pública. El nombre de la clase pública debe ser el mismo que el nombre del archivo (incluido el caso, pero sin el sufijo .java). Si hay otras clases en la unidad de compilación, estas clases no son visibles fuera del paquete porque no son clases públicas y se utilizan principalmente para brindar soporte a la clase pública principal.
Al compilar un archivo .java (es decir, una unidad de compilación), cada clase en el archivo .java tiene un archivo de salida con el mismo nombre que cada clase en el archivo .java, pero más tiene un .class, por lo que después de compilar una pequeña cantidad de archivos .java, terminará con una gran cantidad de archivos .class. Cada archivo .java compilado contendrá una clase pública y cualquier número de clases no públicas. Entonces, cada archivo .java es un artefacto, y si desea que muchos de esos artefactos pertenezcan al mismo grupo, puede usar la palabra clave paquete en cada archivo .java, y este grupo es una biblioteca de clases.
Si se utiliza una declaración de paquete, debe ser la primera línea de código de programa en el archivo .java excluyendo los comentarios.
Si escribes al inicio del archivo:
paquete fruta;
, indicas que la unidad de compilación es parte de una biblioteca de clases llamada fruta, o en otras palabras, indicas que la unidad de compilación Los nombres de clases públicas en la unidad están bajo el paraguas del nombre de la fruta y están anulados por el nombre de la fruta.
Por ejemplo, suponiendo que el archivo se llame Apple.java, esto significa que solo hay una clase pública en el archivo y el nombre de la clase debe ser Apple (tenga en cuenta el caso):
[ java ] ver copia simple
paquete fruta
clase pública Apple
{
//...
}
El código anterior ha incluido la clase Apple en el paquete de frutas, ahora si alguien quiere usar Apple o cualquier otra clase pública en frutas, debe poner el nombre a disposición en fruta usando la palabra clave import .
[java] Ver copia pura
importar fruta.*
clase pública ImportApple
{
public static void main(String[] args)
{
Apple a=new Apple()
}
}
<; p> O utilice el nombre completo:[java] Ver copia simple
clase pública QualifiedApple
{
public static void main(String[] args)
{
fruta.Apple a=nueva fruta.Apple()
}
}
}
Obviamente, usar la palabra clave import hace que el código sea más conciso.
Como programadores, debemos tener en cuenta que lo que nos permiten las palabras clave package e import es dividir un único espacio de nombres global en espacios de nombres cerrados e independientes, de modo que no importa cuántas personas comiencen a usar las clases escritas en el Internet y Java no tendrán conflictos con los nombres de nuestras clases, porque nuestras clases están encerradas en un espacio de nombres independiente definido por nosotros mismos.
Como ya sabrás, la palabra clave paquete nunca empaqueta algo en un solo archivo, pero un paquete puede estar compuesto por múltiples archivos .class, lo que hace posible poner dos clases con el mismo nombre en un paquete. . Para evitar esto, es razonable colocar todos los archivos .class de un paquete específico en un directorio. Esto significa utilizar la estructura jerárquica de archivos del sistema operativo para resolver el problema. Esta es la forma en que Java resuelve el problema del desorden (las herramientas del paquete JAR no se discutirán aquí).
Colocar todos los archivos en un subdirectorio también resuelve otros dos problemas: primero, cómo crear nombres únicos y, segundo, cómo encontrar clases que pueden estar ocultas en algún lugar de la estructura del directorio.
Estas tareas se realizan codificando el nombre del paquete en la ubicación de la ruta donde se encuentra el archivo .class.
Por convención, la primera parte del nombre del paquete es el nombre de dominio de Internet inverso del creador de la clase.
¿Por qué utilizar nombres de dominio de Internet? Porque si sigue la convención de Internet de que los nombres de dominio deben ser únicos, los nombres de sus paquetes también serán únicos, lo que significa que el espacio de nombres personalizado e independiente que mencionamos anteriormente también será único, por lo que no habrá conflictos de nombres. Por supuesto, si no tiene su propio nombre de dominio, tendrá que crear un nombre de paquete único mediante la creación de un conjunto de combinaciones (como su nombre) que es poco probable que otros copien. Si planeas publicar tu código Java, vale la pena conseguir un nombre de dominio.
Alternativamente, si su código Java solo se ejecuta en la computadora local, puede resolver el nombre del paquete en un directorio en la computadora. Entonces, cuando se ejecuta un programa Java y necesita cargar un archivo .class, puede determinar la ubicación del archivo .class en el directorio según el nombre del paquete.
¿Cómo determinar la ubicación del archivo .class cuando el programa se está ejecutando?
Veamos cómo lo hace el intérprete de Java: Primero, encuentra la variable de entorno CLASSPATH (que puede ser configurada por el sistema operativo). CLASSPATH contiene uno o más directorios donde se encuentran los archivos .class. Comenzando en la raíz, el intérprete toma el nombre del paquete y reemplaza cada punto con una barra invertida, generando una ruta que comienza en la raíz CLASSPATH (por ejemplo, el paquete fruta.Apple se convierte en fruta/Apple o fruta/Apple o lo que sea, depende específicamente de el sistema operativo). El intérprete busca en estos directorios un archivo .class con el mismo nombre que la clase requerida. (Además, el intérprete busca en ciertos directorios estándar en relación con la ubicación del intérprete de Java).
Para entender esto, considere el nombre de dominio Food.net como ejemplo. Invierta el orden y conviértalos todos a minúsculas, y net.food será el único espacio de nombres para la clase que estamos creando. Si decidimos crear otra biblioteca de clases llamada fruta, podemos subdividir aún más el nombre y obtener un nombre de paquete como este:
paquete net.food.fruit
Ahora, este paquete; name se puede utilizar como un espacio de nombres para los siguientes archivos de Apple:
[java] ver copia simple
paquete net.food.fruit
clase pública; Apple
{
public Apple()
{
System.out.println(" net.food.fruit.Apple " );
}
}
}
Este archivo se puede colocar en el siguiente sistema informático. En el directorio:
C:/DOC/JavaT/net/food/fruit
La razón para colocarlo en este directorio es que, como se mencionó anteriormente, el sistema puede pasar fácilmente las variables de entorno CLASSPATH para encontrar este archivo. Mirando hacia atrás a lo largo del camino, puede ver el nombre del paquete net.food.fruit, pero ¿qué pasa con la primera mitad del camino? Déjelo en manos de la variable de entorno CLASSPATH. Podemos configurar la variable de entorno CLASSPATH en la computadora de la siguiente manera:
CHASSPATH=.; D:/JAVA/LIB C:/DOC/JavaT
CLASSPATH puede contener múltiples consultas alternativas; camino. Como puede ver, la tercera ruta en el valor del entorno CLASSPATH anterior es el directorio raíz de nuestro archivo anterior.
Como se mencionó anteriormente, el intérprete de Java primero encontrará el directorio raíz C:/DOC/JavaT, luego lo conectará al nombre del paquete net.food.fruit, convirtiendo los puntos en el nombre del paquete en barras al conectarse, obteniendo así la ruta completa a archivo de clase C:/DOC/JavaT/net/food/fruit.
Una explicación adicional necesaria. La variable de entorno CLASSPATH aquí se refiere a los paquetes en el archivo de clase. Si le preocupa el paquete JAR en el archivo de clase, habrá un ligero cambio, es decir, debe configurar la variable de entorno CLASSPATH. Escriba explícitamente la ruta al nombre real del archivo JAR en, en lugar de simplemente especificar el directorio donde se encuentra el paquete JAR. Es concebible que, dado que puede haber muchos otros paquetes JAR en la ubicación del directorio del paquete JAR, y el archivo de clase que necesitamos usar solo existirá en uno de los paquetes JAR, se puede entender que el paquete JAR en realidad actúa como un directorio de primer nivel en el archivo de directorio, por lo que el nombre del archivo del paquete JAR debe escribirse claramente en la variable de entorno CLASSPATH. Por ejemplo, si los archivos de Apple existen en un archivo JAR llamado fruit.jar, CLASSPATH se escribiría como:
CLASSPATH=.; D:/JAVA/LIB C:/DOC/JavaT/net; /comida/fruta.
Una vez establecida la ruta correctamente, puede colocar los siguientes archivos en cualquier directorio:
[java] ver copia simple
importar net.food.*;
public class LibTest
{
public static void main(String[] args)
{
Apple a=new Apple();
}
}
Cuando el compilador encuentra la declaración de importación de la biblioteca de frutas. , Comenzará a buscar el directorio especificado en CLASSPATH, conectará el directorio raíz establecido en CLASSPATH al subdirectorio net/food/fruit después de convertir el nombre del paquete y luego buscará archivos compilados (es decir, archivos de clase) en el archivo completo. directorio después de la conexión. En el directorio conectado, busque el archivo compilado (es decir, el archivo de clase) que coincida con el nombre (Apple.class en el caso de Apple). Si se encuentra este archivo, se ha encontrado un archivo que coincide con la clase Apple.