Grafici di confronto
| Base per il confronto | estende | implementa |
|---|---|---|
| Di base | La parola chiave extends viene utilizzata per creare una sottoclasse utilizzando le funzionalità di una super classe. | La parola chiave implements viene utilizzata per l'implementazione di un'interfaccia |
| metodi | La parola chiave extends non può sovrascrivere tutti i metodi di una super classe. | La parola chiave implements deve implementare tutti i metodi di un'interfaccia implementata. |
| Classe | Una classe può estendere solo una super classe. | Una classe può implementare più interfacce. |
| Interfaccia | Un'interfaccia può estendere più di un'interfaccia. | Un'interfaccia non può implementare un'altra interfaccia. |
Definizione della parola chiave extends
L'ereditarietà è un concetto importante nella programmazione orientata agli oggetti, si ottiene quando una sottoclasse estende un'altra superclasse. Una sottoclasse può estendere solo una superclasse. Una classe non può mai estendere più di una super classe in Java. Quando una classe estende un'altra classe, può sovrascrivere i metodi definiti in una superclasse. Cerchiamo di capire le estensioni delle parole chiave con l'aiuto di un esempio.
classe A {String s; A (stringa s1) {s = s1; } // display string void display () {System.out.println (+ s); }} la classe B estende A {String i; B (String s1, String i1) {super (s1); i = i1; } void dispaly () {super.dispaly (); / * display () della classe A invocato. * / System.out.println (+ i); }} classe Override {public static void main (String args []) {B ob = new B (Tech, Differences); ob.display (); / * visualizzazione della classe B invocata * /}} / * out put * / Differenze tecniche Nel codice precedente, è possibile osservare che la classe B ha esteso la classe A e ha scavalcato il metodo display () definito nella classe A. In modo simile un'interfaccia può estendere più di un'interfaccia alla volta. Poiché l'interfaccia non deve implementare alcun metodo dell'interfaccia estesa, è quindi possibile ereditare più interfacce alla volta.
Definizione della parola chiave implements
Utilizzando la parola chiave implements, una classe eredita tutti i metodi in un'interfaccia. Quando una classe implementa un'interfaccia, quella classe deve implementare tutti i metodi dell'interfaccia implementata. Un'interfaccia non può mai implementare un'altra interfaccia, poiché implementa l'implementazione dei metodi con parole chiave promesse, ma un'interfaccia non implementa mai metodi in essa, quindi è impossibile che un'interfaccia implementa un'altra interfaccia. Cerchiamo di capire la parola chiave implements con l'aiuto di un esempio.
stringhe di interfaccia {void display (String s); } intero dell'interfaccia {void show (int i); } classe Demo implementa stringhe, integer {void show (int i) {System.Out.Println ("valore intero:" + i); } void display (String s) {System.Out.Println ("valore stringa:" + s); }} classe Demo_main {public static void main (string args []) {Demo d = new Demo (); d.display ( "TechDifferences"); d.show (2); }} / * output * / TechDifferences 2 Come nel codice sopra, puoi vedere che la demo di classe implementa due stringhe di interfaccie e un intero e ha implementato i metodi dichiarati in entrambe le interfacce che sono display () e show ().
Differenze chiave tra estensioni e attrezzi
- Una classe può ereditare un'altra classe, o un'interfaccia eredita altre interfacce usando una parola chiave extends mentre una classe può implementare un'interfaccia usando una parola chiave implementa.
- Una sottoclasse che estende una superclasse può sostituire o meno i metodi di una superclasse. D'altra parte, una classe che implementa un'interfaccia deve definire / implementare tutti i metodi di tale interfaccia.
- Una classe può implementare qualsiasi numero di un'interfaccia allo stesso tempo. D'altra parte, una classe può estendere solo una super classe.
- Un'interfaccia può estendere qualsiasi numero di interfacce, ma un'interfaccia non può mai implementare altre interfacce poiché l'implementazione significa definire i metodi e l'interfaccia sempre con metodi astratti, in modo che un'interfaccia non possa mai implementare un'altra interfaccia.
Conclusione:
Concludo la discussione dicendo che l'implementazione di un'interfaccia rende il codice più flessibile dell'estensione di una classe. Come evita la restrizione di ereditare solo una super classe in Java. Usando la parola chiave implements una classe può ereditare le caratteristiche di più di una interfaccia.
