Guida ai pacchetti Java

1. Introduzione

In questo rapido tutorial, tratteremo le basi dei pacchetti in Java. Vedremo come creare pacchetti e accedere ai tipi che inseriamo al loro interno.

Discuteremo anche delle convenzioni di denominazione e di come si relazionano alla struttura di directory sottostante.

Infine, compileremo ed eseguiremo le nostre classi Java pacchettizzate.

2. Panoramica dei pacchetti Java

In Java, utilizziamo i pacchetti per raggruppare classi, interfacce e sotto-pacchetti correlati .

I principali vantaggi di questa operazione sono:

  • Rendere i tipi correlati più facili da trovare: i pacchetti di solito contengono tipi che sono correlati logicamente
  • Evitare conflitti di denominazione: un pacchetto ci aiuterà a identificare in modo univoco una classe; ad esempio, potremmo avere una com.baeldung.Application, così come com.example.Application classi
  • Controllo dell'accesso: possiamo controllare la visibilità e l'accesso ai tipi combinando pacchetti e modificatori di accesso

Successivamente, vediamo come possiamo creare e utilizzare i pacchetti Java.

3. Creazione di un pacchetto

Per creare un pacchetto, dobbiamo usare l' istruzione pacchetto aggiungendola come la prima riga di codice in un file .

Mettiamo un tipo in un pacchetto chiamato com.baeldung.packages :

package com.baeldung.packages;

Si consiglia vivamente di inserire ogni nuovo tipo in un pacchetto. Se definiamo i tipi e non li inseriamo in un pacchetto, andranno nel pacchetto predefinito o senza nome. L'utilizzo dei pacchetti predefiniti presenta alcuni svantaggi:

  • Perdiamo i vantaggi di avere una struttura a pacchetti e non possiamo avere sotto-pacchetti
  • Non possiamo importare i tipi nel pacchetto predefinito da altri pacchetti
  • Gli ambiti di accesso protetto e privato del pacchetto sarebbero privi di significato

Come afferma la specifica del linguaggio Java, i pacchetti senza nome vengono forniti dalla piattaforma Java SE principalmente per comodità durante lo sviluppo di applicazioni piccole o temporanee o quando lo sviluppo è appena iniziato.

Pertanto, dovremmo evitare di utilizzare pacchetti senza nome o predefiniti nelle applicazioni del mondo reale .

3.1. Convenzioni di denominazione

Per evitare pacchetti con lo stesso nome, seguiamo alcune convenzioni di denominazione:

  • definiamo i nomi dei nostri pacchetti in minuscolo
  • i nomi dei pacchetti sono delimitati da punti
  • i nomi sono determinati anche dalla società o dall'organizzazione che li crea

Per determinare il nome del pacchetto in base a un'organizzazione, in genere inizieremo invertendo l'URL dell'azienda. Successivamente, la convenzione di denominazione viene definita dalla società e può includere nomi di divisione e nomi di progetto.

Ad esempio, per creare un pacchetto da www.baeldung.com , invertiamolo:

com.baeldung

Possiamo quindi definire ulteriormente i sotto-pacchetti di questo, come com.baeldung.packages o com.baeldung.packages.domain.

3.2. Struttura delle directory

I pacchetti in Java corrispondono a una struttura di directory.

Ogni pacchetto e sottopacchetto ha la propria directory. Quindi, per il pacchetto com.baeldung.packages , dovremmo avere una struttura di directory com -> baeldung -> packages .

La maggior parte degli IDE aiuterà a creare questa struttura di directory basata sui nomi dei nostri pacchetti, quindi non dobbiamo crearli manualmente.

4. Utilizzo dei membri del pacchetto

Iniziamo definendo una classe TodoItem in un sottopacchetto denominato dominio :

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

4.1. Importazioni

Per poter utilizzare la nostra classe TodoItem da una classe in un altro pacchetto, dobbiamo importarla. Una volta importato, possiamo accedervi per nome.

Possiamo importare un singolo tipo da un pacchetto o utilizzare un asterisco per importare tutti i tipi in un pacchetto.

Importiamo l'intero sottopacchetto del dominio :

import com.baeldung.packages.domain.*;

Ora, importiamo solo la classe TodoItem :

import com.baeldung.packages.domain.TodoItem;

Anche JDK e altre librerie Java vengono fornite con i propri pacchetti. Possiamo importare classi preesistenti che vogliamo utilizzare nel nostro progetto allo stesso modo.

Ad esempio, importiamo l' interfaccia Java core List e la classe ArrayList :

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

Possiamo quindi utilizzare questi tipi nella nostra applicazione semplicemente usando il loro nome:

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.

Il codice di esempio completo è disponibile su GitHub.