I pacchetti in Java sono un meccanismo che incapsula un gruppo di classi, sottopacchetti e interfacce. I pacchetti vengono utilizzati per:

• Previeni i conflitti di denominazione consentendo alle classi con lo stesso nome di esistere in pacchetti diversi come college.staff.cse.Employee e college.staff.ee.Employee.
• Semplifica l'organizzazione, l'individuazione e l'utilizzo delle interfacce delle classi e di altri componenti.
• Fornire accesso controllato per i membri Protected accessibili all'interno dello stesso pacchetto e per sottoclassi. I membri predefiniti (nessun specificatore di accesso) sono accessibili solo all'interno dello stesso pacchetto.

Raggruppando classi correlate in pacchetti, Java promuove l'incapsulamento dei dati rendendo il codice riutilizzabile e più facile da gestire. Importa semplicemente la classe desiderata da un pacchetto per usarla nel tuo programma.

Creazione di pacchetti personalizzati

Passaggio 1: Crea una directory in cui creiamo i nostri pacchetti e file Java.

mkdir PROGRAMMAZIONE

stringa inversa in Java

Passaggio 2: Ora cambia la directory e crea un'altra cartella all'interno della cartella principale

cd PROGRAMMAZIONE
mkdir JavaProgrammazione
cd JavaProgrammazione
matrici mkdir

Passaggio 3: Ora crea un file di testo vuoto e scrivi il codice Java sottostante e non dimenticare di salvarlo con lo stesso nome della classe con estensione .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');  } } 

Nota: Non dimenticare di aggiungere il nome del pacchetto all'interno del file del programma.

Passaggio 4: Ora esegui il programma con il percorso della cartella definito

javac srcJavaProgrammingarraysTwoPointers.java

java srcJavaProgrammingarraysTwoPointers.java

Produzione:

Struttura delle cartelle:

Questa è la rappresentazione visiva di un pacchetto personalizzato in Java nell'immagine seguente. Per prima cosa creiamo una cartella denominata Progamming e al suo interno creiamo un pacchetto Javaprogramming e poi creiamo un altro sottopacchetto che si chiama matrici . Quindi creiamo al suo interno un file di classe Java che è mostrato nell'immagine qui sotto:

Funzionamento dei pacchetti Java

Struttura della directory: I nomi dei pacchetti e le strutture delle directory sono strettamente correlati. Ad esempio, se il nome di un pacchetto è college.staff.cse, le tre directory sono college staff e cse dove cse è all'interno di staff e staff è all'interno del college.

Convenzioni di denominazione : I nomi dei pacchetti sono scritti in ordine inverso rispetto ai nomi di dominio, ad es. org.geeksforgeeks.practice. In un college la convenzione potrebbe essere:

• college.tech.cse
• college.tech.ee
• college.storia.dell'arte

Esempio:

importa java.util.*;

Qui util è un sottopacchetto creato all'interno del pacchetto Java.  

Accesso alle classi all'interno di un pacchetto

In Java possiamo importare classi da un pacchetto utilizzando uno dei seguenti metodi:

1. Importa una classe specifica :

import java.util.Vector;

Ciò importa solo la classe Vector dal pacchetto java.util.

ospitare Linux

2. Importa tutte le classi da un pacchetto :

importa java.util.*;

Questo importa tutte le classi e le interfacce dal pacchetto java.util ma non include i sottopacchetti.

Esempio: Importa 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] 

Nota:

• Utilizzo del pacchetto di importazione.*; importa tutte le classi in un pacchetto ma non le classi dai suoi sottopacchetti.
• Quando due pacchetti hanno classi con lo stesso nome (ad esempio java.util.Date e my.package.Date) utilizza il nome completo per evitare conflitti:

import java.util.Date;

importa mio.pacchetto.Data;

Tipi di pacchetti Java

• Pacchetti integrati
• Pacchetti definiti dall'utente

1. Pacchetti integrati

Questi pacchetti sono costituiti da un gran numero di classi che fanno parte di Java API .Alcuni dei pacchetti integrati comunemente utilizzati sono:

• java.lang : Contiene classi di supporto linguistico (ad esempio classi che definiscono operazioni matematiche di tipi di dati primitivi). Questo pacchetto viene importato automaticamente.
• java.io: Contiene classi per supportare le operazioni di input/output.
• java.util : Contiene classi di utilità che implementano strutture dati come Linked List Dictionary e supportano ; per le operazioni di data/ora.
• java.applet: Contiene classi per la creazione di applet.
• java.aut: Contengono classi per l'implementazione dei componenti per le interfacce utente grafiche (come pulsanti, menu, ecc.). 6)
• java.net: Contengono classi per supportare le operazioni di rete.

2. Pacchetti definiti dall'utente

Questi sono i pacchetti definiti dall'utente.

1. Crea il pacchetto:

Per prima cosa creiamo una directory myPackage (il nome dovrebbe essere uguale al nome del pacchetto). Quindi crea MyClass all'interno della directory con la prima istruzione che rappresenta i nomi dei pacchetti.

Esempio:

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

2. Utilizzare la classe nel programma:

Ora useremo il La mia classe lezione nel nostro programma.

puntatore in c

 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);  } } 

Nota: MyClass.java deve essere salvato nella directory myPackage poiché fa parte del pacchetto.  

Importazione statica in Java

L'importazione statica in Java riguarda la semplificazione dell'accesso ai membri statici e la separa dalla discussione più ampia sui pacchetti definiti dall'utente.

Importazione statica è una funzionalità introdotta nel linguaggio di programmazione Java (versioni 5 e successive) che consente ai membri (campi e metodi) definiti in una classe come pubblici statico da utilizzare nel codice Java senza specificare la classe in cui è definito il campo.

Esempio:

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 

Gestione dei conflitti di nomi

Quando due pacchetti contengono una classe con lo stesso nome (ad esempio java.util.Date e java.sql.Date) specificare il nome completo del pacchetto per evitare conflitti.

importa java.util.*;
importa java.sql.*;
//E quindi utilizza la classe Date, otterremo un errore in fase di compilazione:
Data oggi; //ERRORE-- java.util.Date o java.sql.Date?

Il compilatore non sarà in grado di capire quale classe Date vogliamo. Questo problema può essere risolto utilizzando una specifica istruzione di importazione:

import java.util.Date;
importa java.sql.*;

Se abbiamo bisogno di entrambe le classi Date, allora dobbiamo utilizzare il nome completo del pacchetto ogni volta che dichiariamo un nuovo oggetto di quella classe. Per esempio:

java.util.Date deadLine = new java.util.Date();
java.sql.Date oggi = nuovo java.sql.Date();

moltiplicazione di matrici in c

Struttura delle directory e CLASSPATH

I nomi dei pacchetti corrispondono a una struttura di directory. Ad esempio, una classe Circle nel pacchetto com.zzz.project1.subproject2 viene archiviata come:

$BASE_DIR/com/zzz/progetto1/sottoprogetto2/Circle.class

• Qui $BASE_DIR rappresenta la directory di base del pacchetto.
• Il "punto" nel nome del pacchetto corrisponde a una sottodirectory del file system.
• La directory di base ( $BASE_DIR ) potrebbe trovarsi ovunque nel file system.
• Pertanto il compilatore Java e il runtime devono essere informati sulla posizione di $BASE_DIR in modo da individuare le classi.
• Ciò è realizzato da una variabile d'ambiente chiamata PERCORSO DI CLASSE .
• CLASSPATH è simile a un'altra variabile d'ambiente PATH che viene utilizzata dalla shell dei comandi per cercare i programmi eseguibili.

Impostazione CLASSPATH

CLASSPATH può essere impostato in uno dei seguenti modi:

• CLASSPATH può essere impostato in modo permanente nell'ambiente in cui si trovano i passaggi in Windows

Vai a Pannello di controllo -> Sistema -> Avanzate -> Variabili d'ambiente.

• Seleziona "Variabili di sistema" per applicare il CLASSPATH per tutti gli utenti del sistema.
• Seleziona "Variabili utente" per applicarlo solo all'utente attualmente connesso.
• Modifica o crea CLASSPATH: se CLASSPATH esiste già selezionalo e fai clic su "Modifica" o se non esiste fai clic su "Nuovo"
• Inserisci i dettagli CLASSPATH: Nel campo "Nome variabile" inserisci: "CLASSPATH" Nel campo "Valore variabile" inserisci le directory e i file JAR separati da punto e virgola.
• Nel campo "Valore variabile" inserisci le directory e i file JAR separati da punto e virgola. Esempio:

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

• Il punto (.) rappresenta la directory di lavoro corrente.
• Per verificare l'impostazione corrente del CLASSPATH, eseguire il seguente comando:

> IMPOSTA IL PERCORSO DI CLASSE

CLASSPATH può essere impostato temporaneamente per quella particolare sessione della shell CMD emettendo il seguente comando:

> IMPOSTA CLASSPATH=.;c:javaprojectclasses;d:tomcatlibservlet-api.jar

Invece di utilizzare la variabile d'ambiente CLASSPATH puoi anche utilizzare l'opzione della riga di comando -classpath o -cp dei comandi javac e java, ad esempio

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

Illustrazione dei pacchetti definiti dall'utente:  Creazione del nostro primo pacchetto: nome file: ClassOne.java

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

Creazione del nostro secondo pacchetto: nome file – ClassTwo.java

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

Facendo uso di entrambi i pacchetti creati: Nome del file – Testing.java

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

Ora diamo un'occhiata alla struttura delle directory sia dei pacchetti che del file della classe testing:

Modificatori di accesso nel contesto dei pacchetti

• Pubblico: Membri con ilpublicIl modificatore è accessibile da qualsiasi luogo, indipendentemente dal fatto che la classe che accede sia o meno nello stesso pacchetto .
• Protetto: I membri con il modificatore protected sono accessibili all'interno dello stesso pacchetto nelle sottoclassi
• Predefinito: I membri senza modificatore sono accessibili solo all'interno dello stesso pacchetto
• Privato: Membri con ilprivateil modificatore è accessibile solo all'interno della stessa classe. Non è possibile accedervi dalle classi nelle stesse sottoclassi del pacchetto o in pacchetti diversi.