Leg uit in een gemakkelijk te begrijpen taal of een link naar een artikel.
Antwoord 1, autoriteit 100%
Extendsis voor het verlengenvan een klas.
implementsis voor het implementerenvan een interface
Het verschil tussen een interface en een gewone klasse is dat je in een interface geen van de gedeclareerde methoden kunt implementeren. Alleen de klasse die de interface “implementeert” kan de methoden implementeren. Het C++-equivalent van een interface zou een abstracte klasse zijn (niet PRECIES hetzelfde, maar ongeveer).
Java ondersteunt ook geen meervoudige overervingvoor klassen. Dit wordt opgelost door meerdere interfaces te gebruiken.
public interface ExampleInterface {
public void doAction();
public String doThis(int number);
}
public class sub implements ExampleInterface {
public void doAction() {
//specify what must happen
}
public String doThis(int number) {
//specfiy what must happen
}
}
verlengt nu een les
public class SuperClass {
public int getNb() {
//specify what must happen
return 1;
}
public int getNb2() {
//specify what must happen
return 2;
}
}
public class SubClass extends SuperClass {
//you can override the implementation
@Override
public int getNb2() {
return 3;
}
}
in dit geval
Subclass s = new SubClass();
s.getNb(); //returns 1
s.getNb2(); //returns 3
SuperClass sup = new SuperClass();
sup.getNb(); //returns 1
sup.getNb2(); //returns 2
Houd er ook rekening mee dat een @Override-tag niet vereist is voor het implementeren van een interface, aangezien er niets in de originele interfacemethoden overschreven kan worden
Ik stel voor dat je wat meer onderzoek doet naar dynamische binding, polymorfisme en in het algemeen overerving in objectgeoriënteerd programmeren
Antwoord 2, autoriteit 10%
Ik merk dat je enkele C++-vragen in je profiel hebt. Als u het concept van meervoudige overervingvan C++ begrijpt (verwijzend naar klassen die kenmerken overerven van meer dan één andere klasse), staat Java dit niet toe, maar het heeft wel trefwoord interface, wat een beetje lijkt op een pure virtuele klasse in C++. Zoals door veel mensen wordt vermeld, Extendseen klasse (en je kunt er maar vanaf één uitbreiden), en je implementeen interface — maar je klas kan zoveel interfaces implementeren zoals je wilt.
Met andere woorden, deze trefwoorden en de regels die het gebruik ervan bepalen, schetsen de mogelijkheden voor meervoudige overerving in Java (u kunt maar één superklasse hebben, maar u kunt meerdere interfaces implementeren).
Antwoord 3, autoriteit 8%
Over het algemeen implementatiesdie worden gebruikt voor het implementeren van een interfaceen uitbreidingendie worden gebruikt voor uitbreidingvan basisklassegedrag of abstracteklas.
verlengt: een afgeleide klasse kan een basisklasse uitbreiden. U kunt het gedrag van een gevestigde relatie opnieuw definiëren. Afgeleide klasse “is een” basisklasse type
implementeert: u voert een contract uit. De klasse die de interface implementeert “heeft een” mogelijkheid.
Met java 8-release kan de interface standaardmethoden in de interface hebben, wat zorgt voor implementatie in de interface zelf.
Raadpleeg deze vraag voor wanneer u ze allemaal moet gebruiken:
Interface versus abstracte klasse (algemene OO)
Voorbeeld om dingen te begrijpen.
public class ExtendsAndImplementsDemo{
public static void main(String args[]){
Dog dog = new Dog("Tiger",16);
Cat cat = new Cat("July",20);
System.out.println("Dog:"+dog);
System.out.println("Cat:"+cat);
dog.remember();
dog.protectOwner();
Learn dl = dog;
dl.learn();
cat.remember();
cat.protectOwner();
Climb c = cat;
c.climb();
Man man = new Man("Ravindra",40);
System.out.println(man);
Climb cm = man;
cm.climb();
Think t = man;
t.think();
Learn l = man;
l.learn();
Apply a = man;
a.apply();
}
}
abstract class Animal{
String name;
int lifeExpentency;
public Animal(String name,int lifeExpentency ){
this.name = name;
this.lifeExpentency=lifeExpentency;
}
public void remember(){
System.out.println("Define your own remember");
}
public void protectOwner(){
System.out.println("Define your own protectOwner");
}
public String toString(){
return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
}
}
class Dog extends Animal implements Learn{
public Dog(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " will protect owner");
}
public void learn(){
System.out.println(this.getClass().getSimpleName()+ " can learn:");
}
}
class Cat extends Animal implements Climb {
public Cat(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
}
public void climb(){
System.out.println(this.getClass().getSimpleName()+ " can climb");
}
}
interface Climb{
public void climb();
}
interface Think {
public void think();
}
interface Learn {
public void learn();
}
interface Apply{
public void apply();
}
class Man implements Think,Learn,Apply,Climb{
String name;
int age;
public Man(String name,int age){
this.name = name;
this.age = age;
}
public void think(){
System.out.println("I can think:"+this.getClass().getSimpleName());
}
public void learn(){
System.out.println("I can learn:"+this.getClass().getSimpleName());
}
public void apply(){
System.out.println("I can apply:"+this.getClass().getSimpleName());
}
public void climb(){
System.out.println("I can climb:"+this.getClass().getSimpleName());
}
public String toString(){
return "Man :"+name+":Age:"+age;
}
}
uitvoer:
Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man
Belangrijke punten om te begrijpen:
- Honden Katzijn dieren en ze hebben
remember() enprotectOwner() uitgebreid doorname,lifeExpentencyvanAnimal - Kat kan klimmen() maar hond niet. Hond kan denken() maar kat niet. Deze specifieke mogelijkheden worden toegevoegd aan
CatenDogdoor die mogelijkheid te implementeren. - De mens is geen dier, maar hij kan
Think,Learn,Apply,Climb
Door deze voorbeelden door te nemen, kunt u begrijpen dat
Niet-gerelateerde klassen kunnen mogelijkheden hebben via de interface, maar gerelateerde klassen overschrijven het gedrag door uitbreiding van basisklassen.
Antwoord 4, autoriteit 5%
Extendsis voor als je overerft van een basisklasse(d.w.z. de functionaliteit uitbreidt).
implementsis voor wanneer u een interfaceimplementeert.
Dit is een goede plek om te beginnen: Interfaces en overerving .
Antwoord 5, autoriteit 4%
Een classkan alleen een interface“implementeren”. Een klasse “verlengt” alleen een class. Evenzo kan een interfaceeen andere interfaceuitbreiden.
Een classkan slechts één andere classuitbreiden. Een classkan meerdere interface‘s implementeren.
Als je in plaats daarvan meer wilt weten wanneer je abstract classes en interfaces moet gebruiken, raadpleeg dan deze thread: Interface versus abstracte klasse (algemene OO)
Antwoord 6, autoriteit 4%
Zoals weergegeven in de onderstaande afbeelding, breidt een klasse een andere klasse uit, een interface breidt een andere interface uit, maar een klasse implementeert een interface.
Voor meer details
Antwoord 7, autoriteit 4%
Een interface is een beschrijving van de acties die een object kan doen… bijvoorbeeld als je een lichtschakelaar omdraait, gaat het licht aan, het maakt je niet uit hoe, alleen dat het doet. In Object Oriented Programming is een interface een beschrijving van alle functies die een object moet hebben om een “X” te zijn. Nogmaals, als voorbeeld, alles dat “ALS WERKT” als licht, zou een turn_on() methode en een turn_off() methode moeten hebben. Het doel van interfaces is om de computer in staat te stellen deze eigenschappen af te dwingen en om te weten dat een object van TYPE T (wat de interface ook is) functies moet hebben die X,Y,Z, enz. worden genoemd.
Een interface is een programmeerstructuur/syntaxis waarmee de computer bepaalde eigenschappen op een object (klasse) kan afdwingen. Stel bijvoorbeeld dat we een autoklasse en een scooterklasse en een vrachtwagenklasse hebben. Elk van deze drie klassen zou een actie start_engine() moeten hebben. Hoe de “motor wordt gestart” voor elk voertuig wordt overgelaten aan elke specifieke klasse, maar het feit dat ze een start_engine-actie moeten hebben, is het domein van de interface.
Antwoord 8, autoriteit 2%
Verlengt: dit wordt gebruikt om attributen van een bovenliggende klasse in de basisklasse te krijgen en kan reeds gedefinieerde methoden bevatten die kunnen worden overschreven in de onderliggende klasse.
Implementeert: dit wordt gebruikt om een interface te implementeren (bovenliggende klasse met alleen functiesignaturen maar niet hun definities) door deze in de onderliggende klasse te definiëren.
Er is één speciale voorwaarde: “Wat als ik wil dat een nieuwe interface het onderliggende is van een bestaande interface?”. In de bovenstaande toestand, breidt de onderliggende interface uitde bovenliggende interface.
Antwoord 9, autoriteit 2%
Beide trefwoorden worden gebruikt bij het maken van uw eigen nieuwe klasse in de Java-taal.
Verschil: implementbetekent dat je de elementen van een Java-interface in je klas gebruikt. Extendsbetekent dat je een subklasse aanmaakt van de basisklasse die je uitbreidt. U kunt slechts één klas uitbreiden in uw onderliggende klas, maar u kunt zoveel interfaces implementeren als u wilt.
Raadpleeg de Oracle-documentatiepagina op de interfacevoor meer details .
Dit kan helpen om te verduidelijken wat een interface is, en de conventies rond het gebruik ervan.
Antwoord 10, autoriteit 2%
-
A breidt B uit:
A en B zijn beide klassen of beide interfaces
-
A implementeert B
A is een klasse en B is een interface
-
Het resterende geval waarin A een interface is en B een klasse is niet legaal in Java.
Antwoord 11, autoriteit 2%
Implements wordt gebruikt voor interfaces en extends wordt gebruikt om een klasse uit te breiden.
Om het in eenvoudiger bewoordingen duidelijker te maken, is een interface zoals het klinkt – een interface – een model dat je moet toepassen, volgen, samen met je ideeën erop.
Verlengen wordt gebruikt voor lessen, hier breid je iets uit dat al bestaat door er meer functionaliteit aan toe te voegen.
Nog een paar opmerkingen:
een interface kan een andere interface uitbreiden.
En als je moet kiezen tussen het implementeren van een interface of het uitbreiden van een klasse voor een bepaald scenario, kies dan voor het implementeren van een interface. Omdat een klasse meerdere interfaces kan implementeren, maar slechts één klasse kan uitbreiden.
Antwoord 12
We gebruiken SubClassbreidt SuperClassalleen uit wanneer de subklasse bepaalde functionaliteit (methoden of instantievariabelen) wil gebruiken die al is gedeclareerd in de SuperClass, of als ik de functionaliteit van de SuperClassenigszins wil wijzigen (Methode overschrijven). Maar stel, ik heb een klasse Animal (SuperClass) en een klasse Dog (SubClass) en er zijn enkele methoden die ik heb gedefinieerd in de klasse Animal, bijvoorbeeld. doEat(); , doSleep(); … en nog veel meer.
Mijn Dog-klasse kan nu eenvoudig de Animal-klasse uitbreiden. Als ik wil dat mijn hond een van de methoden gebruikt die in de Animal-klasse zijn gedeclareerd, kan ik die methoden aanroepen door simpelweg een Dog-object te maken. Op deze manier kan ik garanderen dat ik een hond heb die kan eten en slapen en kan doen wat ik wil dat de hond doet.
Stel je nu eens voor dat er op een dag een kattenliefhebber in onze werkruimte komt en ze probeert de dierenklasse uit te breiden (katten eten en slapen ook). Ze maakt een Cat-object en begint de methoden aan te roepen.
Maar, laten we zeggen, iemand probeert een object van de klasse Animal te maken. Je kunt zien hoe een kat slaapt, je kunt zien hoe een hond eet, je kunt zien hoe een olifant drinkt.
Maar het heeft geen zin om een object van de klasse Animal te maken. Omdat het een sjabloon is en we geen algemene manier van eten willen.
Dus in plaats daarvan zal ik er de voorkeur aan geven een abstracte klasse te maken die niemand kan instantiëren, maar die kan worden gebruikt als sjabloon voor andere klassen.
Dus tot slot, Interface is niets anders dan een abstracte klasse (een pure abstracte klasse) die geen methode-implementaties bevat, maar alleen de definities (de sjablonen). Dus wie de interface implementeert, weet gewoon dat ze de sjablonen van doEat(); en doSleep(); maar ze moeten hun eigen doEat(); en doSleep(); methoden volgens hun behoefte.
Je breidt alleen uit als je een deel van de SuperClass opnieuw wilt gebruiken (maar houd er rekening mee dat je de methoden van je SuperClass altijd kunt overschrijven naar behoefte) en je implementeert wanneer je de sjablonen wilt en je ze wilt definiëren alleen (volgens uw behoefte).
Ik zal een stukje code met je delen: je probeert het met verschillende sets invoer en bekijkt de resultaten.
class AnimalClass {
public void doEat() {
System.out.println("Animal Eating...");
}
public void sleep() {
System.out.println("Animal Sleeping...");
}
}
public class Dog extends AnimalClass implements AnimalInterface, Herbi{
public static void main(String[] args) {
AnimalInterface a = new Dog();
Dog obj = new Dog();
obj.doEat();
a.eating();
obj.eating();
obj.herbiEating();
}
public void doEat() {
System.out.println("Dog eating...");
}
@Override
public void eating() {
System.out.println("Eating through an interface...");
// TODO Auto-generated method stub
}
@Override
public void herbiEating() {
System.out.println("Herbi eating through an interface...");
// TODO Auto-generated method stub
}
}
Gedefinieerde interfaces:
public interface AnimalInterface {
public void eating();
}
interface Herbi {
public void herbiEating();
}
Antwoord 13
In de meest eenvoudige bewoordingen wordt extendsgebruikt om te erven van een klasseen implementswordt gebruikt om een interfacetoe te passen. sterk>in je klas
verlengt:
public class Bicycle {
//properties and methods
}
public class MountainBike extends Bicycle {
//new properties and methods
}
implementeert:
public interface Relatable {
//stuff you want to put
}
public class RectanglePlus implements Relatable {
//your class code
}
als je nog steeds in de war bent, lees dan dit: https://docs. oracle.com/javase/tutorial/java/IandI/subclasses.html
https://docs.oracle.com/javase/tutorial/java/IandI /usinginterface.html
Antwoord 14
Als een subklasse een klasse uitbreidt, kan de subklasse de code die in het supertype is gedefinieerd, erven (hergebruiken) en overschrijven.
Wanneer een klasse een interface implementeert, kan een object dat op basis van de klasse is gemaakt, worden gebruikt in elke context die een waarde van de interface verwacht.
De echte addertje onder het gras is dat terwijl we iets implementeren, dit simpelweg betekent dat we die methoden gebruiken zoals ze zijn. Er is geen ruimte voor verandering in hun waarden en retourtypes.
Maar als we iets uitbreiden, wordt het een verlengstuk van je klas. Je kunt het veranderen, gebruiken, hergebruiken en het hoeft niet per se dezelfde waarden terug te geven als in de superklasse.
Antwoord 15
Klassenen Interfaceszijn beide contracten.
Ze bieden methoden en eigenschappen waarop andere delen van een toepassing vertrouwen.
U definieert een interfacewanneer u niet geïnteresseerd bent in de uitvoeringsdetails van dit contract. Het enige waar u zich zorgen over hoeft te maken, is dat het contract (de interface) bestaat.
In dit geval laat je het over aan de klasse die de interface implementeertom zich te bekommeren om de details hoe het contract wordt uitgevoerd. Alleen klassen kunnen interfaces implementeren.
verlengtwordt gebruikt wanneer u details van een bestaand contract wilt vervangen.
Zo vervang je de ene manier om een contract na te komen door een andere manier. Klassen kunnen andere klassen uitbreiden en interfaces kunnen andere interfaces uitbreiden.
Antwoord 16
Extendswordt gebruikt wanneer u attributen van een bovenliggende klasse/interface in uw onderliggende klasse/interface wilt en implementswordt gebruikt wanneer u attributen van een interface in uw klasse wilt.
Voorbeeld:
-
Blijft uit met klasse
klas Ouder{
}
klas Kind verlengt ouder{
}
-
Breid uit met gebruik van interface
interface Ouder{
}
interface Kind breidt ouder uit{
}
-
Implementeert
interface A{
}
klasse B implementeert A{
}
Combinatie van verlengstukken en werktuigen
interface A{
}
class B
{
}
class C implements A,extends B{
}
Antwoord 17
verlengt
- klasse verlengt slechts één klasse
- interface breidt een of meer interfaces uit
implementeert
- klasse implementeert een of meer interfaces
- interfaces ‘kan niet’ implementeren iets
abstracte klassen werken ook als klasse, met uitbreidingen en implementaties
Antwoord 18
Die twee trefwoorden zijn direct gekoppeld aan Inheritance, het is een kernconcept van OOP.
Als we een klasse overnemen van een andere klasse, kunnen we extendsgebruiken, maar als we sommige interfaces naar onze klasse gaan erven, kunnen we geen extends gebruiken, we moeten implementsgebruiken en we kan het trefwoord verlengtgebruiken om de interface over te nemen van een andere interface.
Antwoord 19
In Java breidt een klasse (subklasse) een andere klasse (superklasse) uit en kan deze de methoden overschrijven die in de superklasse zijn gedefinieerd.
Terwijl implements wordt gebruikt wanneer een klasse probeert de methoden te declareren die zijn gedefinieerd in de interface, wordt de genoemde klasse uitgebreid.