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


S'il vous plaît expliquer dans une langue facile à comprendre ou un lien vers un article.


560
2018-05-31 18:25


origine


Réponses:


extends est pour extension une classe.

implements est pour exécution une interface

La différence entre une interface et une classe régulière est que dans une interface, vous ne pouvez pas implémenter l'une 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 chose mais à peu près).

Java ne supporte pas non plus héritage multiple pour les cours. 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
     }
 }

maintenant étendre 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 recherches sur liaison dynamique, polymorphisme et héritage général dans la programmation orientée objet


578
2018-05-31 18:27



Je remarque que vous avez des questions C ++ dans votre profil. Si vous comprenez le concept de héritage multiple à partir 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 des mots-clés 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 prolonger qu'une), et vous implement une 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 qui régissent leur utilisation délimitent les possibilités de l'héritage multiple en Java (vous ne pouvez avoir qu'une super classe, mais vous pouvez implémenter plusieurs interfaces).


73
2018-05-31 18:36



extends est pour quand vous héritez d'un classe de base (c'est-à-dire étendre sa fonctionnalité).

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

Ici c'est un bon endroit pour commencer: Interfaces et héritage.


34
2018-05-31 18:27



UNE class ne peut que "mettre en œuvre" un interface. Une classe "étend" seulement class. De même, un interface peut prolonger un autre interface.

UNE class ne peut que prolonger un autre class. UNE class peut mettre en œuvre plusieurs interfaces.

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


29
2018-05-31 18:29



Généralement met en oeuvre utilisé pour mettre en œuvre un interface et s'étend utilisé pour extension du comportement de la classe de base ou abstrait classe.

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

met en oeuvre: Vous mettez en œuvre un contrat. La classe implémentant l'interface "a un" aptitude.

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

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

Interface vs classe abstraite (général 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() 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 mettant en œuvre 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 fonctionnalités via l'interface, mais les classes associées remplacent le comportement par l'extension des classes de base.


27
2018-01-24 14:59



Une interface est une description des actions qu'un objet peut faire ... par exemple, lorsque vous faites basculer un interrupteur, la lumière s'allume, vous ne vous souciez pas de comment, juste que c'est le cas. 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 LIKE" 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 de faire respecter 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 "moteur est démarré" pour chaque véhicule est laissé à chaque classe particulière, mais le fait qu'ils doivent avoir une action start_engine est le domaine de la interface.


18
2017-08-25 20:45



  • 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 est une classe n'est pas légal en Java.


11
2018-05-25 07:39



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

Met en oeuvre : Ceci est utilisé pour implémenter une interface (classe parent avec des signatures de fonctions seulement mais pas leurs définitions) en le 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 s'étend l'interface parent.


11
2017-12-08 09:23



Implements est utilisé pour Interfaces et extends est utilisé pour étendre une classe.

Pour le rendre plus clair en termes plus faciles, une interface est comme elle sonne - 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 lorsque 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.


9
2018-05-31 18:27