Guide des packages Java

1. Introduction

Dans ce rapide tutoriel, nous aborderons les bases des packages en Java. Nous verrons comment créer des packages et accéder aux types que nous y plaçons.

Nous discuterons également des conventions de dénomination et de leur relation avec la structure de répertoires sous-jacente.

Enfin, nous compilerons et exécuterons nos classes Java packagées.

2. Présentation des packages Java

En Java, nous utilisons des packages pour regrouper les classes, interfaces et sous-packages associés .

Les principaux avantages de cette opération sont:

  • Rendre les types associés plus faciles à trouver - les packages contiennent généralement des types qui sont logiquement liés
  • Éviter les conflits de noms - un package nous aidera à identifier de manière unique une classe; par exemple, nous pourrions avoir une classe com.baeldung.Application, ainsi que des classes com.example.Application
  • Contrôle de l'accès - nous pouvons contrôler la visibilité et l'accès aux types en combinant des packages et des modificateurs d'accès

Ensuite, voyons comment nous pouvons créer et utiliser des packages Java.

3. Création d'un package

Pour créer un package, nous devons utiliser l' instruction package en l'ajoutant comme toute première ligne de code dans un fichier .

Plaçons un type dans un package nommé com.baeldung.packages :

package com.baeldung.packages;

Il est fortement recommandé de placer chaque nouveau type dans un package. Si nous définissons des types et ne les plaçons pas dans un package, ils iront dans le package par défaut ou sans nom. L'utilisation de packages par défaut présente quelques inconvénients:

  • Nous perdons les avantages d'avoir une structure de package et nous ne pouvons pas avoir de sous-packages
  • Nous ne pouvons pas importer les types dans le package par défaut à partir d'autres packages
  • Les étendues d'accès protégées et privées du package n'auraient aucun sens

Comme l'indique la spécification du langage Java, les packages sans nom sont fournis par la plate-forme Java SE principalement pour plus de commodité lors du développement d'applications petites ou temporaires ou au début du développement.

Par conséquent, nous devons éviter d'utiliser des packages sans nom ou par défaut dans des applications du monde réel .

3.1. Conventions de nommage

Afin d'éviter les paquets avec le même nom, nous suivons certaines conventions de dénomination:

  • nous définissons nos noms de packages en minuscules
  • les noms de package sont délimités par des points
  • les noms sont également déterminés par l'entreprise ou l'organisation qui les crée

Pour déterminer le nom du package en fonction d'une organisation, nous commencerons généralement par inverser l'URL de l'entreprise. Après cela, la convention de dénomination est définie par l'entreprise et peut inclure des noms de division et des noms de projet.

Par exemple, pour créer un package à partir de www.baeldung.com , inversons -le:

com.baeldung

Nous pouvons ensuite définir des sous-packages de celui-ci, comme com.baeldung.packages ou com.baeldung.packages.domain.

3.2. Structure du répertoire

Les packages en Java correspondent à une structure de répertoires.

Chaque package et sous-package a son propre répertoire. Donc, pour le package com.baeldung.packages , nous devrions avoir une structure de répertoire de com -> baeldung -> packages .

La plupart des IDE vous aideront à créer cette structure de répertoires basée sur nos noms de paquets, nous n'avons donc pas à les créer à la main.

4. Utilisation des membres du package

Commençons par définir une classe TodoItem dans un sous-paquet nommé domain :

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

4.1. Importations

Afin d'utiliser notre classe TodoItem à partir d'une classe dans un autre package, nous devons l'importer. Une fois importé, nous pouvons y accéder par son nom.

Nous pouvons importer un seul type d'un package ou utiliser un astérisque pour importer tous les types d'un package.

L'importation Let l'ensemble domaine de subpackage:

import com.baeldung.packages.domain.*;

Maintenant, importons uniquement la classe TodoItem :

import com.baeldung.packages.domain.TodoItem;

Le JDK et d'autres bibliothèques Java sont également fournis avec leurs propres packages. Nous pouvons importer des classes préexistantes que nous souhaitons utiliser dans notre projet de la même manière.

Par exemple, importons l' interface Java Core List et la classe ArrayList :

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

Nous pouvons ensuite utiliser ces types dans notre application en utilisant simplement leur nom:

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.

L'exemple de code complet est disponible à l'adresse over sur GitHub.