Implements vs extends: quand utiliser? Quelle est la différence?

je remarque que vous avez des questions C++ dans votre profil. Si vous comprenez le concept de héritages multiples de C++ (se référant aux classes qui héritent des caractéristiques de plus d'une autre classe), Java ne le permet pas, mais il a le mot-clé interface , qui est en quelque sorte comme une classe virtuelle pure en C++. Comme mentionné par beaucoup de gens, vous extend une classe (et vous ne pouvez étendre d'un), et vous implement une interface -- mais votre classe peut implémenter autant d'interfaces que vous le souhaitez.

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

extends est pour quand vous héritez d'une classe de base (i.e. étendre sa fonctionnalité).

implements est pour quand vous mettez en œuvre une interface .

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

Un class ne peut "mettre en œuvre" une interface . Une classe ne " étend "que la class . De même, un interface peut étendre un autre interface .

Un class ne peut s'étendre d'un autre class . Un class peut implémenter plusieurs interface .

si vous êtes plutôt intéressé à savoir quand utiliser abstract class es et interface s, référez-vous à ce thread: Interface vs classe abstraite (general OO)

extends : une classe dérivée peut étendre une classe de base. Vous pouvez redéfinir le comportement d'une relation. Classe dérivée " est une " classe de base de type

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

avec la version java 8, l'interface peut avoir par défaut méthodes dans l'interface, qui fournit la mise en œuvre dans l'interface elle-même.

se référer à cette question pour savoir quand pour utiliser chacun d'eux:

Interface vs Classe Abstraite générale (OO)

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

sortie:

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,lifeExpentency de Animal
2. Chat peut grimper() mais le Chien ne le fait pas. Le chien peut penser() mais le chat ne . Ces capacités spécifiques sont ajoutées aux Cat et Dog par la mise en œuvre de 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 indépendantes peuvent avoir des capacités par l'intermédiaire de l'interface, mais les classes apparentées supplantent le comportement par l'extension des classes de base.

Une interface est une description des mesures qu'un objet peut faire... par exemple, lorsque vous appuyer sur un interrupteur, la lumière s'allume, vous ne se soucient pas comment, juste qu'il ne veut. En 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, par exemple, tout ce qui "agit 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 pour 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'imposer certaines propriétés sur un objet (class). 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 devrait avoir une action start_engine (). La manière dont le "moteur est démarré" pour chaque véhicule est laissée à chaque classe particulière, le fait qu'ils doivent avoir une action start_engine est le domaine de interface .

Extends : il est utilisé pour obtenir les attributs d'une classe mère dans la classe de base et peut contenir des méthodes déjà définies qui peuvent être dépassées dans la classe enfant.

met en œuvre : il est utilisé pour mettre en œuvre une interface (classe parent avec fonctions signatures seulement 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 s'étend B:

  A et B sont deux classes ou les deux interfaces

• a instruments B

  A est une classe et B est une interface

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

Instruments est utilisé pour les Interfaces et étend est utilisé pour étendre une classe.

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

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

encore quelques notes:

une interface peut étendre une autre interface.

et quand vous devez choisir entre implémenter une interface ou étendre une classe pour un scénario particulier, allez pour implémenter une interface. Parce qu'une classe peut implémenter plusieurs interfaces mais étendre une seule classe.

Lorsqu'une sous-classe étend une classe, elle permet à la sous-classe d'hériter (réutiliser) et d'Outrepasser le code défini dans le supertype. Quand 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 hic ici, c'est que pendant que nous mettons en œuvre quoi que ce soit, cela signifie simplement que nous utilisons ces méthodes telles qu'elles sont. Il n'y a pas de possibilité de modification de leurs valeurs et de leurs types de retour.

mais quand nous étendons quelque chose alors il devient une extension de votre classe. Vous pouvez le modifier, utiliser, réutiliser l'utiliser et il n'a pas nécessairement besoin de retourner les mêmes valeurs que dans la superclasse.

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

différence: implements signifie que vous utilisez les éléments D'une Interface Java dans votre classe. extends signifie que vous créez une sous-classe de la classe de base que vous étendez. Vous ne pouvez étendre qu'une classe dans votre classe enfant, mais vous pouvez implémenter autant d'interfaces que vous le souhaitez.

se référer à la page de documentation d'oracle sur interface pour plus de détails.

cela peut aider à clarifier ce qu'est une interface, et les conventions Autour de leur utilisation.

Dans les termes les plus simples s'étend est utilisée pour hériter d'un classe et met en œuvre est utilisé pour appliquer un interface dans votre classe

s'étend :

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

instruments :

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

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

nous utilisons la sous-classe étend superclasse seulement lorsque la sous-classe veut utiliser une fonctionnalité (méthodes ou variables d'instance) qui est déjà déclarée dans le superclasse , ou si je veux modifier légèrement la fonctionnalité du superclasse (méthode prépondérante). Mais disons, par exemple, que j'ai une classe animale ( superclasse ) et une classe de chien ( sous-classe ) et il y a peu de méthodes que j'ai définies dans la classe animale par exemple. doEat (); , doSleep ();... et beaucoup plus.

maintenant, ma classe de chien 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 de chien. De cette façon, je peux garantir que j'ai un chien qui peut manger et dormir et faire tout ce que je veux que le chien à faire.

maintenant, imaginez, un jour une certaine cat lover vient dans notre espace de travail et elle essaie d'étendre la classe animale(les chats mangent et dorment aussi). Elle fait un Chat objet et commence à invoquer les méthodes.

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

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

pour conclure, Interface n'est rien d'autre qu'une classe abstraite(une classe abstraite pure) qui ne contient aucune implémentation de méthode mais seulement les définitions(les gabarits). Donc celui qui implémente l'interface sait juste qu'ils ont les modèles de doEat (); et doSleep (); mais ils ont à définir leurs propres doEat (); et doSleep (); méthodes en fonction de leur besoin.

Vous étendre uniquement lorsque vous souhaitez réutiliser une partie de la super-classe(mais gardez à l'esprit, vous pouvez toujours remplacer les méthodes de votre super-classe en fonction de votre besoin) et à implémenter les modèles et que vous souhaitez définir sur votre propre(selon votre besoin).

je vais partager avec vous un morceau de code: Vous essayez avec différents ensembles d'entrées et de regarder 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();

}

, Comme illustré dans la figure ci-dessous, une classe étend une autre classe, une interface s'étend une autre interface, mais une classe implémente une interface.

pour plus détails

Extends est utilisé lorsque vous voulez des attributs de classe parent/interface dans votre classe enfant/interface et implements est utilisé lorsque vous voulez des attributs d'une interface dans votre classe.

exemple:

1. S'étend en utilisant la classe

   classe Parent {

   }

   classe enfant s'étend Parent {

   }

2. S'étend en utilisant l'interface

   interface Parent {

   }

   de l'interface de l'Enfant extends Parent{

   }

3. Instruments

de l'interface d'Un{

}

Classe B met en œuvre Une{

}

combinaison d'extensions et d'instruments

interface A{

}

class B

{

}

class C implements A,extends B{

}