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

Bitte erklären Sie es in einer leicht verständlichen Sprache oder verlinken Sie auf einen Artikel.

extends ist für verlängern eine Klasse.

implements ist für umsetzen eine 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 das Interface “implementiert”, kann die Methoden implementieren. Das C++-Äquivalent einer Schnittstelle wäre eine abstrakte Klasse (nicht GENAU die gleiche, aber ziemlich genau).

Auch Java wird nicht unterstützt 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

Beachten Sie auch, dass ein @Override -Tag ist für die Implementierung einer Schnittstelle nicht erforderlich, da in den ursprünglichen Schnittstellenmethoden nichts enthalten ist überschrieben werden

Ich schlage vor, Sie recherchieren weiter Dynamische Bindung, Polymorphismus und allgemein Vererbung in der objektorientierten Programmierung

Mir ist aufgefallen, dass Sie einige C++-Fragen in Ihrem Profil haben. Wenn Sie das Konzept von verstehen Mehrfachvererbung von C++ (bezieht sich auf Klassen, die Merkmale von mehr als einer anderen Klasse erben), erlaubt Java dies nicht, hat aber ein Schlüsselwort interface, was so etwas wie eine rein virtuelle Klasse in C++ ist. Wie von vielen Leuten erwähnt, du extend eine Klasse (und Sie können nur von einer erweitern) und Sie implement eine Schnittstelle — aber Ihre Klasse kann beliebig viele Schnittstellen implementieren.

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).

Allgemein implementiert verwendet für die Implementierung einer Schnittstelle und erweitert benutzt für Verlängerung des Basisklassenverhaltens oder abstrakt Klasse.

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

implementiert: Sie setzen einen Vertrag um. Die Klasse, die die Schnittstelle implementiert “hat ein„Fähigkeit.

Mit Java 8 Release kann Schnittstelle haben Ursprünglich Methoden in der Schnittstelle, die die Implementierung in der Schnittstelle selbst bereitstellt.

Beziehen Sie sich auf diese Frage, um zu erfahren, wann Sie sie verwenden sollten:

Schnittstelle vs. abstrakte Klasse (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;
    }
}

Ausgang:

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 zum Verständnis:

1. Hund und Katze sind Tiere und sie erweitert remember() und protectOwner() durch Teilen name,lifeExpentency von Animal
2. Katze kann klettern() aber Hund nicht. Hund kann denken(), Katze nicht. Diese spezifischen Fähigkeiten werden hinzugefügt Cat und Dog durch Implementierung dieser Fähigkeit.
3. Der Mensch ist kein Tier, aber er kann es Think,Learn,Apply,Climb

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

Nicht verwandte Klassen können über Schnittstellen Fähigkeiten haben, aber verwandte Klassen setzen das Verhalten durch Erweiterung von Basisklassen außer Kraft.

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

Für mehr Einzelheiten

extends ist, wenn Sie von a erben Basisklasse (dh Erweiterung seiner Funktionalität).

implements ist für die Implementierung einer Schnittstelle.

Hier ist ein guter Anfang: Schnittstellen und Vererbung.

EIN class kann nur an “implementieren”. interface. Eine Klasse “erweitert” nur a class. Ebenso ein interface kann eine andere verlängern interface.

EIN class können sich nur gegenseitig verlängern class. EIN class mehrere umsetzen kann interfaceS.

Wenn Sie stattdessen mehr daran interessiert sind zu wissen, wann Sie es verwenden müssen abstract classes und interfaces, siehe diesen Thread: Interface vs Abstract Class (general OO)

Eine Schnittstelle ist eine Beschreibung der Aktionen, die ein Objekt ausführen kann … zum Beispiel, wenn Sie einen Lichtschalter betätigen, geht das Licht an, es ist Ihnen egal, wie, es tut es einfach. In der objektorientierten Programmierung ist eine Schnittstelle eine Beschreibung aller Funktionen, die ein Objekt haben muss, um ein “X” zu sein. Nochmals, als Beispiel, alles, was ein Licht „FÄHIG IST“, sollte eine turn_on()-Methode und eine turn_off()-Methode haben. Der Zweck von Schnittstellen besteht darin, dem Computer zu ermöglichen, diese Eigenschaften durchzusetzen und zu wissen, dass ein Objekt vom TYP T (was auch immer die Schnittstelle ist) Funktionen namens X, Y, Z usw. haben muss.

Eine Schnittstelle ist eine Programmierstruktur/Syntax, die es dem Computer ermöglicht, bestimmte Eigenschaften eines Objekts (einer Klasse) durchzusetzen. Angenommen, wir haben eine Autoklasse, eine Rollerklasse und eine Lkw-Klasse. Jede dieser drei Klassen sollte eine Aktion start_engine() haben. Wie der “Motor gestartet wird” für jedes Fahrzeug bleibt jeder einzelnen Klasse überlassen, aber die Tatsache, dass sie eine start_engine-Aktion haben müssen, ist die Domäne der Schnittstelle.