Differenza chiave – Ereditarietà vs interfaccia in Java
Java è un linguaggio di programmazione sviluppato da Sun Microsystems. Java può essere utilizzato per sviluppare diverse applicazioni. È un linguaggio multi-paradigma che supporta la programmazione orientata agli oggetti, strutturata ecc. Il vantaggio principale di Java è che supporta la programmazione orientata agli oggetti (OOP). Il programmatore può creare classi e oggetti. Ci sono quattro pilastri in OOP. Sono eredità, polimorfismo, astrazione e incapsulamento. L'ereditarietà e le interfacce sono correlate all'OOP. Il differenza fondamentale tra ereditarietà e interfaccia è quello l'ereditarietà consiste nel derivare nuove classi da classi esistenti e un'interfaccia consiste nell'implementare classi astratte e l'ereditarietà multipla.
Cos'è l'ereditarietà in Java?
L'ereditarietà può ottenere la riutilizzabilità del codice. L'ereditarietà aiuta a riutilizzare gli attributi ei metodi di una classe esistente. Il meccanismo per derivare una nuova classe usando la vecchia classe è chiamato ereditarietà. La vecchia classe è nota come classe genitore o superclasse. La classe derivata è chiamata classe figlia o sottoclasse.
La sintassi dell'ereditarietà Java è la seguente.
class subclass_name estende superclass_name {
dichiarazione di variabili;
dichiarazione del metodo;
}
Il concetto di ereditarietà può essere spiegato usando il seguente esempio. Supponiamo che ci sia una classe chiamata A come segue.
classe pubblica A{
somma vuota pubblica(){
System.out.println("Somma");
}
}
Se vogliamo aggiungere un nuovo metodo senza cambiare la classe esistente, possiamo farlo come segue.
classe pubblica B{
vuoto pubblico sub(){
System.out.println("Sub");
}
}
Il programmatore può utilizzare l'ereditarietà per utilizzare la classe A sum().
la classe pubblica B estende la classe A{
vuoto pubblico sub(){
System.out.println("Sub");
}
}
Nella funzione principale, è possibile creare un oggetto di B e chiamare sub(), che appartiene alla classe B e sum(), che appartiene alla classe A usando l'ereditarietà.
public static void main(String args){
B obj=nuovo B();
obj.sub();
obj.sum();
}
Ci sono diversi tipi di eredità. Si tratta di eredità singola, eredità multipla, eredità multilivello ed eredità gerarchica. Nell'ereditarietà singola, esiste una classe base e una classe derivata. Nell'ereditarietà multilivello, ci sono tre classi, vale a dire, classe base, classe intermedia e classe derivata. La classe intermedia eredita dalla classe base e la classe derivata eredita dalla classe intermedia. Nell'ereditarietà gerarchica, esiste una classe base e molte classi derivate. Esiste un tipo speciale noto come ereditarietà ibrida. È una combinazione di due o più tipi di eredità.
Figura 01: Ereditarietà
Nell'ereditarietà multipla ci sono molte classi base e una classe derivata. Supponiamo che le classi A e B siano le classi base. La classe C è la classe derivata. Se entrambe le classi A e B hanno lo stesso metodo e il programmatore chiama quel metodo dalla classe derivata, si verificherà un problema di ambiguità. L'ereditarietà di due classi può causare un errore in fase di compilazione. Pertanto, l'ereditarietà multipla non è supportata in Java. Un'interfaccia può essere utilizzata per superare questo problema.
Cos'è l'interfaccia in Java?
L'astrazione è un processo per nascondere i dettagli di implementazione e visualizzare solo le funzionalità all'utente. L'astrazione può essere ottenuta utilizzando Classi astratte o Interfacce. Un metodo astratto è un metodo senza un'implementazione. Una classe con almeno un metodo astratto è una classe astratta. Esempio di una classe astratta è il seguente.
classe astratta A{
abstract void sum();
}
Supponiamo che ci siano due classi astratte come A e B. Per implementare metodi astratti di A e B, viene creata una nuova classe C. Quindi la classe C dovrebbe estendere sia A che B., ma l'ereditarietà multipla non è supportata in Java. Pertanto, dovrebbe utilizzare le interfacce. Le interfacce possono essere utilizzate per dichiarare metodi, ma non è possibile definire metodi. Non è possibile creare un oggetto utilizzando le interfacce. La classe C dovrebbe implementare tutti i metodi nell'interfaccia A e B.
interfaccia A{
somma nulla();
}
interfaccia B{
void sub();
}
la classe C implementa A, B{
somma vuota pubblica(){
System.out.println("Somma");
}
vuoto pubblico sub(){
System.out.println("Sottrazione");
}
}
Ora, nel programma principale è possibile creare un oggetto di C e chiamare entrambi i metodi.
public static void main (String args) {
C obj=nuovo C();
obj.sum();
obj.sub();
}
Quindi, le interfacce possono essere utilizzate per implementare l'ereditarietà multipla.
Un altro uso delle interfacce è che fornisce sicurezza. Fare riferimento al codice seguente.
interfaccia LA {
somma nulla ();
}
la classe B implementa LA {
somma vuota pubblica () {
System.out.println("Somma");
}
vuoto pubblico moltiplicato () {
System.out.println("Moltiplicazione");
}
}
Quando si crea un oggetto di B, è possibile chiamare entrambi i metodi sum() e multiply(). Se il programmatore vuole limitare usando la funzione moltiplica (), è possibile come segue.
public static void main(String args){
A obj=new B();
obj.sum();
}
A obj=new B(); creerà un oggetto. È di tipo A e la memoria è allocata come B. È possibile chiamare sum() ma non eseguire multiply(). Questa restrizione viene eseguita utilizzando le interfacce.
Quali sono le somiglianze tra ereditarietà e interfaccia in Java?
- Entrambi i concetti sono correlati alla programmazione orientata agli oggetti
- Entrambi rappresentano una relazione IS-A.
Qual è la differenza tra ereditarietà e interfaccia in Java?
Ereditarietà vs interfaccia in Java |
|
| L'ereditarietà è un concetto OOP per derivare nuove classi dalle classi esistenti. | L'interfaccia è un meccanismo in OOP per implementare l'astrazione e l'ereditarietà multipla. |
| Utilizzo | |
| L'ereditarietà fornisce il riutilizzo del codice. | Le interfacce forniscono astrazione ed eredità multipla. |
Riepilogo – Ereditarietà vs interfaccia in Java
Java è un linguaggio di programmazione multiparadigma che supporta la programmazione orientata agli oggetti. L'ereditarietà e le interfacce sono legate alla programmazione orientata agli oggetti. La differenza tra l'ereditarietà e l'interfaccia è che l'ereditarietà consiste nel derivare nuove classi da classi esistenti e le interfacce nell'implementare classi astratte e l'ereditarietà multipla.
Scarica la versione PDF di Ereditarietà vs interfaccia in Java
Puoi scaricare la versione PDF di questo articolo e usarla per scopi offline come da nota di citazione. Si prega di scaricare la versione PDF qui Differenza tra ereditarietà e interfaccia in Java
