it-swarm.com.de

Anbaugeräte vs erweitert: Wann verwenden? Was ist der Unterschied?

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

667
Saad Masood

extends ist für das Erweitern einer Klasse.

implements dient zum Implementieren 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).

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

676
tgoossens

Ich stelle fest, dass Sie einige C++ - Fragen in Ihrem Profil haben. Wenn Sie das Konzept Mehrfachvererbung von C++ verstehen (in Bezug auf Klassen, die Merkmale von mehr als einer anderen Klasse erben), lässt Java dies nicht zu, hat jedoch ein Schlüsselwort interface, eine Art rein virtuelle Klasse in C++. Wie von vielen Leuten erwähnt, extend Sie eine Klasse (und Sie können nur von einer erweitern), und Sie implement eine 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).

extends wird verwendet, wenn Sie von einer Basisklasse erben (d. H. Deren Funktionalität erweitern).

implements ist für die Implementierung einer Schnittstelle vorgesehen.

Hier ist ein guter Anfang: Schnittstellen und Vererbung .

40

Im Allgemeinen implementiert zur Implementierung einer Schnittstelle und erweitert wird für die Erweiterung des Basisklassenverhaltens oder der abstrakten Klasse verwendet.

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

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

Mit der Version Java 8 kann die Schnittstelle Standardmethoden in der Schnittstelle haben, die die Implementierung in der Schnittstelle selbst bereitstellen.

In dieser Frage erfahren Sie, wann Sie welche verwenden sollen:

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

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

  1. Hund und Katze sind Tiere und haben remember () und protectOwner () durch Teilen von name,lifeExpentency erweitert von Animal
  2. Katze kann klettern (), Hund nicht. Hund kann denken (), Katze nicht . Diese spezifischen Funktionen werden zu Cat und Dog hinzugefügt, indem diese Funktion implementiert wird.
  3. Der Mensch ist kein Tier, aber er kann Think,Learn,Apply,Climb

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

Unabhängige Klassen können Funktionen über die Schnittstelle haben, verwandte Klassen überschreiben jedoch das Verhalten durch Erweiterung der Basisklassen.

38
Ravindra babu

Ein class kann nur ein interface "implementieren". Eine Klasse "erweitert" nur ein class. Ebenso kann ein interface ein anderes interface erweitern.

Ein class kann nur einen anderen class erweitern. Ein class kann mehrere interface implementieren.

Wenn Sie stattdessen mehr wissen möchten, wann Sie abstract classes und interfaces verwenden sollen, lesen Sie den folgenden Thread: Interface vs Abstract Class (general OO)

32
Hari Menon

Eine Schnittstelle ist eine Beschreibung der Aktionen, die ein Objekt ausführen kann. Wenn Sie beispielsweise einen Lichtschalter betätigen, leuchtet das Licht, es ist Ihnen egal, wie, nur dass es funktioniert. In der objektorientierten Programmierung ist eine Schnittstelle eine Beschreibung aller Funktionen, die ein Objekt haben muss, um ein "X" zu sein. Als Beispiel sollte alles, was "WIE EIN LICHT WIRKT", 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 des Typs T (unabhängig von der Schnittstelle) Funktionen mit den Bezeichnungen 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-, eine Roller- und eine Lkw-Klasse. Jede dieser drei Klassen sollte eine Aktion start_engine () haben. Wie der Motor für jedes Fahrzeug gestartet wird, bleibt der jeweiligen Klasse überlassen, aber die Tatsache, dass sie eine start_engine-Aktion haben müssen, ist die Domäne der Schnittstelle .

25
Ryan Efendy
  • A verlängert 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.

15
user207421

Wie in der folgenden Abbildung gezeigt, erweitert eine Klasse eine andere Klasse, eine Schnittstelle eine andere Schnittstelle, aber eine Klasse implementiert eine Schnittstelle. enter image description here

Für mehr Einzelheiten

15
Dev4World

Extends : Dies wird verwendet, um Attribute einer übergeordneten Klasse in die Basisklasse abzurufen und kann bereits definierte Methoden enthalten, die überschrieben werden können in der Kinderklasse.

Implementiert : Dies wird verwendet, um eine Schnittstelle (Elternklasse mit Funktionssignaturen, aber nicht deren Definitionen) zu implementieren, indem sie in definiert wird die Kinderklasse.

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

14
Guru

Implements wird für Interfaces verwendet und extend wird verwendet, um eine Klasse zu erweitern.

Um es klarer zu machen, klingt eine Benutzeroberfläche so, als ob sie sich anhört - eine Benutzeroberfläche - ein Modell, das Sie anwenden müssen, dem Sie folgen müssen, zusammen mit Ihren Ideen.

Extend 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 für ein bestimmtes Szenario eine Schnittstelle implementieren oder eine Klasse erweitern möchten, müssen Sie eine Schnittstelle implementieren. Denn eine Klasse kann mehrere Interfaces implementieren, aber nur eine Klasse erweitern.

11
Kazekage Gaara

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, während wir alles implementieren, diese Methoden einfach so verwenden, wie sie sind. Die Werte und Rückgabetypen können nicht geändert werden.

Aber wenn wir etwas erweitern, wird es eine Erweiterung Ihrer Klasse. Sie können es ändern, verwenden und wiederverwenden. Es müssen nicht unbedingt dieselben Werte wie in der Superklasse zurückgegeben werden.

7
Nikhil Arora

In den einfachsten Begriffen wird verwendet, um von einer Klasse und zu erben implementiert 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.htmlhttps://docs.Oracle.com/ javase/tutorial/Java/IandI/usinginterface.html

7
Irteza Asad

Wir verwenden SubClass extended SuperClass nur, wenn die Unterklasse einige Funktionen (Methoden oder Instanzvariablen) verwenden möchte, die bereits in SuperClass, oder deklariert sind wenn ich die Funktionalität der SuperClass (Methode überschreiben) leicht ändern möchte. Nehmen wir zum Beispiel an, ich habe eine Animal-Klasse (SuperClass) und eine Dog-Klasse (SubClass) und es gibt einige Methoden, die ich in der Animal-Klasse definiert habe, z. doEat ​​(); , doSleep (); ... und viele mehr.

Jetzt kann meine Dog-Klasse einfach die Animal-Klasse erweitern. Wenn mein Hund eine der in der Animal-Klasse deklarierten Methoden verwenden soll, kann ich diese Methoden aufrufen, indem ich einfach ein Dog-Objekt erstelle. Auf diese Weise kann ich garantieren, dass ich einen Hund habe, der essen und schlafen kann und tun kann, was auch immer ich möchte, dass der Hund tut.

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

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

Daher bevorzuge ich es, eine abstrakte Klasse zu 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 das Interface implementiert, weiß nur, dass sie die Vorlagen von - haben. doEat ​​(); und doSleep (); aber sie müssen ihre eigenen definieren doEat ​​(); und doSleep () Methoden nach ihren Bedürfnissen.

Sie erweitern nur, wenn Sie einen Teil der SuperClass wiederverwenden möchten (Sie können die Methoden Ihrer SuperClass jedoch jederzeit entsprechend Ihren Anforderungen überschreiben), und Sie implementieren, wenn Sie die Vorlagen benötigen und Sie sie selbst definieren möchten (entsprechend Ihrem Bedarf).

Ich werde Ihnen einen Teil des Codes mitteilen: Sie versuchen es mit verschiedenen Eingaben 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

}


}

Defined Interfaces:

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}
7
Shubham Arya

Beide Schlüsselwörter werden beim Erstellen Ihrer eigenen neuen Klasse in der Sprache Java verwendet.

Unterschied: implements bedeutet, dass Sie die Elemente einer Java - Schnittstelle in Ihrer Klasse verwenden. extends bedeutet, 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 unter Schnittstelle .

Dies kann dazu beitragen, die Funktionsweise einer Schnittstelle und die damit verbundenen Konventionen zu verdeutlichen.

6
Daniel

Extends wird verwendet, wenn Sie Attribute der übergeordneten Klasse/Schnittstelle in Ihrer untergeordneten Klasse/Schnittstelle wünschen, und implements wird verwendet, wenn Sie Attribute einer Schnittstelle in Ihrer Klasse wünschen.

Beispiel:

  1. Wird mit class erweitert

    klasse Elternteil {

    }

    klasse Kind erweitert Elternteil {

    }

  2. Wird über die Schnittstelle erweitert

    schnittstelle Parent {

    }

    interface Child erweitert Parent {

    }

  3. Anbaugeräte

schnittstelle A {

}

klasse B implementiert A {

}

Kombination von erweitert und implementiert

interface A{

}

class B

{

}

class C implements A,extends B{

}
3
Alekya

erweitert

  • klasse erweitert nur eine Klasse
  • interface erweitert eine oder mehrere Schnittstellen

implementiert

  • klasse implementiert eine oder mehrere Schnittstellen
  • schnittstellen 'können' nichts umsetzen

abstrakte Klassen verhalten sich ebenfalls wie Klassen mit Erweiterungen und Implementierungen

1

Diese beiden Schlüsselwörter sind direkt mit der Vererbung verknüpft. Dies ist ein Kernkonzept von OOP. Wenn wir eine Klasse an eine andere Klasse erben, können wir extend verwenden, aber wenn wir einige Schnittstellen an unsere Klasse erben wollen, können wir extend nicht verwenden, wir sollten implements und wir verwenden Mit dem Schlüsselwort extended können Sie die Schnittstelle von einer anderen Schnittstelle erben.

0