Discussion :

[guti11]

Bonjour les amis

je veux savoir la différence en java entre Implements et non-Implements, ou d'une autre manière la différence entre une méthode implémenté et non-implémenté,

Merci.

[ludomacho]

Bonjour,

tu n'implémentes pas une méthode mais une interface.

ton interface définit des méthodes qui y sont juste déclarées.

Quand tu crées une class qui implémente une interface, tu dois dans ta classe surcharger toutes les méthodes définies dans ton interface.

exemple:

soit une interface InterfaceTest qui définit 3 méthodes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public interface InterfaceTest {
 
          String methode1();
          void methode2(int i);
          void methode3();
}

la methode1 retourne un string et ne demande pas de paramètres
la methode2 ne retourne rien mais nécessite un paramètre de type int
la methode3 ne retourne rien et ne nécessite pas de paramètre

Créons maintenant une classe ClassTest qui implémente InterfaceTest

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class ClassTest implements InterfaceTest {
 
          public ClassTest() {
               //constructeur
          }
 
          public String methode1() {
               String s;
               //TODO
               return s
          }
 
          public void methode2(int i) {
               //TODO
          }
 
          public void methode3() {
               //TODO
          }
 
 
}

Comme tu le vois tu es obligé de définir toute les méthodes de l'interface dans ta classe.

[guti11]

Merci d'avoir répondu ,c'est très clair ce que tu as écrit , mais j'ai toujours pas encore saisie la différence entre une fonction implémenté et non-implémenté , j'ai trouvé cela dans une explication de classe abstraite et interface..

Merci de m’éclaircir

[ludomacho]

Bonjour,

ok je pense que ce que tu veux savoir c'est pourquoi en utilisant une classe abstraite on peut ne pas écrire toute les méthodes d'une interface mais seulement celle qui t'intéresse.

Si tu reprends l'interface précédente, à la place d'utiliser directement l'interface je vais créer une classe abstraite qui va implémenter l'interface et qui va donc devoir définir toutes les méthodes de l'interface

Ensuite ma classe ClassTest n'implemente plus l'interface mais étend la classe abstraite. Ainsi je surcharge uniquement la méthode désirée.


Exemple : supposons que je n'ai besoin que de la methode1 de l'interface

reprenons l'interface précéddente :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public interface InterfaceTest {
 
          String methode1();
          void methode2(int i);
          void methode3();
}

je crée une AbstractClassTest qui implemente InterfaceTest

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Abstract class AbstractClassTest implements InterfaceTest {
           abstract String methode1();
           abstract void methode2(int i);
           abstract void methode3();
}

Et maintenant, comme je n'implémente plus une interface mais j'étends une classe je peux n'utiliser que la méthode qui m'intéresse :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class ClassTest implements InterfaceTest {
 
          public ClassTest() {
               //constructeur
          }
 
          public String methode1() {
               String s;
               //TODO
               return s
          }
}

[guti11]

c'est intéressant merci bcq.
svp une dernière question je veux une définition du mot (non-implémenté & implémenté)
merci infiniment.

[joel.drigo]

salut,

ce n'est pas exact, à moins qu'une nouvelle version de java ne soit sortie sans que je sois au courant :

une interface définit des méthodes sans leur code (uniquement la signature sans le corps de la méthode).

donc ok pour ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 public interface InterfaceTest {
 
          String methode1();
          void methode2(int i);
          void methode3();
}

une classe qui implémente cette interface doit impérativement fournir le code de chacune des méthodes de l'interface implémentée

donc ok pour ça aussi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class ClassTest implements InterfaceTest {
 
          public ClassTest() {
               //constructeur
          }
 
          public String methode1() {
               String s;
               //TODO
               return s
          }
 
          public void methode2(int i) {
               //TODO
          }
 
          public void methode3() {
               //TODO
          }
 
 
}

une classe abstraite définit des méthodes ou/et des signatures de méthodes sans le corps de la méthode, donc comme une interface. c'est en quelque sort un mixte entre interface et classe abstraite

par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public abstract class AbstractTest {
 
    public void methode5() {
          // du code
    }
 
    public abstract int methode6(); // cette méthode n'a pas de corps
 
}

comme quand on implémente une interface, une classe qui étend une classe abstraite et qui n'est pas abstraite doit définir l'ensemble des méthodes de la classe abstraite.

une classe abstraite n'est pas obligé de définir le corps d'une méthode héritée d'une classe abstraite ou d'une interface,

donc on peut faire ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public abstract class AbstractTest2 extends AbstractTest implements InterfaceTest {
 
       public String methode1() {
               String s;
               //TODO
               return s
          }
 
}

ici j'ai implémenté la méthode 1 héritée de l'interface InterfaceTest, donc j'ai écrit le corps de cette méthode, mais je n'ai pas implémenté methode2(int), methode3(), methode5() et methode6()

mais je dois absolument implémenter toutes ces méthodes dans une classe concrete qui étend ma classe AbstractTest2.

la classe suivante, provenant du post précédent ne compile pas : il manque 2 méthodes methode2(int) et methode3()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public class ClassTest implements InterfaceTest {
 
          public ClassTest() {
               //constructeur
          }
 
          public String methode1() {
               String s;
               //TODO
               return s
          }
}

mais peut être voulais tu, @ludomacho, faire ça dans ton exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class AbstractClassTest implements InterfaceTest {
           abstract String methode1();
           public void methode2(int i) {
              //TODO
          }
 
          public void methode3() {
               //TODO
          }
}
public class ClassTest extends AbstractClassTest {
 
          public ClassTest() {
               //constructeur
          }
 
          public String methode1() {
               String s;
               //TODO
               return s
          }
}

[joel.drigo]

Pour la définition de implémenté :

il s'agit déjà d'un anglicisme : ce mot n'existe pas en français, ni même implémenter.

to implement en anglais signifie mettre en pratique ou mettre en oeuvre

en quelque sorte, quand on écrit public class Toto implements Jambon

on veut dire je déclare une classe qui s'appele Toto et qui met en oeuvre l'interface Jambon

par extension, on parle d'implémenter une méthode quand on parle d'écrire le corps de cette méthode, c'est à dire le code qu'elle va exécuter si on l'appelle

non-implement, je n'ai jamais vu, mais je suppose que ça pourrait décrire justement une classe abstraite qui n'implémente pas une méthode héritée d'une interface qu'elle implémente (on a vu qu'une classe abstraite n'est pas obligé de définir l'ensemble de méthodes dont elle hérite).

[ludomacho]

bonjour,
effectivement,

c'est une erreur de copié collé désolé d'ailleur mon expliquation ne correspond pas a ça encore désolé

[guti11]

Merci les amis votre aide me serais très bénéfique, à bientot