Implementiert vs erweitert: Wann verwenden? Was ist der Unterschied?

Bitte erklären Sie in einer leicht verständlichen Sprache oder einem Link zu einem Artikel.

extendsdient zum Erweitern einer Klasse.

implementsdient zur Implementierung einer Schnittstelle

Der Unterschied zwischen einer Schnittstelle und einer regulären Klasse besteht darin, dass Sie in einer Schnittstelle keine der deklarierten Methoden implementieren können. Nur die Klasse, die die Schnittstelle "implementiert", kann die Methoden implementieren. Das C ++ - Äquivalent einer Schnittstelle wäre eine abstrakte Klasse (nicht genau das gleiche, aber ziemlich genau).

Java unterstützt auch keine Mehrfachvererbung für Klassen. Dies wird durch die Verwendung mehrerer Schnittstellen gelöst.

 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
     }
 }

jetzt eine Klasse erweitern

 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 diesem Fall

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

Ich schlage vor, dass Sie mehr über dynamische Bindung, Polymorphismus und allgemeine Vererbung in der objektorientierten Programmierung forschen

Ich stelle fest, dass Sie einige C ++ - Fragen in Ihrem Profil haben. Wenn Sie das Konzept der Mehrfachvererbung von C ++ verstehen (bezogen auf Klassen, die Merkmale von mehr als einer anderen Klasse erben), lässt Java dies nicht zu, verfügt jedoch über ein Schlüsselwort interface, das einer reinen virtuellen Klasse in C ++ ähnelt. Wie von vielen Leuten erwähnt, sind Sie extendeine Klasse (und Sie können nur von einer erweitern) und Sie implementeine Schnittstelle - aber Ihre Klasse kann so viele Schnittstellen implementieren, wie Sie möchten.

Das heißt, diese Schlüsselwörter und die Regeln für ihre Verwendung beschreiben die Möglichkeiten der Mehrfachvererbung in Java (Sie können nur eine Superklasse haben, aber Sie können mehrere Schnittstellen implementieren).

Im Allgemeinen implementiert verwendet , um eine für die Implementierung Schnittstelle und erstreckt sich für verwendete Erweiterung der Basisklasse Verhalten oder abstrakte Klasse.

erweitert : Eine abgeleitete Klasse kann eine Basisklasse erweitern. Sie können das Verhalten einer etablierten Beziehung neu definieren. Abgeleitete Klasse " ist ein " Basisklassentyp

implementiert : Sie implementieren einen Vertrag. Die Klasse, die die Schnittstelle implementiert, " hat eine " Fähigkeit.

Mit Java 8 Release kann die Schnittstelle Standardmethoden in der Schnittstelle haben, die die Implementierung in der Schnittstelle selbst ermöglichen.

In dieser Frage erfahren Sie, wann Sie sie verwenden müssen:

Interface vs Abstract Class (allgemeines OO)

Beispiel, um Dinge zu verstehen.

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;
    }
}

Ausgabe:

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

Wichtige Punkte zu verstehen:

1. Hund und Katze sind Tiere und sie haben remember() und protectOwner() durch Teilen name,lifeExpentencyvon erweitertAnimal
2. Katze kann klettern (), Hund nicht. Hund kann denken (), Katze aber nicht . Diese spezifischen Funktionen werden zu Catund Dogdurch Implementierung dieser Funktion hinzugefügt .
3. Der Mensch ist kein Tier, aber er kann Think,Learn,Apply,Climb

Wenn Sie diese Beispiele durchgehen, können Sie das verstehen

Nicht verwandte Klassen können über die Schnittstelle Funktionen haben, aber verwandte Klassen überschreiben das Verhalten durch die Erweiterung von Basisklassen.

extendsist für den Fall, dass Sie von einer Basisklasse erben (dh deren Funktionalität erweitern).

implementsist für die Implementierung einer Schnittstelle .

Hier ist ein guter Anfang: Schnittstellen und Vererbung .

A classkann nur ein "implementieren" interface. Eine Klasse "erweitert" nur a class. Ebenso kann ein interfaceanderer erweitert werden interface.

A classkann sich nur gegenseitig verlängern class. A classkann mehrere interfaces implementieren .

Wenn Sie stattdessen mehr daran interessiert sind, wann abstract classes und interfaces verwendet werden sollen, lesen Sie diesen Thread: Schnittstelle vs Abstrakte Klasse (allgemeines OO)

Eine Schnittstelle ist eine Beschreibung der Aktionen, die ein Objekt ausführen kann. Wenn Sie beispielsweise einen Lichtschalter betätigen, geht das Licht an. Es ist Ihnen egal, wie, nur dass es funktioniert. In der objektorientierten Programmierung beschreibt eine Schnittstelle alle Funktionen, die ein Objekt haben muss, um ein "X" zu sein. Als Beispiel sollte alles, was "ACTS LIKE" ein Licht ist, eine turn_on () -Methode und eine turn_off () -Methode haben. Der Zweck von Schnittstellen besteht darin, dem Computer zu ermöglichen, diese Eigenschaften zu erzwingen und zu wissen, dass ein Objekt vom Typ T (unabhängig von der Schnittstelle) Funktionen mit den Namen X, Y, Z usw. haben muss.

Eine Schnittstelle ist eine Programmierstruktur / -syntax, mit der der Computer bestimmte Eigenschaften für ein Objekt (eine Klasse) erzwingen kann. Nehmen wir zum Beispiel an, wir haben eine Auto-Klasse und eine Roller-Klasse und eine LKW-Klasse. Jede dieser drei Klassen sollte eine start_engine () -Aktion haben. Wie der "Motor" für jedes Fahrzeug gestartet wird, bleibt jeder bestimmten Klasse überlassen, aber die Tatsache, dass sie eine start_engine-Aktion haben müssen, ist die Domäne der Schnittstelle .

Wie in der folgenden Abbildung gezeigt, erweitert eine Klasse eine andere Klasse, eine Schnittstelle eine andere Schnittstelle, aber eine Klasse implementiert eine Schnittstelle.

Für weitere Details

Erweitert : Dies wird verwendet, um Attribute einer übergeordneten Klasse in die Basisklasse zu übertragen, und kann bereits definierte Methoden enthalten, die in der untergeordneten Klasse überschrieben werden können.

Implementiert : Dies wird verwendet, um eine Schnittstelle (übergeordnete Klasse mit nur Funktionssignaturen, jedoch nicht deren Definitionen) zu implementieren, indem sie in der untergeordneten Klasse definiert wird.

Es gibt eine spezielle Bedingung: "Was ist, wenn eine neue Schnittstelle das untergeordnete Element einer vorhandenen Schnittstelle sein soll?". In der obigen Bedingung erweitert die untergeordnete Schnittstelle die übergeordnete Schnittstelle.

• A erweitert B:

  A und B sind beide Klassen oder beide Schnittstellen

• A implementiert B.

  A ist eine Klasse und B ist eine Schnittstelle

• Der verbleibende Fall, in dem A eine Schnittstelle und B eine Klasse ist, ist in Java nicht zulässig.

Implementiert wird für Schnittstellen verwendet und erweitert wird verwendet, um eine Klasse zu erweitern.

Um es einfacher zu machen, ist eine Benutzeroberfläche so, wie sie sich anhört - eine Benutzeroberfläche - ein Modell, das Sie zusammen mit Ihren Ideen anwenden, befolgen und befolgen müssen.

Erweitern wird für Klassen verwendet. Hier erweitern Sie etwas, das bereits vorhanden ist, indem Sie ihm weitere Funktionen hinzufügen.

Noch ein paar Anmerkungen:

Eine Schnittstelle kann eine andere Schnittstelle erweitern.

Wenn Sie zwischen der Implementierung einer Schnittstelle oder der Erweiterung einer Klasse für ein bestimmtes Szenario wählen müssen, sollten Sie eine Schnittstelle implementieren. Weil eine Klasse mehrere Schnittstellen implementieren kann, aber nur eine Klasse erweitert.

Wenn eine Unterklasse eine Klasse erweitert, kann die Unterklasse den im Supertyp definierten Code erben (wiederverwenden) und überschreiben. Wenn eine Klasse eine Schnittstelle implementiert, kann ein aus der Klasse erstelltes Objekt in einem beliebigen Kontext verwendet werden, der einen Wert der Schnittstelle erwartet.

Der eigentliche Haken dabei ist, dass wir bei der Implementierung lediglich bedeuten, dass wir diese Methoden so verwenden, wie sie sind. Es gibt keinen Spielraum für Änderungen ihrer Werte und Rückgabetypen.

Aber wenn wir etwas erweitern, wird es eine Erweiterung Ihrer Klasse. Sie können es ändern, verwenden, wiederverwenden, verwenden und es muss nicht unbedingt dieselben Werte wie in der Oberklasse zurückgeben.

Wir verwenden SubClass erweitert SuperClass nur, wenn die Unterklasse einige Funktionen (Methoden oder Instanzvariablen) verwenden möchte, die bereits in der SuperClass deklariert sind , oder wenn ich die Funktionalität der SuperClass geringfügig ändern möchte (Methodenüberschreibung). Angenommen , ich habe beispielsweise eine Tierklasse ( SuperClass ) und eine Hundeklasse ( SubClass ), und es gibt nur wenige Methoden, die ich in der Tierklasse definiert habe, z. doEat (); , doSleep (); ... und viele mehr.

Jetzt kann meine Hundeklasse einfach die Tierklasse erweitern. Wenn mein Hund eine der in der Tierklasse deklarierten Methoden verwenden soll, kann ich diese Methoden aufrufen, indem ich einfach ein Hundeobjekt erstelle. Auf diese Weise kann ich garantieren, dass ich einen Hund habe, der essen und schlafen und alles tun kann, was der Hund sonst noch tun soll.

Stellen Sie sich vor, eines Tages kommt ein Katzenliebhaber in unseren Arbeitsbereich und versucht, die Tierklasse zu erweitern (Katzen essen und schlafen auch). Sie erstellt ein Cat-Objekt und ruft die Methoden auf.

Aber zum Beispiel versucht jemand, ein Objekt aus der Tierklasse zu machen. Sie können sagen, wie eine Katze schläft, Sie können sagen, wie ein Hund frisst, Sie können sagen, wie ein Elefant trinkt. Aber es macht keinen Sinn, ein Objekt der Tierklasse zu machen. Weil es eine Vorlage ist und wir keine allgemeine Art zu essen wollen.

Daher werde ich lieber eine abstrakte Klasse erstellen, die niemand instanziieren kann, die aber als Vorlage für andere Klassen verwendet werden kann.

Zusammenfassend ist Interface nichts anderes als eine abstrakte Klasse (eine reine abstrakte Klasse), die keine Methodenimplementierungen enthält, sondern nur die Definitionen (die Vorlagen). Wer also die Schnittstelle implementiert, weiß nur, dass er die Vorlagen von doEat () hat. und doSleep (); aber sie müssen ihr eigenes doEat () definieren; und doSleep (); Methoden nach ihren Bedürfnissen.

Sie erweitern nur, wenn Sie einen Teil der SuperClass wiederverwenden möchten (aber denken Sie daran, dass Sie die Methoden Ihrer SuperClass je nach Bedarf jederzeit überschreiben können) und implementieren, wenn Sie die Vorlagen möchten und sie selbst definieren möchten (je nach Bedarf).

Ich werde Ihnen einen Teil des Codes mitteilen: Sie versuchen es mit verschiedenen Eingabesätzen und sehen sich die Ergebnisse an.

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

}


}

Definierte Schnittstellen :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Beide Schlüsselwörter werden verwendet, wenn Sie eine eigene neue Klasse in der Java-Sprache erstellen.

Unterschied: implementsbedeutet, dass Sie die Elemente einer Java-Schnittstelle in Ihrer Klasse verwenden. extendsbedeutet, dass Sie eine Unterklasse der Basisklasse erstellen, die Sie erweitern. Sie können nur eine Klasse in Ihrer untergeordneten Klasse erweitern, aber Sie können so viele Schnittstellen implementieren, wie Sie möchten.

Weitere Informationen finden Sie auf der Oracle-Dokumentationsseite auf der Benutzeroberfläche .

Dies kann helfen, zu verdeutlichen, was eine Schnittstelle ist und welche Konventionen sie verwendet.

In den einfachsten Begriffen wird expand verwendet, um von einer Klasse zu erben, und implement wird verwendet, um eine Schnittstelle in Ihrer Klasse anzuwenden

erweitert :

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

implementiert :

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

Wenn Sie immer noch Verwirrung haben, lesen Sie Folgendes: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Klassen und Schnittstellen sind beide Verträge . Sie bieten Methoden und Eigenschaften, auf die sich andere Teile einer Anwendung stützen.

Sie definieren eine Schnittstelle, wenn Sie nicht an den Implementierungsdetails dieses Vertrags interessiert sind. Das einzige, was Sie beachten müssen, ist, dass der Vertrag (die Schnittstelle) existiert.

In diesem Fall überlassen Sie es der Klasse, die die Schnittstelle implementiert , sich um die Details der Vertragserfüllung zu kümmern. Nur Klassen können Schnittstellen implementieren.

Erweitert wird verwendet, wenn Sie Details eines bestehenden Vertrags ersetzen möchten. Auf diese Weise ersetzen Sie eine Möglichkeit, einen Vertrag zu erfüllen, durch eine andere. Klassen können andere Klassen erweitern, und Schnittstellen können andere Schnittstellen erweitern.

Extendswird verwendet, wenn Sie Attribute der übergeordneten Klasse / Schnittstelle in Ihrer untergeordneten Klasse / Schnittstelle implementsmöchten, und wird verwendet, wenn Sie Attribute einer Schnittstelle in Ihrer Klasse möchten.

Beispiel:

1. Erweitert mit Klasse

   Klasse Parent {

   }}

   Klasse Kind erweitert Eltern {

   }}

2. Erweitert die Verwendung der Schnittstelle

   Schnittstelle Parent {

   }}

   Schnittstelle Child erweitert Parent {

   }}

3. Geräte

Schnittstelle A {

}}

Klasse B implementiert A {

}}

Kombination von Erweiterungen und Geräten

interface A{

}

class B

{

}

class C implements A,extends B{

}

erweitert

• Klasse erweitert nur eine Klasse
• Schnittstelle erweitert eine oder mehrere Schnittstellen

Geräte

• Klasse implementiert eine oder mehrere Schnittstellen
• Schnittstellen 'können' nichts implementieren

abstrakte Klassen verhalten sich auch wie Klassen, mit Erweiterungen und Implementierungen

Diese beiden Schlüsselwörter sind direkt mit Vererbung verbunden. Dies ist ein Kernkonzept von OOP. Wenn wir eine Klasse in eine andere Klasse erben können wir den Einsatz erstreckt , aber wenn wir einige Schnittstellen zu unserer Klasse gehen erben können wir nicht verwenden erstreckt sollten wir verwenden Geräte und wir können den Einsatz erstreckt sich zu vererben Schnittstelle von einer anderen Schnittstelle Schlüsselwort.