Vergelijkingsgrafieken
| Basis voor vergelijking | breidt | gereedschap |
|---|---|---|
| basis- | Het keyword extends wordt gebruikt om een subklasse te maken met behulp van functies van een superklasse. | Het sleutelwoord werktuigen wordt gebruikt voor de implementatie van een interface |
| methoden | Het keyword extends mag niet alle methoden van een superklasse overschrijven. | Het sleutelwoord implementeert moet alle methoden van een geïmplementeerde interface implementeren. |
| Klasse | Een klasse kan slechts één superklasse uitbreiden. | Een klasse kan meerdere tussenruimten implementeren. |
| Interface | Een interface kan meer dan één interface uitbreiden. | Een interface kan geen andere interface implementeren. |
Definitie van keyword extends
Overerving is een belangrijk concept in objectgeoriënteerde programmering en wordt bereikt wanneer een subklasse een andere superklasse uitbreidt. Het is toegestaan dat een subklasse slechts één superklasse uitbreidt. Een klasse kan nooit meer dan één superklasse in Java uitbreiden. Wanneer een klasse een andere klasse uitbreidt, kan deze de methoden overschrijven die zijn gedefinieerd in een superklasse. Laten we het trefwoord uitbreiden met behulp van een voorbeeld.
klasse A {String s; A (String s1) {s = s1; } // display string void display () {System.out.println (+ s); }} klasse B breidt A uit {String i; B (String s1, String i1) {super (s1); i = i1; } void dispaly () {super.dispaly (); / * display () van klasse A opgeroepen. * / System.out.println (+ i); }} class Override {public static void main (String args []) {B ob = new B (Tech, Differences); ob.display (); / * weergave van klasse B ingeroepen * /}} / * uit gezet * / Tech Verschillen In de bovenstaande code kunt u zien dat klasse B klasse A heeft uitgebreid en de methode-weergave () heeft overschreven die is gedefinieerd in klasse A. Op een vergelijkbare manier kan een interface meer dan één interface tegelijk uitbreiden. Omdat de interface geen enkele methode van de uitgebreide interface hoeft te implementeren, is het dus toegestaan om meerdere interfaces tegelijkertijd te erven.
Definitie van het sleutelwoord implementeert
Met behulp van de sleutelwoordinstrumenten, erft een klasse alle methoden in een interface. Wanneer een klasse een interface implementeert, moet die klasse alle methoden voor de geïmplementeerde interface implementeren. Een interface kan nooit een andere interface implementeren, omdat het sleutelwoord implementeert de implementatie van de methoden belooft, maar een interface implementeert nooit methoden erin, dus het is onmogelijk voor een interface om een andere interface te implementeren. Laten we het trefwoord van implementaties begrijpen met behulp van een voorbeeld.
interface strings {void display (String s); } interface integer {void show (int i); } class Demo implementeert strings, integer {void show (int i) {System.Out.Println ("integer value:" + i); } void display (String s) {System.Out.Println ("stringwaarde:" + s); }} class Demo_main {public static void main (string args []) {Demo d = nieuwe demo (); d.display ( "TechDifferences"); d.show (2); }} / * uitvoer * / TechVerschillen 2 Net als in de bovenstaande code kunt u zien dat de klassendemo twee interfacestrings en integer implementeert en de methoden heeft geïmplementeerd die zijn gedeclareerd in zowel de interfaces die display () als show () zijn.
Belangrijkste verschillen tussen uitbreidingen en werktuigen
- Een klasse kan een andere klasse erven, of een interface neemt andere interfaces over die gebruikmaken van een sleutelwoord, terwijl een klasse interfaces kan implementeren met behulp van sleutelwoordinstrumenten.
- Een subklasse die een superklasse uitbreidt, kan al dan niet alle methoden in een superklasse overschrijven. Aan de andere kant moet een klasse die een interface implementeert alle methoden van die interface definiëren / implementeren.
- Een klasse kan elk willekeurig aantal van een interface op hetzelfde moment implementeren. Aan de andere kant kan een klasse slechts één superklasse uitbreiden.
- Een interface kan elk aantal interfaces uitbreiden, maar een interface kan nooit een andere interface implementeren als implementatiemiddelen die de methoden definiëren en de interface heeft altijd abstracte methoden, zodat een interface nooit een andere interface kan implementeren.
Conclusie:
Ik besluit de discussie dat het implementeren van een interface de code flexibeler maakt dan het uitbreiden van een klasse. Omdat het de beperking van het overerven van slechts één superklasse op Java vermijdt. Met behulp van het sleutelwoord implementeert een klasse een eigenschap van meerdere interfaces.
