Implements vs includes: Quand utiliser? Quelle est la différence?
S'il vous plaît expliquer dans une langue facile à comprendre ou un lien vers un article.
extends est pour l'extension d'une classe.
implements est pour implémenter une interface
La différence entre une interface et une classe normale réside dans le fait 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 chose mais à peu près).
De plus, Java ne prend pas en charge 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
}
}
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 recherches sur liaison dynamique, polymorphisme et en général, héritage dans la programmation orientée objet
Je remarque que vous avez des questions C++ dans votre profil. Si vous comprenez le concept héritage multiple de C++ (en référence aux classes qui héritent des caractéristiques de plusieurs classes), Java ne le permet pas, mais son mot-clé est interface, qui est un peu comme une classe virtuelle pure en C++. Comme mentionné par de nombreuses personnes, vous extend une classe (et vous ne pouvez en étendre 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 régissant leur utilisation définissent les possibilités d'héritage multiple dans Java (vous ne pouvez avoir qu'une seule super classe, mais vous pouvez implémenter plusieurs interfaces).
extends est utilisé pour hériter d'une classe de base (c'est-à-dire étendre ses fonctionnalités).
implements est pour lorsque vous implémentez une interface .
Voici un bon point de départ: Interfaces et héritage .
Généralement implémente utilisé pour implémenter une interface et s'étend utilisé pour extension du comportement de la classe de base ou classe abstraite .
extend : 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
implémente : vous mettez en œuvre 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, ce qui permet 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:
- Chien et Chat sont des animaux et ils se sont étendus
remember() etprotectOwner() en partageantname,lifeExpentencydeAnimal - Le chat peut grimper () mais pas le chien. Le chien peut penser () mais pas le chat . Ces capacités spécifiques sont ajoutées à
CatetDogen implémentant cette capacité. - 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 apparentées peuvent avoir des fonctionnalités via l'interface, mais les classes associées annulent le comportement via l'extension des classes de base.
Un class ne peut "implémenter" qu'un interface. Une classe seulement "étend" une class. De même, un interface peut étendre un autre interface.
Un class ne peut étendre qu'un autre class. Un class peut implémenter plusieurs interfaces.
Si vous préférez savoir quand utiliser abstract classes et interfaces, consultez le fil de discussion suivant: Interface vs Abstract Class (OO général)
Une interface est une description des actions que peut effectuer un objet ... par exemple, lorsque vous actionnez un interrupteur, la lumière s’allume, vous ne vous en souciez pas de la façon dont cela se produit. Dans la programmation orientée objet, une interface est une description de toutes les fonctions qu'un objet doit posséder pour être un "X". Encore une fois, à titre d'exemple, tout ce qui "ACTS LIKE" une lumière doit 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, supposons que nous ayons une classe de voiture, 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é" de chaque véhicule est laissée à chaque classe particulière, mais le fait qu’elles doivent avoir une action start_engine est le domaine de la interface .
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.
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 détails
É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 pouvant être remplacées dans la classe des enfants.
Implémente : Ceci est utilisé pour implémenter une interface (classe parente avec des signatures de fonctions uniquement mais pas leurs définitions) en la définissant dans la classe enfant.
Il existe une condition spéciale: "Et si je souhaite qu'une nouvelle interface soit le fils d'une interface existante?". Dans la condition ci-dessus, l'interface enfant extend l'interface parent.
Implements est utilisé pour les interfaces et expand pour étendre une classe.
Pour rendre les choses plus claires en termes plus simples, une interface est comme son: une interface, un modèle que vous devez appliquer, suivre, ainsi que 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 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 ne peut étendre qu'une classe.
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, même si nous mettons en œuvre quoi que ce soit, cela signifie simplement que nous utilisons ces méthodes telles quelles. Il n'y a aucune possibilité de changement dans leurs valeurs et leurs 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.
Dans les termes les plus simples expand est utilisé pour hériter d'une classe et implémente est utilisé pour appliquer une 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 du mal à lire, lisez ceci: https://docs.Oracle.com/javase/tutorial/Java/IandI/subclasses.htmlhttps://docs.Oracle.com/ javase/tutorial/Java/IandI/usinginterface.html
Nous utilisons SubClass étend SuperClass uniquement lorsque la sous-classe souhaite utiliser certaines fonctionnalités (méthodes ou variables d’instance) déjà déclarée dans la SuperClass , ou si je souhaite modifier légèrement la fonctionnalité de la SuperClass (méthode écrasante). 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. Donc, de cette façon, je peux garantir que j'ai un chien qui peut manger, dormir et faire tout ce que je veux que le chien fasse.
Maintenant, imaginez, un jour, un amoureux des chats arrive dans notre espace de travail et tente d’étendre la classe des animaux (les chats mangent et dorment aussi). Elle crée un objet Cat et commence à appeler les méthodes.
Mais, disons, quelqu'un essaie de faire un objet de la classe Animal. Vous pouvez dire comment un chat dort, vous pouvez dire comment un chien mange, vous pouvez dire 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 que nous ne voulons pas de manière générale de manger.
Au lieu de cela, je préférerais créer une classe abstraite que personne ne peut instancier mais qui puisse ê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 modèles). Ainsi, ceux qui implémentent l’interface savent simplement qu’ils ont les modèles de doEat (); et doSleep (); mais ils doivent définir leur propre doEat (); et doSleep (); méthodes en fonction de leurs besoins .
Vous étendez uniquement lorsque vous souhaitez réutiliser une partie de la SuperClass (mais gardez à l'esprit que vous pouvez toujours remplacer les méthodes de votre SuperClass en fonction de vos besoins) et que vous implémentez lorsque 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: essayez-le 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();
}
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.
Reportez-vous à la page de documentation Oracle sur interface pour plus de détails.
Cela peut aider à clarifier ce qu'est une interface et les conventions concernant leur utilisation.
Extends est utilisé lorsque vous voulez des attributs de classe/interface parente dans votre classe/interface enfant et implements est utilisé lorsque vous voulez des attributs d'une interface dans votre classe.
Exemple:
Étend en utilisant class
classe Parent {
}
classe Child étend Parent {
}
étend en utilisant l'interface
interface parent {
}
interface Child extension Parent {
}
Implements
interface A {
}
la classe B implémente A {
}
Combinaison de rallonge et implémente
interface A{
}
class B
{
}
class C implements A,extends B{
}
étend
- la classe ne s'étend que sur une classe
- interface étend une ou plusieurs interfaces
implémente
- la classe implémente une ou plusieurs interfaces
- les interfaces "ne peuvent" rien implémenter
les classes abstraites agissent aussi comme une classe, avec une extension et une implémentation
Ces deux mots clés sont directement liés à l'héritage, il s'agit d'un concept fondamental de la programmation orientée objet. Lorsque nous héritons d'une classe à une autre classe, nous pouvons utiliser extend mais lorsque nous allons hériter de certaines interfaces de notre classe, nous ne pouvons pas utiliser des spreads, nous devons utiliser implements et nous peut utiliser le mot-clé extend pour hériter d’une autre interface.