Java - Paquetes

Los paquetes se utilizan en Java para evitar conflictos de nombres, controlar el acceso, facilitar la búsqueda / localización y el uso de clases, interfaces, enumeraciones y anotaciones, etc.

UN Package se puede definir como una agrupación de tipos relacionados (clases, interfaces, enumeraciones y anotaciones) que brindan protección de acceso y administración del espacio de nombres.

Algunos de los paquetes existentes en Java son:

  • java.lang - agrupa las clases fundamentales

  • java.io - las clases para las funciones de entrada y salida se incluyen en este paquete

Los programadores pueden definir sus propios paquetes para agrupar grupos de clases / interfaces, etc. Es una buena práctica agrupar las clases relacionadas implementadas por usted para que un programador pueda determinar fácilmente que las clases, interfaces, enumeraciones y anotaciones están relacionadas.

Dado que el paquete crea un nuevo espacio de nombres, no habrá ningún conflicto de nombres con los nombres de otros paquetes. Al usar paquetes, es más fácil proporcionar control de acceso y también es más fácil ubicar las clases relacionadas.

Crear un paquete

Al crear un paquete, debe elegir un nombre para el paquete e incluir un package junto con ese nombre en la parte superior de cada archivo fuente que contiene las clases, interfaces, enumeraciones y tipos de anotaciones que desea incluir en el paquete.

La declaración del paquete debe ser la primera línea del archivo fuente. Solo puede haber una declaración de paquete en cada archivo de origen y se aplica a todos los tipos del archivo.

Si no se utiliza una declaración de paquete, la clase, las interfaces, las enumeraciones y los tipos de anotaciones se colocarán en el paquete predeterminado actual.

Para compilar los programas Java con declaraciones de paquetes, debe usar la opción -d como se muestra a continuación.

javac -d Destination_folder file_name.java

Luego, se crea una carpeta con el nombre de paquete dado en el destino especificado, y los archivos de clase compilados se colocarán en esa carpeta.

Ejemplo

Veamos un ejemplo que crea un paquete llamado animals. Es una buena práctica utilizar nombres de paquetes con letras minúsculas para evitar conflictos con los nombres de clases e interfaces.

El siguiente ejemplo de paquete contiene una interfaz llamada animales :

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Ahora, implementemos la interfaz anterior en el mismo paquete de animales :

package animals;
/* File name : 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();
   }
}

Ahora compile los archivos java como se muestra a continuación:

$ javac -d . Animal.java 
$ javac -d . MammalInt.java

Ahora un paquete / carpeta con el nombre animals se creará en el directorio actual y estos archivos de clase se colocarán en él como se muestra a continuación.

Puede ejecutar el archivo de clase dentro del paquete y obtener el resultado como se muestra a continuación.

Mammal eats
Mammal travels

La palabra clave de importación

Si una clase quiere usar otra clase en el mismo paquete, no es necesario usar el nombre del paquete. Las clases del mismo paquete se encuentran entre sí sin ninguna sintaxis especial.

Ejemplo

Aquí, una clase llamada Jefe se agrega al paquete de nómina que ya contiene Empleado. El Jefe puede entonces referirse a la clase Empleado sin usar el prefijo de nómina, como lo demuestra la siguiente clase Jefe.

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

¿Qué sucede si la clase Empleado no está en el paquete de nómina? La clase Boss debe utilizar una de las siguientes técnicas para hacer referencia a una clase en un paquete diferente.

  • Se puede utilizar el nombre completo de la clase. Por ejemplo
payroll.Employee

  • El paquete se puede importar utilizando la palabra clave import y el comodín (*). Por ejemplo

import payroll.*;
  • La clase en sí se puede importar utilizando la palabra clave import. Por ejemplo
import payroll.Employee;

Note- Un archivo de clase puede contener cualquier número de declaraciones de importación. Las declaraciones de importación deben aparecer después de la declaración del paquete y antes de la declaración de clase.

La estructura de directorio de los paquetes

Se producen dos resultados importantes cuando se coloca una clase en un paquete:

  • El nombre del paquete pasa a formar parte del nombre de la clase, como acabamos de comentar en la sección anterior.

  • El nombre del paquete debe coincidir con la estructura del directorio donde reside el código de bytes correspondiente.

Aquí hay una forma simple de administrar sus archivos en Java:

Coloque el código fuente de una clase, interfaz, enumeración o tipo de anotación en un archivo de texto cuyo nombre sea el nombre simple del tipo y cuya extensión sea .java.

Por ejemplo

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

Ahora, coloque el archivo fuente en un directorio cuyo nombre refleje el nombre del paquete al que pertenece la clase -

....\vehicle\Car.java

Ahora, el nombre de la clase calificada y el nombre de la ruta serían los siguientes:

  • Nombre de clase → vehículo.
  • Nombre de ruta → vehículo \ Car.java (en Windows)

En general, una empresa utiliza su nombre de dominio de Internet invertido para los nombres de sus paquetes.

Example- El nombre de dominio de Internet de una empresa es apple.com, entonces todos los nombres de sus paquetes comenzarían con com.apple. Cada componente del nombre del paquete corresponde a un subdirectorio.

Example - La empresa tenía un paquete com.apple.computers que contenía un archivo fuente Dell.java, estaría contenido en una serie de subdirectorios como este -

....\com\apple\computers\Dell.java

En el momento de la compilación, el compilador crea un archivo de salida diferente para cada clase, interfaz y enumeración definida en él. El nombre base del archivo de salida es el nombre del tipo y su extensión es.class.

Por ejemplo

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Ahora, compile este archivo de la siguiente manera usando la opción -d -

$javac -d . Dell.java

Los archivos se compilarán de la siguiente manera:

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Puede importar todas las clases o interfaces definidas en \ com \ apple \ computers \ de la siguiente manera:

import com.apple.computers.*;

Al igual que los archivos fuente .java, los archivos .class compilados deben estar en una serie de directorios que reflejen el nombre del paquete. Sin embargo, la ruta a los archivos .class no tiene que ser la misma que la ruta a los archivos fuente .java. Puede organizar sus directorios de fuentes y clases por separado, como:

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

Al hacer esto, es posible dar acceso al directorio de clases a otros programadores sin revelar sus fuentes. También necesita administrar los archivos fuente y de clase de esta manera para que el compilador y la máquina virtual Java (JVM) puedan encontrar todos los tipos que usa su programa.

La ruta completa al directorio de clases, <ruta-dos> \ clases, se denomina ruta de clases y se establece con la variable de sistema CLASSPATH. Tanto el compilador como la JVM construyen la ruta a sus archivos .class agregando el nombre del paquete a la ruta de clases.

Digamos que <path-two> \ classes es la classpath y el nombre del paquete es com.apple.computers, luego el compilador y JVM buscarán archivos .class en <path-two> \ classes \ com \ apple \ computers.

Una ruta de clases puede incluir varias rutas. Varias rutas deben estar separadas por un punto y coma (Windows) o dos puntos (Unix). De forma predeterminada, el compilador y la JVM buscan el directorio actual y el archivo JAR que contiene las clases de la plataforma Java para que estos directorios estén automáticamente en la vía de acceso de clases.

Establecer la variable de sistema CLASSPATH

Para mostrar la variable CLASSPATH actual, use los siguientes comandos en Windows y UNIX (shell Bourne):

  • En Windows → C: \> establecer CLASSPATH
  • En UNIX →% echo $ CLASSPATH

Para eliminar el contenido actual de la variable CLASSPATH, use -

  • En Windows → C: \> establecer CLASSPATH =
  • En UNIX →% unset CLASSPATH; exportar CLASSPATH

Para establecer la variable CLASSPATH:

  • En Windows → configure CLASSPATH = C: \ users \ jack \ java \ classes
  • En UNIX →% CLASSPATH = / home / jack / java / classes; exportar CLASSPATH