Les packages en Java sont un mécanisme qui encapsule un groupe de sous-packages de classes et d'interfaces. Les packages sont utilisés pour :

• Évitez les conflits de noms en autorisant les classes portant le même nom à exister dans différents packages tels que college.staff.cse.Employee et college.staff.ee.Employee.

En regroupant les classes associées dans des packages, Java favorise l'encapsulation des données, rendant le code réutilisable et plus facile à gérer. Importez simplement la classe souhaitée à partir d’un package pour l’utiliser dans votre programme.

Création de packages personnalisés

Étape 1 : Créez un répertoire dans lequel nous créons nos packages et fichiers Java.

Programmation mkdir

Étape 2 :

PROGRAMMATION CD
mkdir JavaProgrammation
cd JavaProgrammation
tableaux mkdir

Étape 3 : Créez maintenant un fichier texte vide et écrivez le code Java ci-dessous et n'oubliez pas de l'enregistrer sous le même nom que la classe avec l'extension .java (TwoPointers.java)

Classe TwoPointers.

   package     JavaProgramming.arrays  ;   // Main class present inside the package    public     class   TwoPointers     {      public     static     void     main  (  String  []     args  )     {      System  .  out  .  println  (  'Inside the package'  );      }   }   

Note:

Étape 4 : Maintenant, exécutez le programme avec le chemin du dossier défini

javac srcJavaProgrammingarraysTwoPointers.java

java srcJavaProgrammingarraysTwoPointers.java

Sortir:

Structure des dossiers :

Il s'agit de la représentation visuelle d'un package personnalisé en Java dans l'image ci-dessous. Nous créons d’abord un dossier nommé Progamming et à l’intérieur nous créons un package Javaprogramming, puis créons un autre sous-package appelé tableaux . Ensuite, nous créons un fichier de classe Java à l'intérieur, illustré dans l'image ci-dessous :

Fonctionnement des packages Java

Structure du répertoire : Les noms de packages et les structures de répertoires sont étroitement liés. Par exemple, si le nom d'un package est college.staff.cse, alors trois répertoires sont le personnel du collège et cse où cse est à l'intérieur du personnel et le personnel est à l'intérieur du collège.

Conventions de dénomination : Package names are written in reverse order of domain names e.g. org.geeksforgeeks.practice. Dans un collège, la convention pourrait être :

• collège.tech.cse
• collège.tech.ee
• collège.art.histoire

Exemple:

importer java.util.* ;

Ici, util est un sous-package créé dans le package Java.  

Accéder aux classes dans un package

1. Importez une classe spécifique :

importer java.util.Vector ;

Cela importe uniquement la classe Vector du package java.util.

2. Importez toutes les classes d'un package :

importer java.util.* ;

Cela importe toutes les classes et interfaces du package java.util mais n'inclut pas les sous-packages.

Exemple: Importer la classe Vector

   import     java.util.Vector  ;   public     class   Geeks     {          public     Geeks  ()     {          // java.util.Vector is imported We are able to access it directly in our code.      Vector     v     =     new     Vector  ();          java  .  util  .  ArrayList     l     =     new     java  .  util  .  ArrayList  ();      l  .  add  (  3  );      l  .  add  (  5  );      l  .  add  (  7  );          System  .  out  .  println  (  l  );      }      public     static     void     main  (  String  []     args  )     {              new     Geeks  ();      }   }   

[3 5 7]  

Note:

• Utilisation du package d'importation.*; imports all classes in a package but not classes from its sub-packages.
• Lorsque deux packages ont des classes portant le même nom (par exemple java.util.Date et my.package.Date), utilisez le nom complet pour éviter les conflits :

importer java.util.Date ;

importer mon.package.Date ;

Types de packages Java

• Forfaits intégrés
• Packages définis par l'utilisateur

1. Forfaits intégrés

API .Certains des packages intégrés couramment utilisés sont :

• java.lang : Contains language support classes(e.g classes which defines primitive data types math operations). Ce package est automatiquement importé.
• java.io : Contient des classes pour prendre en charge les opérations d'entrée/sortie.
• java.util : Contains utility classes which implement data structures like Linked List Dictionary and support ; pour les opérations Date/Heure.
• java.applet : Contient des classes pour créer des applets.
• java.aut : Contain classes for implementing the components for graphical user interfaces (like button ;menus etc). 6)
• java.net :

2. Packages définis par l'utilisateur

1. Créez le package :

Nous créons d’abord un répertoire myPackage (le nom doit être le même que le nom du package). Créez ensuite la MyClass dans le répertoire, la première instruction étant les noms des packages.

Exemple:

   package     myPackage  ;   public     class   MyClass   {      public     void     getNames  (  String     s  )      {         System  .  out  .  println  (  s  );         }   }   

2. Utilisez la classe dans le programme :

Nous allons maintenant utiliser le MaClasse classe dans notre programme.

      import     myPackage.MyClass  ;   public     class   Geeks     {      public     static     void     main  (  String     args  []  )     {             // Initializing the String variable with a value       String     s     =     'GeeksforGeeks'  ;          // Creating an instance of class MyClass in the package.      MyClass     o     =     new     MyClass  ();          o  .  getNames  (  s  );      }   }   

Note:

Importation statique en Java

L'importation statique en Java vise à simplifier l'accès aux membres statiques et le sépare de la discussion plus large des packages définis par l'utilisateur.

Importation statique statique

Exemple:

   import static     java.lang.System.*  ;   class   Geeks     {      public     static     void     main  (  String     args  []  )     {          // We don't need to use 'System.out' as imported using static.      out  .  println  (  'GeeksforGeeks'  );      }   }   

GeeksforGeeks  

Gestion des conflits de noms

Lorsque deux packages contiennent une classe portant le même nom (par exemple java.util.Date et java.sql.Date), spécifiez le nom complet du package pour éviter les conflits.

importer java.util.* ;
importer java.sql.* ;

Rendez-vous aujourd'hui ; //ERREUR-- java.util.Date ou java.sql.Date ?

Le compilateur ne sera pas en mesure de déterminer quelle classe Date nous voulons. Ce problème peut être résolu en utilisant une instruction d'importation spécifique :

importer java.util.Date ;
importer java.sql.* ;

Si nous avons besoin des deux classes Date, nous devons utiliser un nom de package complet chaque fois que nous déclarons un nouvel objet de cette classe. Par exemple:

java.util.Date deadLine = new java.util.Date();
java.sql.Date aujourd'hui = new java.sql.Date();

Structure du répertoire et CLASSPATH

Les noms de packages correspondent à une structure de répertoires. Par exemple, une classe Circle dans le package com.zzz.project1.subproject2 est stockée sous la forme :

$BASE_DIR/com/zzz/project1/subproject2/Circle.class

• Ici $BASE_DIR représente le répertoire de base du package.
• Le « point » dans le nom du package correspond à un sous-répertoire du système de fichiers.
• Le répertoire de base ( $BASE_DIR ) peut être situé n'importe où dans le système de fichiers.
• Ceci est accompli par une variable d'environnement appelée CHEMIN DE CLASSE .

Définition du chemin de classe

• Modifier ou créer CLASSPATH : Si CLASSPATH existe déjà, sélectionnez-le et cliquez sur "Modifier" ou s'il n'existe pas, cliquez sur "Nouveau".
• Saisissez les détails de CLASSPATH : Dans le champ "Nom de la variable", saisissez : "CLASSPATH". Dans le champ "Valeur de la variable", saisissez les répertoires et les fichiers JAR séparés par des points-virgules.
• Dans le champ 'Valeur de la variable' saisissez les répertoires et fichiers JAR séparés par des points-virgules. Exemple:

.c:javaprojectclasses;d:tomcatlibservlet-api.jar

• Le point ( . ) représente le répertoire de travail actuel.
• Pour vérifier le paramètre actuel de CLASSPATH, exécutez la commande suivante :

> DÉFINIR LE CHEMIN DE CLASSE

CLASSPATH peut être défini temporairement pour cette session shell CMD particulière en exécutant la commande suivante :

Au lieu d'utiliser la variable d'environnement CLASSPATH, vous pouvez également utiliser l'option de ligne de commande -classpath ou -cp des commandes javac et java par exemple.

> java –classpath c:javaprojectclasses com.abc.project1.subproject2.MyClass3

Illustration de packages définis par l'utilisateur :

   package     package_name  ;   public     class   ClassOne     {      public     void     methodClassOne  ()      {      System  .  out  .  println  (  'Hello there its ClassOne'  );      }   }   

   package     package_one  ;   public     class   ClassTwo     {      public     void     methodClassTwo  ()      {      System  .  out  .  println  (  'Hello there i am ClassTwo'  );      }   }   

   import     package_name.ClassOne  ;   import     package_one.ClassTwo  ;   public     class   Testing     {      public     static     void     main  (  String  []     args  )      {      ClassTwo     a     =     new     ClassTwo  ();      ClassOne     b     =     new     ClassOne  ();      a  .  methodClassTwo  ();      b  .  methodClassOne  ();      }   }   

Modificateurs d'accès dans le contexte des packages

• Publique: Les membres avec le public .
• Protégé: Les membres avec le modificateur protected sont accessibles au sein du même package Dans les sous-classes
• Défaut: Les membres sans modificateur sont accessibles uniquement au sein du même package
• Privé: Les membres avec le private