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

Je remarque que vous avez des questions C++ dans votre profil. Si vous comprenez le concept de multiple-inheritance 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 un peu comme une classe virtuelle pure en C++. Comme mentionné par beaucoup de gens, vous extend une classe (et vous ne pouvez en étendre qu'une), et vous {[2] } une interface but 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).

Généralement implémente utilisé pour la mise en œuvre d'un interface et étend utilisé pour extension de la classe de base de comportement ou abstract classe.

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 un" type de classe de base

Implements : Vous implémentez un contrat. La classe implémentant l'interface "a un" capacité.

Avec la version java 8, interface peut avoir des méthodespar défaut dans l'interface, ce 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;
    }
}

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() en partageant name,lifeExpentency de Animal
2. Le chat peut grimper() mais pas le chien. Le chien peut penser() mais le chat ne le fait pas. Ces capacités spécifiques sont ajoutées à Cat et Dog en implémentant 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 une interface mais liées les classes remplacent le comportement par l'extension des classes de base.

extends est pour lorsque vous héritez d'une classe de base (c'est-à-dire étendant ses fonctionnalités).

implements est pour quand vous implémentez une interface .

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

Un class ne peut "implémenter" qu'un interface. Une classe "étend" seulement un class. De même, un interface peut étendre un autre interface.

Un class ne peut s'étendre d'une autre class. Un class peut implémenter plusieurs interfaces.

, Si vous êtes plus intéressés à savoir quand utiliser l' abstract classes et interfaces, reportez-vous à ce fil: Interface vs Classe Abstraite (général OO)

Une interface est une description des mesures qu'un objet peut faire... par exemple, lorsque vous allumez un interrupteur, la lumière s'allume, vous ne vous souciez pas de la façon dont, juste que c'est le cas. 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, à titre d'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 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 sur 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 devrait avoir une action start_engine (). Comment le "démarrage du moteur" pour chaque véhicule est laissé à chaque classe, mais le fait qu'ils doivent avoir une l'action start_engine est le domaine de l'interface .

Comme le montre 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 de détails

S'é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: "Que faire 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.

Les deux mots-clés sont utilisés lors de la création de votre propre nouvelle 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 seule classe dans votre classe enfant, mais vous pouvez implémenter autant d'interfaces que vous le souhaitez.

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

Cela peut aider à clarifiez ce qu'est une interface et les conventions autour de leur utilisation.

• A étend B:

  A et B sont les deux classes ou les deux interfaces

• Un implémente B

  Est une classe et B est une interface

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

Implements est utilisé pour les interfaces et extends 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.

Extend 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 quand vous devez choisir entre l'implémentation d'une interface ou l'extension d'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.

Dans les termes les plus simples étend est utilisé pour hériter d'une classe et implémente 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
}

Implémente:

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

Nous utilisons sous-classe étend Superclasse seulement lorsque la sous-classe veut utiliser certaines fonctionnalités (méthodes ou variables d'instance) qui est déjà déclaré dans le Superclasse, ou si je veux modifier légèrement la fonctionnalité de la Superclasse (redéfinition de Méthode). Mais disons que 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. Donc, 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 fasse.

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

Mais, disons, quelqu'un essaie de faire un objet de la classe des animaux. 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 que nous ne voulons aucune façon générale de manger.

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

Donc, 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 modèles). Donc celui qui implémente l'interface sait juste qu'ils ont les modèles de doEat(); et doSleep(); mais ils doivent définir leurs propres doEat(); et doSleep(); méthodes en fonction de leur besoin.

Vous n'étendez que lorsque vous souhaitez réutiliser une partie du 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 si vous voulez définir vous-même(en fonction de 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
    
}


}

Des Interfaces Définies :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

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 est que pendant que nous implémentons 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 quand nous sommes étendre quoi que ce soit devient alors 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 Classes et Interfaces sont les deux contrats. Ils fournissent des méthodes et des propriétés sur lesquelles d'autres parties d'une application s'appuient.

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 à se soucier est que le contrat (l'interface) existe.

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

S'Étend est utilisé lorsque vous voulez remplacer les détails d'un contrat existant. De cette façon, vous remplacez une façon de remplir un contrat par une autre. Les classes peuvent étendre d'autres classes et les interfaces peuvent étendre d'autres interfaces.

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

Exemple:

1. S'étend en utilisant la classe

   Parent de classe {

   }

   L'enfant de la classe étend le parent {

   }

2. S'étend en utilisant l'interface

   Parent d'interface {

   }

   L'interface Enfant s'étend Parent{

   }

3. met en œuvre

Interface D'Un{

}

La classe B implémente un {

}

Combinaison d'extensions et d'implémentations

interface A{

}

class B

{

}

class C implements A,extends B{

}

S'Étend

La classe
• n'étend qu'une seule classe
• interface étend une ou plusieurs interfaces

Implémente

La classe
• implémente une ou plusieurs interfaces
• interfaces 'ne peut pas' implémente quoi que ce soit

Les classes abstraites agissent également comme une classe, avec extends et implements

Ces deux mots clés sont directement attachés avec l'héritage c'est un concept de base de la POO. Lorsque nous héritons d'une classe à une autre classe, on peut utiliser étend, mais quand on va hériter de plusieurs interfaces de notre classe, nous ne pouvons pas utiliser s'étend, nous devrions l'utiliser implémente et on peut utiliser étend clé pour hériter de l'interface d'une autre interface.

En Java, une classe(sous-classe) étend une autre classe(super classe) et peut remplacer les méthodes définies dans la super classe.

While implements est utilisé lorsqu'une classe cherche à déclarer les méthodes définies dans l'Interface que ladite classe étend.