Differenza tra pacchetti e interfacce in Java
Contenuto
Pacchetti e interfacce fungono entrambi da contenitore. Il contenuto in pacchetti e interfacce può essere utilizzato dalle classi importandolo e implementandolo di conseguenza. La differenza di base tra pacchetti e interfacce è che un pacchetto contiene un gruppo di classi e interfacce mentre un'interfaccia contiene metodi e campi. Studiamo alcune altre differenze con l'aiuto della tabella di confronto.
- Tabella di comparazione
- Definizione
- Differenze chiave
- Conclusione
Tabella di comparazione
| Base per il confronto | Pacchi | interfacce |
|---|---|---|
| Di base | Pacchetti è un gruppo di classi e / o interfacce insieme. | Le interfacce sono un gruppo di metodi astratti e campi costanti. |
| Parola chiave | I pacchetti vengono creati utilizzando la parola chiave "Pacchetto". | L'interfaccia viene creata utilizzando la parola chiave "Interfaccia". |
| Sintassi | pacchetto nome_pacchetto; classe pubblica class_name { . (corpo di 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 "import". | Le interfacce possono essere implementate usando la parola chiave "implement". |
Definizione dei pacchetti
I pacchetti sono raccolte o gruppi della varietà di classi e interfacce. Le classi nei pacchetti sono correlate tra loro in qualche 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.
- Apri un file e poi dichiara il nome del pacchetto nella parte superiore del file, come se il nome del pacchetto fosse il nome che vuoi dare al pacchetto.
- Successivamente, si definisce una classe che si desidera inserire nel pacchetto e si ricorda che la si dichiara pubblica.
- Salvare il file come file .java e quindi compilare il file, quindi ".class" viene ottenuto 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 usare “javac -d. . file_name.java ”.
- È inoltre possibile creare un pacchetto secondario dichiarando il nome del pacchetto secondario nella parte superiore del file.
pacchetto Mypackage; public class myclass {public void displayMypackage () {system.out.ln ("metodo displayMypackage della classe myclass del pacchetto Mypackage"); }
Utilizzando il pacchetto
I pacchetti creati o disponibili nella directory possono essere utilizzati nel programma utilizzando un'istruzione import. 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 determinata classe da un pacchetto, la parola chiave "import" è seguita dal nome del pacchetto, 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 ulteriormente seguito dal punto e dall'operatore "*".
import nome_pacchetto. nome della classe; o importa nome_pacchetto. *;
Nel codice sopra, puoi 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.
import Mypackage. myclass {class TestMypackage {vuoto statico pubblico main (string args) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // metodo di output displayMypackage della classe myclass del pacchetto Mypackage.
Nel codice sopra, la classe TestMypackage ha importato il pacchetto Mypackage e ha usato il suo metodo displayMypackage ().
Definizione di interfaccia
L'interfaccia è una specie 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, non è quindi 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 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 è necessario il costruttore nell'interfaccia, quindi l'interfaccia non contiene alcun costruttore. Vediamo l'esempio di creazione e utilizzo di un'interfaccia.
Area di interfaccia {float pi = 3.14; float find_area (float a, float b) {} class Circle implementa Area {float find_area (float a, float b) {return (pi * a * a); } Class Shapes {vuoto statico pubblico main (string args) {Area A = new Area (); Cerchio C = nuovo cerchio (); A = C; float F = Area. find_area (10,10); system.out.ln ("L'area del cerchio è:" + F); }
Nel codice sopra, 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. La classe Circle ha definito il metodo astratto dell'area della classe in base alle sue esigenze.
- Un pacchetto è un gruppo di classi e interfacce insieme, mentre un'interfaccia è un gruppo di metodi astratti.
- Il pacchetto viene creato utilizzando una parola chiave pacchetto mentre, un'interfaccia viene creata usando una parola chiave interfaccia.
- Se si desidera utilizzare una classe o un'interfaccia all'interno di un pacchetto, il pacchetto deve essere importato mentre è necessario implementare un'interfaccia.
Conclusione:
Sia i pacchetti che l'interfaccia sono i contenitori. Il pacchetto riduce la dimensione del codice quando importiamo semplicemente la classe da utilizzare anziché definirla nuovamente.Considerando che l'interfaccia riduce le confusioni che si sono verificate mentre eredità multiple perché nel caso di eredità multiple la classe ereditaria non deve decidere quella definizione di quale metodo dovrebbe ereditare invece definisce la propria.
