Implémente vs étend: Quand l'utiliser? Quelle est la différence?

Veuillez expliquer dans une langue facile à comprendre ou un lien vers un article.

extendsest pour étendre une classe.

implementsest pour implémenter une interface

La différence entre une interface et une classe régulière est que dans une interface, vous ne pouvez implémenter aucune des méthodes déclarées. Seule la classe qui "implémente" l'interface peut implémenter les méthodes. L'équivalent C ++ d'une interface serait une classe abstraite (pas exactement la même mais à peu près).

De plus, java ne prend pas en charge l' héritage multiple pour les classes. Ceci est résolu en utilisant plusieurs interfaces.

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

étendre maintenant une classe

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

dans ce cas

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

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

Je vous suggère de faire plus de recherche sur la liaison dynamique, le polymorphisme et en général l'héritage dans la programmation orientée objet

Je remarque que vous avez des questions C ++ dans votre profil. Si vous comprenez le concept d' héritage multiple de C ++ (faisant référence aux classes qui héritent des caractéristiques de plusieurs autres classes), Java ne permet pas cela, mais il a un mot-clé interface, qui est un peu comme une classe virtuelle pure en C ++. Comme mentionné par beaucoup de gens, vous extendune classe (et vous ne pouvez étendre qu'une seule), et vous implementune interface - mais votre classe peut implémenter autant d'interfaces que vous le souhaitez.

C'est-à-dire que ces mots clés et les règles régissant leur utilisation délimitent les possibilités d'héritage multiple en Java (vous ne pouvez avoir qu'une seule super classe, mais vous pouvez implémenter plusieurs interfaces).

En général , les outils utilisés pour la mise en œuvre d' une interface de et Prolonge utilisés pour l' extension du comportement de la classe de base ou abstraite classe.

étend : une classe dérivée peut étendre une classe de base. Vous pouvez redéfinir le comportement d'une relation établie. La classe dérivée " est un " type de classe de base

met en œuvre : Vous exécutez un contrat. La classe implémentant l'interface " a " une capacité.

Avec la version java 8, l'interface peut avoir des méthodes par défaut dans l'interface, qui fournit une implémentation dans l'interface elle-même.

Reportez-vous à cette question pour savoir quand utiliser chacun d'eux:

Interface vs classe abstraite (OO général)

Exemple pour comprendre les choses.

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

production:

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

Points importants à comprendre:

1. Chien et chat sont des animaux et ils ont étendu remember() et protectOwner() par le partage name,lifeExpentencydeAnimal
2. Le chat peut grimper () mais pas le chien. Le chien peut penser () mais pas le chat . Ces capacités spécifiques sont ajoutées Catet Dogmises en œuvre par cette capacité.
3. L'homme n'est pas un animal mais il peut Think,Learn,Apply,Climb

En parcourant ces exemples, vous pouvez comprendre que

Les classes non liées peuvent avoir des capacités via l'interface, mais les classes liées remplacent le comportement par l'extension des classes de base.

extendsest pour quand vous héritez d'une classe de base (c'est-à-dire l'extension de ses fonctionnalités).

implementsest pour quand vous implémentez une interface .

Voici un bon point de départ: Interfaces et héritage .

Un classne peut que «mettre en œuvre» un interface. Une classe "étend" seulement a class. De même, un interfacepeut prolonger un autre interface.

A classne peut se prolonger qu’un autre class. A classpeut mettre en œuvre plusieurs interfaceart.

Si au contraire, vous êtes plus intéressé à savoir quand utiliser abstract classes et interfaces, reportez-vous à ce fil: Interface vs classe abstraite (OO général)

Une interface est une description des actions qu'un objet peut effectuer ... par exemple, lorsque vous actionnez un interrupteur d'éclairage, la lumière s'allume, vous ne vous souciez pas de la façon dont elle fonctionne. Dans la programmation orientée objet, une interface est une description de toutes les fonctions qu'un objet doit avoir pour être un "X". Encore une fois, à titre d'exemple, tout ce qui "ACTE COMME" une lumière, devrait avoir une méthode turn_on () et une méthode turn_off (). Le but des interfaces est de permettre à l'ordinateur d'appliquer ces propriétés et de savoir qu'un objet de TYPE T (quelle que soit l'interface) doit avoir des fonctions appelées X, Y, Z, etc.

Une interface est une structure / syntaxe de programmation qui permet à l'ordinateur d'appliquer certaines propriétés à un objet (classe). Par exemple, disons que nous avons une classe de voiture et une classe de scooter et une classe de camion. Chacune de ces trois classes doit avoir une action start_engine (). La façon dont le "moteur est démarré" pour chaque véhicule est laissée à chaque classe particulière, mais le fait qu'ils doivent avoir une action start_engine est le domaine de l' interface .

Comme le montre la figure ci-dessous, une classe étend une autre classe, une interface étend une autre interface mais une classe implémente une interface.

Pour plus de détails

Étend : Ceci est utilisé pour obtenir les attributs d'une classe parent dans la classe de base et peut contenir des méthodes déjà définies qui peuvent être remplacées dans la classe enfant.

Implements : Ceci est utilisé pour implémenter une interface (classe parent avec des signatures de fonctions uniquement mais pas leurs définitions) en la définissant dans la classe enfant.

Il y a une condition spéciale: "Et si je veux qu'une nouvelle interface soit l'enfant d'une interface existante?". Dans la condition ci-dessus, l'interface enfant étend l'interface parent.

• A étend B:

  A et B sont les deux classes ou les deux interfaces

• A implémente B

  A est une classe et B est une interface

• Le cas restant où A est une interface et B une classe n'est pas légal en Java.

Implements est utilisé pour les interfaces et extend est utilisé pour étendre une classe.

Pour le rendre plus clair en termes plus faciles, une interface est comme son son - une interface - un modèle, que vous devez appliquer, suivre, ainsi que vos idées.

Étendre est utilisé pour les classes, ici, vous étendez quelque chose qui existe déjà en y ajoutant plus de fonctionnalités.

Quelques notes supplémentaires:

une interface peut étendre une autre interface.

Et lorsque vous devez choisir entre implémenter une interface ou étendre une classe pour un scénario particulier, optez pour l'implémentation d'une interface. Parce qu'une classe peut implémenter plusieurs interfaces mais étendre une seule classe.

Les deux mots clés sont utilisés lors de la création de votre propre nouvelle classe dans le langage Java.

Différence: implementssignifie que vous utilisez les éléments d'une interface Java dans votre classe. extendssignifie que vous créez une sous-classe de la classe de base que vous étendez. Vous ne pouvez étendre qu'une seule classe dans votre classe enfant, mais vous pouvez implémenter autant d'interfaces que vous le souhaitez.

Reportez-vous à la page de documentation d'Oracle sur l' interface pour plus de détails.

Cela peut aider à clarifier ce qu'est une interface et les conventions relatives à leur utilisation.

Lorsqu'une sous-classe étend une classe, elle permet à la sous-classe d'hériter (réutiliser) et de remplacer le code défini dans le supertype. Lorsqu'une classe implémente une interface, elle permet à un objet créé à partir de la classe d'être utilisé dans n'importe quel contexte qui attend une valeur de l'interface.

Le vrai problème ici, c'est que si nous mettons en œuvre quelque chose, cela signifie simplement que nous utilisons ces méthodes telles quelles. Il n'y a aucune possibilité de changement dans leurs valeurs et types de retour.

Mais lorsque nous étendons quelque chose, cela devient une extension de votre classe. Vous pouvez le changer, l'utiliser, le réutiliser et il n'a pas nécessairement besoin de renvoyer les mêmes valeurs que dans la superclasse.

Nous utilisons SubClass étend SuperClass uniquement lorsque la sous-classe souhaite utiliser certaines fonctionnalités (méthodes ou variables d'instance) qui sont déjà déclarées dans la SuperClass , ou si je souhaite modifier légèrement les fonctionnalités de la SuperClass (méthode prioritaire). Mais disons, par exemple, j'ai une classe Animal ( SuperClass ) et une classe Dog ( SubClass ) et il y a peu de méthodes que j'ai définies dans la classe Animal par exemple. doEat (); , doSleep (); ... et beaucoup plus.

Maintenant, ma classe Dog peut simplement étendre la classe Animal, si je veux que mon chien utilise l'une des méthodes déclarées dans la classe Animal, je peux invoquer ces méthodes en créant simplement un objet Dog. Ainsi, je peux garantir que j'ai un chien qui peut manger et dormir et faire tout ce que je veux que le chien fasse.

Maintenant, imaginez, un jour un amoureux des chats entre dans notre espace de travail et elle essaie d'étendre la classe animale (les chats mangent et dorment aussi). Elle crée un objet Cat et commence à invoquer les méthodes.

Mais, disons, quelqu'un essaie de fabriquer un objet de la classe Animal. Vous pouvez dire comment un chat dort, vous pouvez savoir comment un chien mange, vous pouvez savoir comment un éléphant boit. Mais cela n'a aucun sens de faire un objet de la classe Animal. Parce que c'est un modèle et nous ne voulons pas de façon générale de manger.

Donc, à la place, je préfère créer une classe abstraite que personne ne peut instancier mais qui peut être utilisée comme modèle pour d'autres classes.

Donc pour conclure, Interface n'est rien d'autre qu'une classe abstraite (une pure classe abstraite) qui ne contient aucune implémentation de méthode mais seulement les définitions (les modèles). Donc, quiconque implémente l'interface sait juste qu'il a les modèles de doEat (); et doSleep (); mais ils doivent définir leur propre doEat (); et doSleep (); selon leurs besoins.

Vous étendez uniquement lorsque vous souhaitez réutiliser une partie de la SuperClass (mais gardez à l'esprit, vous pouvez toujours remplacer les méthodes de votre SuperClass en fonction de vos besoins) et vous implémentez quand vous voulez les modèles et que vous souhaitez les définir vous-même (selon vos besoins).

Je vais partager avec vous un morceau de code: vous l'essayez avec différents ensembles d'entrées et regardez les résultats.

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

}


}

Interfaces définies :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Dans les termes les plus simples, extend est utilisé pour hériter d'une classe et implements est utilisé pour appliquer une interface dans votre classe

étend :

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

met en œuvre :

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

si vous avez encore de la confusion, lisez ceci: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Les classes et les interfaces sont deux contrats . Ils fournissent des méthodes et des propriétés sur lesquelles s'appuient d'autres parties d'une application.

Vous définissez une interface lorsque vous n'êtes pas intéressé par les détails de mise en œuvre de ce contrat. La seule chose à prendre en compte est que le contrat (l'interface) existe.

Dans ce cas, vous laissez le soin à la classe qui implémente l'interface de se soucier des détails de l' exécution du contrat. Seules les classes peuvent implémenter des interfaces.

extend est utilisé lorsque vous souhaitez remplacer les détails d'un contrat existant. De cette façon, vous remplacez une façon d'exécuter un contrat d'une manière différente. Les classes peuvent étendre d'autres classes et les interfaces peuvent étendre d'autres interfaces.

Extendsest utilisé lorsque vous voulez des attributs de la classe / interface parent dans votre classe / interface enfant et implementsest utilisé lorsque vous voulez des attributs d'une interface dans votre classe.

Exemple:

1. Étend en utilisant la classe

   parent de classe {

   }

   classe Child étend Parent {

   }

2. S'étend en utilisant l'interface

   interface Parent {

   }

   interface enfant étend parent {

   }

3. Met en oeuvre

interface A {

}

la classe B implémente A {

}

Combinaison de rallonges et d'outils

interface A{

}

class B

{

}

class C implements A,extends B{

}

étend

• classe étend une seule classe
• l'interface étend une ou plusieurs interfaces

met en oeuvre

• classe implémente une ou plusieurs interfaces
• les interfaces «ne peuvent pas» implémenter quoi que ce soit

les classes abstraites agissent également comme des classes, avec des extensions et des implémentations

Ces deux mots clés sont directement liés à l'héritage, c'est un concept central de la POO. Lorsque nous héritons d'une classe vers une autre classe, nous pouvons utiliser des extensions, mais lorsque nous allons hériter de certaines interfaces de notre classe, nous ne pouvons pas utiliser des extensions, nous devons utiliser des implémentations et nous pouvons utiliser le mot clé extend pour hériter l'interface d'une autre interface.