Paquetes en Java: qué son, para qué se utilizan, y cómo se usan (con vídeo)
Tags: java, spanish
Published: 2019-08-20 08:56:02

---
title: Paquetes en Java: qué son, para qué se utilizan, y cómo se usan (con vídeo)
published: true
tags: Java,Spanish
canonical_url: https://www.campusmvp.es/recursos/post/paquetes-en-java-que-son-para-que-se-utilizan-y-como-se-usan.aspx
cover_image: https://www.campusmvp.es/recursos/image.axd?picture=/2019/3T/paquetes-java.jpg
---

>Post original escrito por Franciso Charte en [campusMVP](https://www.campusmvp.es/recursos/post/paquetes-en-java-que-son-para-que-se-utilizan-y-como-se-usan.aspx)

Los paquetes son el mecanismo que usa Java **para facilitar la modularidad del código**. Un paquete puede contener una o más definiciones de interfaces y clases, distribuyéndose habitualmente como un archivo. Para utilizar los elementos de un paquete es necesario importar este en el módulo de código en curso, usando para ello la sentencia `import`.

La funcionalidad de una aplicación Java se implementa habitualmente en múltiples clases, entre las que suelen existir distintas relaciones. **Las clases se agrupan en unidades de un nivel superior, los paquetes** , que actúan como **ámbitos de contención de tipos**. Cada módulo de código establece, mediante la palabra clave `package` al inicio, a qué paquete pertenece. Como ya sabrás, con la **cláusula `import`** cualquier módulo de código puede hacer referencia a tipos definidos en otros paquetes.

Vamos a familiarizarnos con los procedimientos para construir paquetes, para referenciarlos desde otros puntos y también veremos la **relación existente entre paquetes, clases y el sistema de archivos** donde se almacena el proyecto.

## Creación de paquetes

Un paquete Java se genera sencillamente incluyendo la palabra clave `package` al inicio de los módulos de código en los que se definen las clases que formarán parte del mismo. Trabajando en un proyecto con [NetBeans](https://www.campusmvp.es/recursos/post/Los-mejores-entornos-de-desarrollo-para-Java.aspx), comprobaremos que en la ventana `Projects` los paquetes se representan con un icono específico y actúan como nodos contenedores, alojando los módulos `.java` con el código fuente. El menú contextual del proyecto nos ofrece la opción `New>Java Package`, que será el que usemos habitualmente para crear un nuevo paquete:

![Creación de un nuevo paquete en Netbeans](https://www.campusmvp.es/recursos/image.axd?picture=/2019/3T/NewPackage.png)

> **Nota** : cada vez que se crea un nuevo proyecto con NetBeans se propone la definición de un nuevo paquete, cuyo nombre sería el mismo del proyecto, donde se alojarían los módulos de código. En proyectos complejos, no obstante, puede ser necesaria la **creación de paquetes adicionales**.

Un paquete puede contener, además de definiciones de tipos como las clases e interfaces, otros paquetes, **dando lugar a estructuras jerárquicas de contenedores**. La denominación de los **subpaquetes, paquetes contenidos en otros** , se compondrán del identificador del contenedor seguido de un punto y el nombre del subpaquete. De existir niveles adicionales se agregarían los distintos identificadores separados por puntos, formando así el nombre completo del paquete.

El diagrama siguiente representa el contenido de un paquete llamado `campusmvp`, teóricamente correspondiente a un proyecto de aplicación de contabilidad. En ese paquete de primer nivel tenemos un subpaquete con utilidades, llamado `campusmvp.util`, no directamente vinculadas con la aplicación de contabilidad. El subpaquete `campusmvp.conta` contendría todos los elementos asociados a dicha aplicación, distribuidos a su vez en un tercer nivel de paquetes que contienen las clases correspondientes al modelo, la vista, etc., siguiendo al **[patrón arquitectónico MVC](https://es.wikipedia.org/wiki/Modelo%E2%80%93vista%E2%80%93controlador)**. Cada uno de los módulos de definición de clase, denominados `Cuenta.java`, `Movimiento.java`, `Vista.java`, etc., comenzarían con una cláusula `package` indicando **el nombre completo del paquete al que pertenecen** :

![Estructura jerárquica de paquetes](https://www.campusmvp.es/recursos/image.axd?picture=/2019/3T/NestedPackages.png)

> **Nota** : todas las clases que pertenecen a un mismo paquete comparten un ámbito común, al que pertenecerán aquellos miembros que no especifiquen explícitamente otro tipo de visibilidad.

## Importación de paquetes

**Los paquetes Java son como cajas de herramientas** , cada una de ellas con una colección distinta de instrumentos útiles para nuestro trabajo, a las que podemos necesitar acceder cada vez que abordamos el desarrollo de un nuevo proyecto. Es en este contexto donde recurriremos a la cláusula **`import`** , a fin de **importar en el ámbito actual las definiciones de otro paquete y poder usarlas** según el procedimiento habitual, creando objetos, accediendo a los servicios de las clases, etc.

La cláusula `import` puede utilizarse para importar un elemento concreto de un paquete, facilitando el nombre de este seguido de un punto y el identificador de dicho elemento. Por ejemplo, para importar la clase `Math` del paquete `java.lang`, pudiendo así acceder a la constante `PI` y las funciones matemáticas que aporta, bastaría con la siguiente línea:

```
import java.lang.Math;
```

Es habitual que al importar un paquete nos interesen muchas de las clases definidas en el mismo. En este caso podríamos importarlas individualmente, usando la sintaxis anterior, o bien podríamos recurrir a la siguiente alternativa. Esto nos permitiría usar la clase `Math`, así como la clase `System`, la clase `Thread` y muchas otras definidas en el paquete `java.lang`:

```
import java.lang.\*;
```

En ocasiones, como ocurre con la clase `Math`, **importamos una clase para acceder directamente a sus miembros estáticos, constantes y métodos** , no para crear objetos a partir de ellas, lo que nos fuerza a utilizar constantemente la sintaxis `Clase.miembro`, por ejemplo `Math.PI` o `Math.sin()`. Si tras importar la clase `Math` intentamos referirnos a estos miembros simplemente por su nombre, como se hace en la mitad superior de la siguiente imagen, obtendremos un error. En estos casos podemos recurrir a la sintaxis **`import static paquete.clase.*`** , cuya finalidad es **incluir en el ámbito actual los miembros estáticos de la clase indicada**. Es lo que se hace en la mitad inferior de la siguiente imagen:

![Importación de paquetes](https://www.campusmvp.es/recursos/image.axd?picture=/2019/3T/ImportStatic.png "Distintas alternativas para hacer referencia al contenido de paquetes Java")

## Relación entre clases, paquetes y el sistema de archivos

En Java existe una estrecha relación entre **las definiciones de paquetes y clases y el sistema de archivos local** , en el que se almacenan los módulos conteniendo el código. Es un hecho que puede pasarnos totalmente inadvertido al trabajar con un IDE como el de NetBeans, ya que sus opciones se encargan de ocultar estos detalles. No obstante, **es interesante que conozcamos dicha relación** ya que esto nos permitirá, en caso de necesidad, trabajar directamente con el JDK.

Cada módulo de código de un proyecto Java únicamente puede contener una clase pública, cuyo nombre, respetando mayúsculas y minúsculas, debe coincidir con el del módulo. Es decir, existe una **correspondencia directa entre los identificadores de clase y archivos en los que se alojan**. Esto no afecta a las clases anidadas y otras clases no públicas que pudiesen definirse en el mismo módulo.

El **nombre del paquete establece además el nombre de la carpeta donde se alojan los módulos de código** contenidos en el paquete. Los nombres de paquete pueden ser compuestos, usándose el punto como separador de las diferentes porciones del identificador. Cada parte identificaría a un subdirectorio, según se muestra en el siguiente esquema:

![Esquema sistema de archivos](https://www.campusmvp.es/recursos/image.axd?picture=/2019/3T/FilesystemScheme.png "Esquema de la correspondencia entre el sistema de archivos y la definición de paquetes y clases")

Al trabajar desde la línea de comandos, usando directamente el JDK, hemos de tener en cuenta que tanto la compilación como la ejecución verificarán que se **satisface la correspondencia entre el nombre de paquete y clase y la estructura de directorios y nombre de archivo**. Si esta no se cumple en algún punto, como ocurre en la parte inferior de la siguiente imagen, se obtiene un error.

![Relación entre paquete y sistema de archivos](https://www.campusmvp.es/recursos/image.axd?picture=/2019/3T/PackageFilesystem.png "La clase Cuenta pertenece al paquete com.campusmvp.contabilidad, denominación que condiciona la jerarquía de carpetas en el sistema de archivos")

> **Nota** : la estructura de directorios de un paquete puede almacenarse completa, una vez se compila el proyecto, en un archivo JAR. Este contendría asimismo los archivos de clase de cada módulo de código.

A continuación puedes ver un **vídeo práctico explicativo** de todo lo anterior, que está extraído directamente del **[curso de programación con Java](https://www.campusmvp.es/recursos/catalogo/Product-Desarrollo-de-aplicaciones-con-la-plataforma-Java_231.aspx)** de campusMVP:

{% youtube x4BDc-VGeZY%}

>Post original escrito por Franciso Charte en [campusMVP](https://www.campusmvp.es/recursos/post/paquetes-en-java-que-son-para-que-se-utilizan-y-como-se-usan.aspx)