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

comment obtenir la date actuelle en Java

É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

stlc

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 :

série dans Postgres

• 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();

tableau de réaction

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 lepublic .
• 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 leprivate