Verschil tussen Extends en Implements in Java met voorbeelden

Na het artikel over Java Autoboxing en Unboxing in Java, zullen we het verschil leren tussen extends en implementments in java. Beide zijn gereserveerde sleutelwoorden in Java die we gebruiken om de kenmerken van een al bestaand ouderblok te erven in het nieuw gecreëerde kindblok. Ze worden gebruikt om verschillende concepten in Java te implementeren. We zullen leren wat is Java extends trefwoord en wat is Java implementeert trefwoord met voorbeelden.

Laten we eerst het concept van Java Autoboxing en Unboxing in detail met Techvidvan.

Wat is extends in Java?

• Het trefwoord extends in Java is nuttig wanneer we de eigenschappen en methoden van een hoofdklasse willen overerven in onze childklasse.
• Dit extends trefwoord legt de overervingsrelatie tussen twee klassen vast.
• We gebruiken het bij het maken van een afgeleide klasse van de bovenliggende klasse of bij het maken van een subklasse van de bovenliggende klasse.
• De regel is dat een klasse maximaal slechts één klasse kan uitbreiden.
• Wanneer een klasse een andere klasse uitbreidt, kan zij de in een bovenliggende klasse gedefinieerde methoden overriden.
• We gebruiken het extends keyword ook als we willen dat een interface een andere interface extend of overerft.

Wordt vertrouwd met het concept van Java Inheritance in detail met Techvidvan.

Code om het extends keyword in Java te begrijpen:

package com.techvidvan.extendsvsimplements;//Parent classclass Country{ String name = "India"; public void display() { System.out.println("This is my country India"); }}//child class extends the parent classclass City extends Country{ // defining additional properties to the derived class String state = "Rajasthan"; String city = "Jaipur";}public class ExtendsDemo{ public static void main(String args) { City obj=new City(); obj.display(); System.out.println("Name of the city is: " + obj.name); System.out.println("City is present in " + obj.state + "state"); }}

Output:

Wat is implementeren in Java?

• We gebruiken het sleutelwoord implementeren tijdens het implementeren van een interface.
• Een klasse kan een interface implementeren met behulp van het sleutelwoord implementeren.
• Een interface is een abstract type in Java dat een verzameling van abstracte methoden bevat. We kunnen een interface niet instantiëren, dat wil zeggen, we kunnen geen objecten van een interface maken.
• Wanneer een klasse een interface implementeert, moet zij alle methoden definiëren die in de interface aanwezig zijn door de implementatie van elk van de methoden te verstrekken.
• Als de klasse die een interface implementeert, niet alle methoden van de interface definieert of niet de implementatie van alle methoden van de interface bevat, dan moeten we de klasse als abstract declareren. Anders geeft de compiler een fout.
• Java ondersteunt geen meervoudige overerving, maar we kunnen meervoudige overerving in onze code implementeren door meerdere interfaces in Java te gebruiken.
• Een interface kan nooit een andere interface implementeren. De reden is dat als de interface zal een andere interface te implementeren dan moet het alle methoden van de interface die het implementeert te definiëren, maar de interface kan geen concrete methoden hebben, daarom kan een interface niet een andere interface te implementeren in Java.

Vergroot uw kennis over Java Interface in detail met Techvidvan.

Code om de uitvoering van java implementeert trefwoord te begrijpen:

package com.techvidvan.extendsvsimplements;//Creating an interfaceinterface MyInterface{ //Declaring abstract methods inside it void displayString(String s); void showNumber(int i);}//Implementing the interface using the implements keywordpublic class MyClass implements MyInterface{ //Implementing all the methods declared in the interface public void displayString(String s) { System.out.println("The string value is: " +s); } public void showNumber(int i) { System.out.println("The integer value is: " +i); } public static void main(String args) { MyClass obj = new MyClass(); obj.displayString("TechVidvan"); obj.showNumber(20); }}

Uitvoer:

Voorbeeld van meervoudige interfaces

Nu zullen we een voorbeeld zien waarin één klasse meer dan één interface tegelijk implementeert en dus meervoudige overervingen in Java vastlegt. We zullen 3 interfaces maken: Walkable, Swimmable, en Talkable en één klasse HumanBeing die alle 3 de interfaces implementeert.

1. interface: Walkable.java

package com.techvidvan.extendsvsimplements;public interface Walkable { public void walk();}

2. interface: Swimmable.java

package com.techvidvan.extendsvsimplements;public interface Swimmable{ public void swim();}

3. interface: Talkable.java

package com.techvidvan.extendsvsimplements;public interface Talkable { public void talk();}

4. Klasse: HumanBeing.java

package com.techvidvan.extendsvsimplements;\To implement multiple interfaces we must use commas to separate thempublic class HumanBeing implements Walkable, Swimmable, Talkable{ @Override public void walk() { System.out.println("I can walk"); } @Override public void swim() { System.out.println("I can swim"); } @Override public void talk() { System.out.println("I can talk"); } public static void main(String args) { HumanBeing human= new HumanBeing(); human.walk(); human.swim(); human.talk(); }}

Output:

Verschil tussen Extends en Implementments in Java

We hebben de voorbeelden van beide sleutelwoorden gezien, laten we nu java extends vs implementments in detail bekijken:

Summary

Dus concluderend komen we aan het einde van het artikel over het verschil tussen extends en implementments in java. We hebben de belangrijkste verschillen tussen deze sleutelwoorden doorgenomen. Beiden gebruiken direct of indirect het concept van overerving in Java. Maar, we kunnen besluiten dat het implementeren van een interface meer flexibiliteit biedt dan het uitbreiden van een klasse, omdat we een enkele klasse kunnen uitbreiden, maar we kunnen meerdere overervingen implementeren in Java. Hopelijk heb je na het lezen van dit artikel eindelijk het sleutelwoord extends vs implements in Java begrepen.