Differenza tra pacchetti e interfacce in Java

2019

I pacchetti e le interfacce fungono entrambi da contenitore. Il contenuto in pacchetti e interfacce può essere utilizzato dalle classi importandolo e implementandolo in modo corrispondente. La differenza fondamentale tra pacchetti e interfacce è che un pacchetto contiene un gruppo di classi e interfacce, mentre un'interfaccia contiene metodi e campi. Analizziamo alcune altre differenze con l'aiuto della tabella di confronto.

Grafico comparativo

Base per il confronto	Pacchi	interfacce
Di base	I pacchetti sono un gruppo di classi e / o interfacce insieme.	Interfacce è un gruppo di metodi astratti e campi costanti.
Parola chiave	I pacchetti sono creati usando la parola chiave "Pacchetto".	L'interfaccia viene creata usando la parola chiave "Interfaccia".
Sintassi	pacchetto nome_pacchetto; public class class_name { . (corpo della classe) . }	interfaccia nome_interfaccia { dichiarazione variabile; dichiarazione del metodo; }
Accesso	Un pacchetto può essere importato	Un'interfaccia può essere estesa da un'altra interfaccia e implementata dalla classe.
Parola chiave di accesso	I pacchetti possono essere importati usando la parola chiave "importa".	Le interfacce possono essere implementate usando la parola chiave "implement".

Definizione di pacchetti

I pacchetti sono raccolte o gruppi di varietà di classi e interfacce. Le classi nei pacchetti sono correlate l'una all'altra in un certo ambito o per ereditarietà. Puoi anche creare il tuo pacchetto e usarlo per il tuo programma.

Creare un pacchetto

Per creare un pacchetto basta seguire i seguenti passi.

Aprire un file e quindi dichiarare il nome del pacchetto nella parte superiore del file, come [pacchetto nome_pacchetto; ] il nome del pacchetto è il nome che vuoi dare al pacchetto.
Successivamente, si definisce una classe che si desidera inserire nel pacchetto e si ricorda di dichiararla pubblica.
Salva il file come file .java e poi compila il file, quindi ".class" si ottiene per quel file.
Per creare un pacchetto per questo file, il comando utilizzato è "javac -d. file_name.java. Puoi vedere che il pacchetto è stato creato contenente un file ".class" nella directory corrente. Per posizionarlo nella directory principale usa "javac -d. . nome_file.java ".
È inoltre possibile creare un pacchetto secondario dichiarando il nome del pacchetto secondario come [pacchetto nome_pacchetto1. package_name2; ] nella parte superiore del file.

 pacchetto Mypackage; public class myclass {public void displayMypackage () {system.out.println ("metodo displayMypackage di classe myclass del pacchetto Mypackage"); }

Utilizzo del pacchetto

I pacchetti creati o disponibili nella directory possono essere utilizzati nel programma utilizzando una dichiarazione di importazione. La parola chiave utilizzata per importare qualsiasi pacchetto nel programma è "import". La dichiarazione di importazione può essere scritta in due modi, oppure puoi dire che ci sono due modi per accedere a qualsiasi pacchetto. Innanzitutto, se si desidera utilizzare una particolare classe da un pacchetto, la parola chiave "import" è seguita dal nome del pacchetto ulteriormente seguito dall'operatore punto e dal nome della classe che si desidera utilizzare dal pacchetto. In secondo luogo, se si desidera utilizzare molte classi contenute nei pacchetti, la parola chiave import è seguita dal nome del pacchetto seguito dal punto e dall'operatore "*".

 import nome_pacchetto. nome della classe; o import package_name. *;

Nel codice sopra, è possibile vedere il segno * che indica che il secondo metodo importa tutte le classi contenute nei pacchetti.

Ora, vediamo l'uso del pacchetto con un esempio.

 importa Mypackage. myclass {class TestMypackage {public static void main (string args []) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // metodo di output displayMypackage di classe myclass del pacchetto Mypackage.

Nel codice precedente, la classe TestMypackage ha importato il pacchetto Mypackage e utilizzato il suo metodo displayMypackage ().

Definizione di interfaccia

L'interfaccia è un tipo di classe, ma differisce nel senso che i metodi dichiarati nell'interfaccia sono astratti, il che significa che i metodi sono solo dichiarati ma non definiti. I campi nell'interfaccia sono sempre pubblici, statici, finali. I campi devono essere inizializzati al momento della dichiarazione. I metodi dichiarati dall'interfaccia sono definiti dalla classe che implementa tale interfaccia in base alle sue esigenze. Poiché i metodi nell'interfaccia non svolgono alcuna funzione, quindi non è possibile creare alcun oggetto dell'interfaccia. Quindi, nessun oggetto può essere creato per l'interfaccia.

L'interfaccia può anche ereditare l'altra interfaccia, ma la classe che eredita una tale interfaccia deve anche implementare tutti i metodi dell'interfaccia ereditata. Poiché i campi sono inizializzati al momento della loro dichiarazione nell'interfaccia, quindi non c'è bisogno di un costruttore nell'interfaccia, quindi l'interfaccia non contiene alcun costruttore. Vediamo l'esempio di creare e usare un'interfaccia.

 area di interfaccia {float pi = 3, 14; float find_area (float a, float b) {} classe Circle implementa l'area {float find_area (float a, float b) {return (pi * a * a); } Class Shapes {public static void main (string args []) {Area A = new Area (); Cerchio C = nuova cerchia (); A = C; float F = Area. find_area (10, 10); system.out.println ("Area del cerchio è:" + F); }

Nel codice precedente, abbiamo creato un'area di interfaccia e la classe Circle ha implementato l'area di interfaccia. Il campo "pi" è stato inizializzato nell'interfaccia al momento della sua dichiarazione. Il circolo classe ha definito il metodo astratto dell'area classe in base alle sue esigenze.

Differenze chiave tra pacchetti e interfacce in Java

Un pacchetto è un gruppo di classi e interfacce insieme mentre, un'interfaccia è un gruppo di metodi astratti.
Il pacchetto viene creato utilizzando un pacchetto di parole chiave , mentre un'interfaccia viene creata utilizzando un'interfaccia per le parole chiave.
Se si deve usare una classe o un'interfaccia all'interno di un pacchetto, il pacchetto deve essere importato mentre un'interfaccia deve essere implementata.

Conclusione:

Sia i pacchetti che l'interfaccia sono i contenitori. Il pacchetto riduce la dimensione del codice poiché importiamo semplicemente la classe da utilizzare invece di definirla di nuovo. Mentre l'interfaccia riduce le confusioni che si verificano durante le eredità multiple perché nel caso di ereditarietà multiple la classe ereditaria non deve decidere quella definizione di quale metodo dovrebbe ereditare, invece ne definisce la propria.