Guía de paquetes de Java

1. Introducción

En este tutorial rápido, cubriremos los conceptos básicos de los paquetes en Java. Veremos cómo crear paquetes y acceder a los tipos que colocamos dentro de ellos.

También discutiremos las convenciones de nomenclatura y cómo se relacionan con la estructura del directorio subyacente.

Finalmente, compilaremos y ejecutaremos nuestras clases Java empaquetadas.

2. Descripción general de los paquetes de Java

En Java, usamos paquetes para agrupar clases, interfaces y subpaquetes relacionados .

Los principales beneficios de hacer esto son:

  • Haciendo que los tipos relacionados sean más fáciles de encontrar: los paquetes generalmente contienen tipos que están relacionados lógicamente
  • Evitar conflictos de nombres: un paquete nos ayudará a identificar de forma única una clase; por ejemplo, podríamos tener una com.baeldung.Application, así como clases com.example.Application
  • Controlar el acceso: podemos controlar la visibilidad y el acceso a los tipos combinando paquetes y modificadores de acceso.

A continuación, veamos cómo podemos crear y usar paquetes Java.

3. Creación de un paquete

Para crear un paquete, tenemos que usar la declaración del paquete agregándola como la primera línea de código en un archivo .

Coloquemos un tipo en un paquete llamado com.baeldung.packages :

package com.baeldung.packages;

Se recomienda encarecidamente colocar cada tipo nuevo en un paquete. Si definimos tipos y no los colocamos en un paquete, irán en el paquete predeterminado o sin nombre. El uso de paquetes predeterminados tiene algunas desventajas:

  • Perdemos los beneficios de tener una estructura de paquete y no podemos tener subpaquetes.
  • No podemos importar los tipos en el paquete predeterminado de otros paquetes.
  • Los ámbitos de acceso protegido y privado del paquete no tendrían sentido

Como indica la especificación del lenguaje Java, la plataforma Java SE proporciona paquetes sin nombre principalmente para su conveniencia al desarrollar aplicaciones pequeñas o temporales o cuando recién se inicia el desarrollo.

Por lo tanto, debemos evitar el uso de paquetes predeterminados o sin nombre en aplicaciones del mundo real .

3.1. Convenciones de nombres

Para evitar paquetes con el mismo nombre, seguimos algunas convenciones de nomenclatura:

  • definimos los nombres de nuestros paquetes en minúsculas
  • los nombres de los paquetes están delimitados por períodos
  • Los nombres también los determina la empresa u organización que los crea.

Para determinar el nombre del paquete en función de una organización, normalmente comenzaremos invirtiendo la URL de la empresa. Después de eso, la convención de nomenclatura la define la empresa y puede incluir nombres de divisiones y nombres de proyectos.

Por ejemplo, para hacer un paquete con www.baeldung.com , invirtámoslo :

com.baeldung

Luego podemos definir más subpaquetes de esto, como com.baeldung.packages o com.baeldung.packages.domain.

3.2. Estructura de directorios

Los paquetes en Java se corresponden con una estructura de directorio.

Cada paquete y subpaquete tiene su propio directorio. Entonces, para el paquete com.baeldung.packages , deberíamos tener una estructura de directorio de com -> baeldung -> packages .

La mayoría de los IDE ayudarán a crear esta estructura de directorio basada en los nombres de nuestros paquetes, por lo que no tenemos que crearlos a mano.

4. Uso de miembros del paquete

Comencemos por definir una clase TodoItem en un subpaquete llamado dominio :

package com.baeldung.packages.domain; public class TodoItem { private Long id; private String description; // standard getters and setters }

4.1. Importaciones

Para usar nuestra clase TodoItem de una clase en otro paquete, necesitamos importarla. Una vez que se importa, podemos acceder a él por su nombre.

Podemos importar un solo tipo de un paquete o usar un asterisco para importar todos los tipos en un paquete.

Vamos a la importación de todo el dominio sub-paquete:

import com.baeldung.packages.domain.*;

Ahora, importemos solo la clase TodoItem :

import com.baeldung.packages.domain.TodoItem;

El JDK y otras bibliotecas de Java también vienen con sus propios paquetes. Podemos importar clases preexistentes que queramos usar en nuestro proyecto de la misma manera.

Por ejemplo, importemos la interfaz Java core List y la clase ArrayList :

import java.util.ArrayList;import java.util.List;

Luego podemos usar estos tipos en nuestra aplicación simplemente usando su nombre:

public class TodoList { private List todoItems; public void addTodoItem(TodoItem todoItem) { if (todoItems == null) { todoItems = new ArrayList(); } todoItems.add(todoItem); } }

Here, we've used our new classes along with Java core classes, to create a List of ToDoItems.

4.2. Fully Qualified Name

Sometimes, we may be using two classes with the same name from different packages. For example, we might be using both java.sql.Date and java.util.Date. When we run into naming conflicts, we need to use a fully qualified class name for at least one of the classes.

Let's use TodoItem with a fully qualified name:

public class TodoList { private List todoItems; public void addTodoItem(com.baeldung.packages.domain.TodoItem todoItem) { if (todoItems == null) { todoItems = new ArrayList(); }todoItems.add(todoItem); } // standard getters and setters }

5. Compiling with javac

When it's time to compile our packaged classes, we need to remember our directory structure. Starting in the source folder, we need to tell javac where to find our files.

We need to compile our TodoItem class first because our TodoList class depends on it.

Let's start by opening a command line or terminal and navigating to our source directory.

Now, let's compile our com.baeldung.packages.domain.TodoItem class:

> javac com/baeldung/packages/domain/TodoItem.java

If our class compiles cleanly, we'll see no error messages and a file TodoItem.class should appear in our com/baeldung/packages/domain directory.

For types that reference types in other packages, we should use the -classpath flag to tell the javac command where to find the other compiled classes.

Now that our TodoItem class is compiled, we can compile our TodoList and TodoApp classes:

>javac -classpath . com/baeldung/packages/*.java

Again, we should see no error messages and we should find two class files in our com/baeldung/packages directory.

Let's run our application using the fully qualified name of our TodoApp class:

>java com.baeldung.packages.TodoApp

Our output should look like this:

6. Conclusion

In this short article, we learned what a package is and why we should use them.

We discussed naming conventions and how packages relate to the directory structure. We also saw how to create and use packages.

Finally, we went over how to compile and run an application with packages using the javac and java commands.

El código de ejemplo completo está disponible en GitHub.