L’utilité des interfaces dans l’orienté objet

Version imprimable

Bonjour :roll:

Pour illustré plus ou je veux en venir j’ai fait un petite exemple :

D’après moi dans le maïeur des cas elle devra donnés la possibilité
De ne pas récrire le même code de la même méthode dans toutes les classes

Donc si j’utilise une interface dans la classe Etudiant_salarier en devra pouvoir redéfinir tout c’est méthode de plus de réutilise le Code de la méthode dans la classe Etudiant et Salarier et de Personne dans 1 seul méthode de la classe Etudiant_salarier et tous sa sans le réécrire (le code).

Ce qui serais bien c’est que je puise accède de Etudiant_Salarier à la classe Etudiant (de la méthode EnCoure(); )et je pourrai accèdes à la classe Personne grâce a l’héritage !.

En claire je me demandés si le faite d’implémenter une interface dans plusieurs classe Réagit comme un Héritage (peu être multiple).

Voila des liens qui peu vous aidez à comprendre ce que je veux dire par la :

http://www.developpez.net/forums/d68...ceptuels-code/

Ou :

http://www.developpez.net/forums/d68...entation-code/

Mais je ne suis pas arrivé si quelqu’un peu donnée des ides.

voici le code ou je fait met Test:
sur les classe Perssone, Etudiant, Salarier, et Etudiant_Salarier.

Code:

1
2
3
4
5
6
7
8
9
10
 
package com.dz.IHM;
 
public interface IPersonne {
 
	public void Manger();
	public void Courir();
	public void Dormir();
 
}

Code:

1
2
3
4
5
6
7
8
9
10
 
package com.dz.IHM;
 
public interface IEtudiant {
 
	public void Reviser();
	public void EnCoure();
	public void Reflechir(); 
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
 
package com.dz.IHM;
 
 
public interface ISalarie {
 
	public void EnTravaille();
	public void Payement();
	public void RealiseProjet(); 	
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
import com.dz.IHM.IPersonne;
 
 
public abstract class Personne implements IPersonne {
	//abstract POUR Quoi  ?
 
	public Personne(){
		System.out.println("Le Constructeur de Personne");
	}
 
	public void Courir() {
 
		System.out.println("je suis la Méthode Courir de Personne");
 
	}
 
	public void Dormir() {
		System.out.println("je suis la Méthode Dormir");
 
	}
 
	public void Manger() {
		System.out.println("je suis la Méthode Manger");
 
	}
 
	/* Sacha que Concéptuelement un EtudiantSalarie == Personne */
    /* ***********Méthode(Comportement)par défaut des Etudiant********* */
	public void EnCoure() {
		System.out.println("je suis la Méthode EnCoure de Personne");
 
	}
 
	public void Reflechir() {
		System.out.println("je suis la Méthode Reflechir de Personne");
 
	}
 
	public void Reviser() {
		System.out.println("je suis la Méthode Reviser de Personne");
 
	}
	/* **************************************************************** */
 
	/* ***********Méthode(Comportement)par défaut des Salarie********* */
	public void EnTravaille() {
		System.out.println("je suis la Méthode EnTravaille de Personne");
 
	}
 
	public void Payement() {
		System.out.println("je suis la Méthode Payement de Personne");
 
	}
 
	public void RealiseProjet() {
		System.out.println("je suis la Méthode RealiseProjet de Personne");
 
	}
	/* **************************************************************** */
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
import com.dz.IHM.IEtudiant;
 
 
public class Etudiant extends Personne implements IEtudiant {
 
 
     public void Courir() {
 
		System.out.println("je suis la Méthode Courir de Etudiant");
 
	}
 
 
 
	public void EnCoure() {
		super.EnCoure();
		System.out.println("je suis la Méthode EnCoure de la classe Etudiant");
 
	}
 
	public void Reflechir() {
		System.out.println("je suis la Méthode Reflechir");
 
	}
 
	public void Reviser() {
		System.out.println("je suis la Méthode Reviser");
 
	}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
import com.dz.IHM.ISalarie;
 
 
public class Salarie extends Personne implements ISalarie {
 
 
	public void EnCoure() {
	super.EnCoure();
	System.out.println("je suis la Méthode EnCoure de la classe Etudiant");	
		}
 
	public void EnTravaille() {
		System.out.println("je suis la Méthode EnTravaille");
 
	}
 
	public void Payement() {
		System.out.println("je suis la Méthode Payement");
 
	}
 
	public void RealiseProjet() {
		System.out.println("je suis la Méthode RealiseProjet");
 
	}
 
}

La classe « EtudiantSalarie» :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
 
import com.dz.IHM.IEtudiant;
import com.dz.IHM.IPersonne;
import com.dz.IHM.ISalarie;
 
 
public class EtudiantSalarie extends Personne implements IPersonne, IEtudiant, ISalarie {
 
	public EtudiantSalarie(){
		super();
		System.out.println("Le Constructeur de EtudiantSalarie");
	}
 
	public void Courir() {
		super.Courir();
		System.out.println("je suis la Méthode Courir de EtudiantSalarie");
 
	}
 
	public void Dormir() {
		System.out.println("je suis la Méthode Dormir");
 
	}
 
	public void Manger() {
		System.out.println("je suis la Méthode Manger");
 
	}
 
	public void EnCoure() {
		super.EnCoure();
		System.out.println("je suis la Méthode EnCoure de EtudiantSalarie");
 
	}
 
	public void Reflechir() {
		System.out.println("je suis la Méthode Reflechir");
 
	}
 
	public void Reviser() {
		System.out.println("je suis la Méthode Reviser");
 
	}
 
	public void EnTravaille() {
		System.out.println("je suis la Méthode EnTravaille");
 
	}
 
	public void Payement() {
		System.out.println("je suis la Méthode Payement");
 
	}
 
	public void RealiseProjet() {
		System.out.println("je suis la Méthode RealiseProjet");
 
	}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
import com.dz.IHM.IEtudiant;
 
 
 
public class Test {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		System.out.println("je suis la Méthode Main");
		IEtudiant p = new EtudiantSalarie();
		//p.Courir();
		  p.EnCoure();
      /* Grace aux l'interface je peu utiliser touts
		  les métode des classe qui l'implémante cette interface */
	}
 
}

pour résumé:

Si c'est possible d'aller direct à et en même Temps à
Etudiants et salarie puis par héritage a personne
Pour ne pas ce retapés le code des méthode de Etudiant et Salarie dans la Classe EtudiantSalarie

Si c’est possible des données une idées ou solution en Java.

Merci d’avance. ;)

Si ton problème est que EtudiantSalarié doit récupérer des méthodes de IEtudiant et de ISalarié et que, en même temps, tu veux récupérer le code de la classe Etudiant et la Classe de Salarié, tu risque de devoir passer par un patron du style delegate. Généralement, dans ce genre de cas, on par de Etudiant ou de Salarié et on ajoute les méthodes qui manquent. Si tu veux vraiement récupérer les code de tes deux classes et que tu sais ce que tu fait, utilise le patron delegate:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public class EtudiantSalarie extends Etudiant implements ISalarie{ private ISalarie salarie; public EtudiantSalarie(.....){ super(.....); salarie = new Salarie(....); } public xxx uneMethodeDeSalarie(....){ return salarie.uneMethodeDeSalarie(....); } }
Note: en java on utilise pas la notaiton Ixxxx pour maquer des interfaces, tu ne trouvera presque jamais ces conventions utilisée, elle viennent plutot du monde c++ / .net. Les interfaces java sont manipulées comme les autres (elles n'ont juste pas de constructeur)

Note: en pratique il est très rare d'avoir vraiment besoin de ce genre d'héritage. Dans ton exemple, les méthodes associées à l'interface Salarie auront clairement des comportement différent sir le salarié est un étudiant ou pas. Dans le cas de l'étudiant, il y aura vraisemblablement des règle sur les limites de salaires, des règles sur la taxation etc qui seront complètement différente -> peu d'intérêt de récupérer le code. Et c'est très souvent le cas quand quelqu'un demande de l'héritage multiple, il y a tellement de contraites derrière que réécrire les méthodes concernées est plus propre, plus rapide et plus souple :)

Je fais du java depuis des années, je n'ai jamasui eu beosin d'héritage multiple au delà de ce que propose java avec ses interfaces :) Quand on veux récupérer du code d'un classe xtérieur implémentant déjà l'interface, soit on hérite (si c'est possible) soit on fait de la délégation (qui marche très bien)

05/03/2009, 10h21
OButterlin

Bon, je pense que le plus simple pour comprendre (l'énorme) utilité des interfaces java est de les présenter comme une définition de "contrat".
Il est certain qu'une interface implémentée par une (et une seule) classe n'a pas de gros intérêt (immédiat), par contre, imagine ce cas :

- des Voitures
- des Avions
- des Bateaux

Tous ces "objets" se déplacent, la façon de le faire leur est par contre très spécifique. On va donc définir une interface "Deplacement" qui aura (pour simplifier) 2 méthodes :
- avancer(sens)
- tourner(sens)

Nos objets implémenteront cette interface, ce qui les obligera à implémenter les 2 méthodes, en fonction de leurs caractéristiques.

Maintenant, on asservit ces objets à un programme de gestion des déplacements. Il aura donc une liste d'objets (Voitures, Avions, Bateaux) dans sa liste d'éléments à déplacer et il pourra les voir par leur "contrat" "Deplacement" et invoquer leurs méthodes (avancer, tourner) sans ce soucier du type physique de l'objet.
D'un point de vu java 5, on pourra écrire List<Deplacement>, ce qui limitera déjà la possibilité d'ajouter des objets n'implémentant pas l'interface et donc, que le programme serait incapable de gérer...

Finalement, avec l'interface, on ne voit l'objet que par un ensemble de "possibilités", mais pas toutes...

C'est plus clair pour toi ?

A+

Merci pour vos réponses. :ccool:

Voila je pense avoir vu et vaincu

Donc j’ai testé ce que tu m'as dit « tchize_ » et ça marche très bien :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public class EtudiantSalarie extends Personne implements IPersonne, IEtudiant, ISalarie { private ISalarie salarie; public IEtudiant etudiant; public void EnCoure() { super.EnCoure(); etudiant = new Etudiant(); etudiant.EnCoure(); System.out.println("je suis la Méthode EnCoure de EtudiantSalarie"); } .. }
Et donc si j’ai bien compris l’utilité de cet interface est de :

1- Récupérer du code d’une classe qui implémente cet interface en Polymorphe le code de la méthode qu'on veut récupèrer.

2- Un avantage d’encapsulation (regroupement) des méthodes qui ont besoin d’être réutilisées dans différentes classes. (ou et Mise à jour simplifiée en cas de modification du code puisque Conceptuellement chaque bout de code sera à sa place logique, ce qui fait qu'en cas d’erreur dans ces méthodes on va rapidement localiser cette erreur)

3- D'un niveau conception c’est plus réaliste.
4- Simplification du code (plus clair).
5- et faire de la simulation de héritage multiple.

Donc, si il y a d’autres avantages ou une mauvaise compréhension de ma part je vous remercie d’avance de me corriger s'il y a lieu, ou d’autres idées ou avantages que je n’ai pas vu. ;)
Merci

09/03/2009, 09h55
OButterlin

Je dirais que l'intérêt de l'interface réside dans le fait qu'on voit un objet par le biais d'une fonctionnalité et non d'une instance d'un objet particulier ce qui, d'un point de vue polymorphe, est un gros avantage... et supprime le problème de cast...
Un inconvénient en contre partie est que parfois, on a besoin du debogger pour connaître l'instance de l'objet qu'on manipule :aie: