Pacchetti in Java e come usarli?

I pacchetti in Java vengono utilizzati per raggruppare classi, interfacce e sottopacchetti correlati. Utilizziamo i pacchetti Java per evitare conflitti di denominazione poiché possono esserci due classi con lo stesso nome in due pacchetti diversi. Inoltre, la ricerca, la localizzazione e l'utilizzo di interfacce, classi, annotazioni ed enumerazioni diventano più semplici con i pacchetti Java.

L'uso del linguaggio di programmazione Java per scrivere software coinvolge numerose classi individuali e ha senso organizzare solo classi e interfacce correlate in pacchetti. In un certo senso, puoi confrontare i pacchetti Java con le cartelle in un computer che utilizziamo per organizzare vari file e mantenere il nostro lavoro ordinato.

Questa guida discuterà i diversi tipi di pacchetti in Java e come usarli.

Tipi di pacchetti in Java

I pacchetti in Java sono divisi in categorie a seconda che l'utente li definisca o meno. I due tipi di pacchetti Java sono:

• Pacchetti incorporati
• Pacchetti definiti dall'utente

1. Pacchetti integrati

I pacchetti Java predefiniti o integrati fanno parte del Java Development Kit (JDK) e sono costituiti da molte classi e interfacce predefinite che fanno parte delle API Java. Alcuni dei pacchetti integrati comunemente usati in Java sono i seguenti:

• java.io: contiene classi per supportare le operazioni di input/output.
• java.lang: questo pacchetto integrato viene importato automaticamente e contiene classi di supporto linguistico.
• java.util: contiene classi di utilità per l'implementazione di strutture di dati come dizionario e supporto, elenco collegato, operazioni di data e ora, ecc .
• java.net: contiene classi che supportano le operazioni di rete.

Dobbiamo usare l'istruzione import per importare qualsiasi pacchetto Java integrato e utilizzare le classi che contiene.

Un semplice esempio per mostrare l'uso della classe ArrayList del pacchetto Java.util è il seguente:

pacchetto Esempio;

importare java.util.ArrayList;

classe BuiltInPackage {

public static void main(String[] args) {

ArrayList<Integer> myList = nuovo ArrayList<>(3);

miaLista.aggiungi(3);

miaLista.aggiungi(2);

miaLista.aggiungi(1);

System.out.println(“L'elenco contiene gli elementi: ” + myList);

}

}

Produzione:

L'elenco contiene gli elementi: [3, 2, 1]

Nell'esempio precedente di Java.util.ArrayList, Java è il pacchetto di primo livello, util è un sottopacchetto e ArrayList è una classe presente nel sottopacchetto util.

Importazione di pacchetti in Java

Come mostrato nell'esempio precedente, Java ha un'istruzione import che ci consente di importare un intero pacchetto o utilizzare solo determinate interfacce e classi definite nel pacchetto.

La sintassi generale dell'istruzione import è:

• importa nome.pacchetto.Nomeclasse; //Importa solo una determinata classe
• import package.name.* //Importa l'intero pacchetto

Ad esempio, import java.util.Date; importa solo la classe Date mentre import java.io.*; importa tutto ciò che contiene il pacchetto java.io.

Tuttavia, l'istruzione import è facoltativa in Java e, se vogliamo utilizzare la classe o l'interfaccia di un determinato pacchetto, possiamo utilizzare il suo nome completo come segue:

classe MyClass implementa java.util.Date {

//corpo

}

2. Pacchetti definiti dall'utente

Come evidente dal nome, i pacchetti definiti dall'utente vengono creati dall'utente per raggruppare classi, interfacce e sottopacchetti.

Creazione di un pacchetto definito dall'utente

Per creare un pacchetto definito dall'utente in Java, sceglieremo un nome per il nostro pacchetto e utilizzeremo il comando package come istruzione iniziale nel file sorgente Java. Ad esempio, creeremo un pacchetto denominato ExamplePackage utilizzando la seguente istruzione:

pacchetto EsempioPacchetto;

L'istruzione package specifica il pacchetto a cui apparterranno le classi che definiamo. Se non utilizziamo l'istruzione package, i nomi delle classi verranno inseriti nel pacchetto predefinito in Java che non ha nome.

Impara i corsi di sviluppo software online dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Creazione di una classe nel pacchetto Java

Una volta creato il pacchetto, il passaggio successivo consiste nel creare una classe all'interno del pacchetto. Per questo, dichiareremo il nome del pacchetto nella prima istruzione del programma, seguita dall'inclusione della classe come parte del pacchetto.

Di seguito è riportato un semplice programma per mostrare come creare una classe in un pacchetto Java. Nell'esempio fornito, creiamo una classe Calculate all'interno del pacchetto ExamplePackage.

pacchetto EsempioPacchetto;

classe pubblica Calcola {

public int add(int p, int q){

restituire p+q;

}

public static void main(String args[]){

Calcola obj = nuovo Calcola();

System.out.println(obj.add(70, 12));

}

}

Uscita: 82

Java memorizza i pacchetti nelle directory del file system. Quindi, il programma sopra verrà salvato in un file come Calculate.java e archiviato nella directory denominata ExamplePackage. Quando il file viene compilato, Java creerà un file '.class' e lo memorizzerà nella directory ExamplePackage.

Ora puoi usare il pacchetto ExamplePackage in un altro programma. Ecco come:

import ExamplePackage.Calculate;

demo di classe pubblica{

public static void main(String args[]){

Calcola obj = nuovo Calcola();

System.out.println(obj.add(200, 523));

}

}

Uscita: 723

Nell'esempio sopra, abbiamo importato il pacchetto ExamplePackage per usare la classe Calculate. L'importazione del pacchetto come ExamplePackage.Calculate importa solo la classe Calculate. Tuttavia, se hai più di una classe all'interno del pacchetto ExamplePackage, puoi utilizzare tutte le classi del pacchetto usando la seguente istruzione import:

import PacchettoEsempio.*;

Creazione di una classe all'interno di un pacchetto durante l'importazione di un altro pacchetto

Per creare una classe all'interno di un pacchetto durante l'importazione di un altro pacchetto, inizieremo dichiarando il nome del pacchetto e quindi importeremo l'altro pacchetto. L'esempio seguente dimostra lo stesso:

pacchetto Altro pacchetto; //Dichiarazione di un pacchetto

import ExamplePackage.Calculate; //importazione di un pacchetto

Esempio di classe pubblica{

public static void main(String args[]){

Calcola obj = nuovo Calcola();

System.out.println(obj.add(300, 700));

}

}

Uscita: 1000

Nell'esempio precedente, dichiariamo il pacchetto OtherPackage, importiamo la classe Calculate dal pacchetto ExamplePackage e quindi creiamo la classe Example.

Importazione di una classe utilizzando un nome completo

Possiamo evitare l'istruzione import utilizzando un nome completo. L'utilizzo di un nome completo rende accessibile solo la classe dichiarata del pacchetto. Ma dobbiamo usare un nome completo ogni volta che accediamo alla classe o all'interfaccia. L'importazione di una classe utilizzando un nome completo è utile quando due pacchetti hanno lo stesso nome di classe.

L'esempio seguente illustra lo stesso:

1. Calcola.java

pacchetto EsempioPacchetto;

classe pubblica Calcola {

public int add(int x, int y){

restituisci x+y;

}

public static void main(String args[]){

Calcola obj = nuovo Calcola();

System.out.println(obj.add(20, 50));

}

}

2. Demo.java

pacchetto Altro pacchetto; //Dichiarazione di un pacchetto

demo di classe pubblica{

public static void main(String args[]){

ExamplePackage.Calculate obj = new ExamplePackage.Calculate(); //Utilizzo di un nome completo invece di import

System.out.println(obj.add(200, 100));

}

}

Uscita: 300

Nell'esempio seguente, abbiamo utilizzato il nome completo ExamplePackage.Calculate per creare l'oggetto invece di importare il pacchetto.

3. Sottopacchetti in Java

Ora che abbiamo un'idea sui pacchetti Java e su come crearli, cerchiamo di capire il concetto di sottopacchetti in Java.

Un sottopacchetto è un pacchetto all'interno di un altro pacchetto e viene utilizzato per classificare ulteriormente il pacchetto. In altre parole, se creiamo un pacchetto multiply all'interno del pacchetto ExamplePackage, allora moltiplica è il sottopacchetto. Quindi, se vogliamo creare una classe all'interno di questo sottopacchetto moltiplica, allora il sottopacchetto dovrebbe avere una dichiarazione all'inizio.

Il seguente programma dimostra il concetto di sottopacchetto Java:

pacchetto EsempioPackage.multiply; //Dichiarazione del sottopacchetto

moltiplicazione di classe pubblica {

int prodotto(int p, int q){

restituire p*q;

}

}

Ora, se vogliamo usare la classe Multiplication, possiamo:

1. Importalo usando l'istruzione import ExamplePackage.multiply; o
2. usa un nome completo come ExamplePackage.multiply.Multiplication obj = new ExamplePackage.multiply.Multiplication();

Via avanti

I pacchetti in Java possono essere pacchetti integrati o definiti dall'utente e sono essenziali per un migliore accesso e gestione del codice. Il concetto di pacchetti Java è fondamentale per chiunque sia nel campo dello sviluppo software.

La certificazione PG collegata al lavoro di upGrad in ingegneria del software è un programma online di 5 mesi che può aiutarti a padroneggiare le abilità di programmazione e prepararti per ruoli software. Il programma si concentra su abilità fondamentali come Java, JavaScript, CSS3, HTML5, ecc. ed è appositamente progettato per i neofiti che vogliono imparare a programmare.

Punti salienti del programma:

• Specializzazione in MERN/Cloud-Native
• Oltre 500 ore di contenuto
• Oltre 50 sessioni dal vivo
• Oltre 350 ore di formazione pratica
• Cinque progetti di settore
• Supporto all'apprendimento a 360 gradi
• Networking con esperti del settore

Iscrizione oggi e impara dai migliori!