Paquetes (package) de Java

Para organizar mejor las clases, Java ofrece el mecanismo de paquetes, que se utiliza para distinguir el espacio de nombres de los nombres de las clases.

El papel del paquete

• 1, organizar clases o interfaces con funcionalidades similares o relacionadas en el mismo paquete, lo que facilita la búsqueda y uso de clases.

• 2, al igual que las carpetas, los paquetes también utilizan una forma de almacenamiento de directorio jerárquico. Los nombres de las clases en el mismo paquete son diferentes, y los nombres de las clases en diferentes paquetes pueden ser los mismos. Cuando se llama a clases con nombres idénticos en dos paquetes diferentes, se debe agregar el nombre del paquete para distinguirlos. Por lo tanto, los paquetes pueden evitar conflictos de nombres.

• 3, los paquetes también limitan los permisos de acceso, solo las clases con permisos de acceso al paquete pueden acceder a las clases en un paquete.

Java utiliza este mecanismo de paquete (paquete) para evitar conflictos de nombres, controlar el acceso, proporcionar búsqueda y ubicación de clases (class), interfaces, enumeraciones (enumerations) y comentarios (annotations).

El formato de la sintaxis de la declaración del paquete es:

package pkg1[．pkg2[．pkg3...]];

Por ejemplo, el contenido de un archivo Something.java

package net.java.util;
public class Something{
　　　...
}

Entonces, su ruta debería ser net/java/util/Something.java De esta manera se almacena. El papel del paquete (paquete) es clasificar y almacenar diferentes programas java, facilitando que otros programas java los llamen.

Un paquete (paquete) se puede definir como un grupo de tipos relacionados (clases, interfaces, enumeraciones y comentarios), proporcionando funcionalidades de protección de acceso y gestión de espacio de nombres para estos tipos.

A continuación, se presentan algunos paquetes en Java:

• java.lang-Empaquetar las clases básicas

• java.io-Funciones con funcionalidades de entrada y salida

Los desarrolladores pueden paquetizar un grupo de clases e interfaces y definir su propio paquete. Además, en la práctica de desarrollo, es muy recomendable hacer así, ya que al completar la implementación de las clases, agrupar las clases relacionadas permite a otros desarrolladores determinar más fácilmente qué clases, interfaces, enumeraciones y comentarios son relacionados.

Dado que el paquete crea un nuevo espacio de nombres (namespace), no habrá conflicto de nombres con cualquier otro paquete. Al usar este mecanismo de paquete, es más fácil implementar el control de acceso y facilitar la ubicación de clases relacionadas.

Crear paquete

Al crear un paquete, necesitas dar un nombre adecuado a este paquete. Después de eso, si otro archivo de origen contiene clases, interfaces, enumeraciones o tipos de comentarios proporcionados por este paquete, deben colocarse la declaración de este paquete al principio de este archivo.

La declaración del paquete debe estar en la primera línea del archivo de origen, y solo puede haber una declaración de paquete en cada archivo, aplicándose a cada tipo en este archivo.

Si en un archivo de origen no se utiliza la declaración de paquete, las clases, funciones, enumeraciones, comentarios y otros se pondrán en un paquete sin nombre (unnamed package).

实例

Veamos un ejemplo, este ejemplo crea un paquete llamado animals. Por lo general, se utilizan letras minúsculas para nombrar para evitar conflictos con nombres de clases e interfaces.

Agregue una interfaz (interface) al paquete animals:

/*　Nombre del archivo:　Animal.java　*/
package　animals;
　
interface　Animal　{
　　　public　void　eat();
　　　public　void　travel();
}

A continuación, agregue la implementación de esta interfaz en el mismo paquete:

package　animals;
　
/*　Nombre del archivo:　MammalInt.java　*/
public　class　MammalInt　implements　Animal{
　
　　　public　void　eat(){
　　　　　　System.out.println("Mammal　eats");
　　　}
　
　　　public　void　travel(){
　　　　　　System.out.println("Mammal　travels");
　　　}　
　
　　　public　int　noOfLegs(){
　　　　　　return　0;
　　　}
　
　　　public　static　void　main(String　args[]){
　　　　　　MammalInt　m　=　new　MammalInt();
　　　　　　m.eat();
　　　　　　m.travel();
　　　}
}

Luego, compile estos dos archivos y colóquelos en un subdirectorio llamado animals. Ejecute el siguiente comando para ejecutar:

$　mkdir　animals
$　cp　Animal.class　　MammalInt.class　animals
$　java　animals/MammalInt
Mammal　eats
Mammal　travel

palabra clave import

Para poder usar los miembros de un paquete específico, necesitamos importar explícitamente ese paquete en el programa Java. La instrucción "import" permite realizar esta función.

En los archivos de origen de Java, las instrucciones import deben ubicarse después de la instrucción package y antes de cualquier definición de clase, pueden no haber y pueden haber varias, y su formato de sintaxis es:

import　package1[.package2...(classname|*);

Si un clase dentro de un paquete desea usar otra clase de ese paquete, el nombre del paquete puede omitirse.

实例

下面的 payroll 包已经包含了 Employee 类，接下来向 payroll 包中添加一个 Boss 类。Boss 类引用 Employee 类的时候可以不用使用 payroll 前缀，Boss 类的示例如下。

package　payroll;
　
public　class　Boss
{
　　　public　void　payEmployee(Employee　e)
　　　{
　　　　　　e.mailCheck();
　　　}
}

如果 Boss 类不在 payroll 包中又会怎样？Boss 类必须使用下面几种方法之一来引用其他包中的类。

使用类全名描述，例如：

payroll.Employee

用 import 关键字引入，使用通配符 "*"

import　payroll.*;

使用 import 关键字引入 Employee 类:

import　payroll.Employee;

注意：

类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

package 的目录结构

类放在包中会有两种主要的结果：

• 包名成为类名的一部分，正如我们前面讨论的一样。

• 包名必须与相应的字节码所在的目录结构相吻合。

下面是管理你自己 java 中文件的一种简单方式：

将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java作为扩展名。例如：

//　文件名　:　　Car.java
　
package　vehicle;
　
public　class　Car　{
　　　//　类实现　　
}

接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。

....\vehicle\Car.java

现在，正确的类名和路径将会是如下样子：

• 类名 ->　vehicle.Car

• 路径名 ->　vehicle\Car.java (在 windows 系统中)

通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 oldtoolbag.com，所有的包名都以 com.w3codebox 开头。包名中的每一个部分对应一个子目录。

例如：有一个 com.w3codebox.test 的包，这个包包含一个叫做 w3Si tienes el archivo de origen codebox.java, entonces debe haber una serie de subdirectorios como se muestra a continuación:

....\com\w3codebox\test\w3codebox.java

Durante la compilación, el compilador crea un archivo de salida diferente para cada clase, interfaz y otro tipo definido en el paquete, y el nombre del archivo de salida es el nombre del tipo, más .class como extensión. Por ejemplo:

//　Nombre del archivo: w3codebox.java
　
package com.w3codebox.test;
public class w3codebox {
　　　　　　
}
class Google {
　　　　　　
}

Ahora, usamos-usar la opción d para compilar este archivo, como se muestra a continuación:

$javac　-d　.　w3codebox.java

De esta manera, los archivos compilados se colocarán como se muestra a continuación:

.\com\w3codebox\test\w3codebox.class
.\com\w3codebox\test\Google.class

Puedes importar todos de la siguiente manera \com\w3codebox\test\ Clases, interfaces y otros definidos en:

import com.w3codebox.test.*;

Los archivos .class compilados deben estar en el mismo directorio que los archivos .java de origen, y el directorio debe coincidir con el nombre del paquete. Sin embargo, no se requiere que la ruta del archivo .class sea la misma que la del archivo .java correspondiente. Puedes organizar separadamente los directorios de código fuente y clases.

<path-one>\sources\com\w3codebox\test\w3codebox.java
<path-two>\classes\com\w3codebox\test\Google.class

De esta manera, puedes compartir tu directorio de clases con otros programadores sin revelar tu código fuente. Gestionar el código fuente y los archivos de clase de esta manera permite que el compilador y el motor JVM (JVM) encuentren todos los tipos utilizados en tu programa.

La ruta absoluta del directorio de clases se llama class path. Se establece en la variable de sistema CLASSPATH En este directorio. El compilador y el motor java virtual (JVM) construyen la ruta de los archivos .class al agregar el nombre del paquete al class path.

<path- two>\classes es el class path, y el nombre del paquete es com.w3codebox.test, mientras que el compilador y JVM buscarán en <path-two>\classes\com\w3Buscar archivos .class en codebox\test.

Una class path puede contener varios caminos, y los múltiples caminos deben separarse con un separador. Por defecto, el compilador y JVM buscan en el directorio actual. Los archivos JAR contienen clases relacionadas con la plataforma Java, por lo que sus directorios se colocan por defecto en el class path.

Configurar la variable de sistema CLASSPATH

Usar la siguiente orden para mostrar la variable de sistema CLASSPATH actual:

• Plataforma Windows (línea de comandos DOS): C:\> set CLASSPATH

• Plataforma UNIX (Bourne shell): # echo $CLASSPATH

Eliminar el contenido actual de la variable de sistema CLASSPATH:

• Plataforma Windows (línea de comandos DOS): C:\> set CLASSPATH=

• Plataforma UNIX (Bourne shell): # unset CLASSPATH; export CLASSPATH

Configurar variable de sistema CLASSPATH:

• Plataforma Windows (línea de comandos DOS): C:\> set CLASSPATH=C:\users\jack\java\classes

• Plataforma UNIX (Bourne shell): # CLASSPATH=/home/jack/java/classes; export CLASSPATH