Discussion :

[coco-sup]

Bonjour, je ne comprend pas un concept fondamentale en java concernant les interfaces. Je précise que je suis un débutant invétéré.

Voilà j'ai compris le fonctionnement des classes, par exemple :

Code :

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

Personne p = new Personne();

Donc la on instancie un objet de type Personne dont la référence s'appelle p.

Ce que je ne comprend pas c'est pourquoi on fait un peu la même chose avec les interfaces. Je pensais qu'on ne pouvait pas instancié une interface, ou déclarer une référence à partir d'une interface, je pensais qu'on ne pouvait que l'implémenter... bref je suis bien perdu

Je m'explique avec un exemple :

Code :

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

Iterator it = maCollection.iterator();

Ici par exemple je ne comprend pas pourquoi on déclare une référence it dont le type est l'interface Iterator
maCollection.iterator() me retourne un objet de type Iterator, et pourtant au lieu d'utiliser la classe Iterator, on utilise l'interface Iterator pour la variable it...

De la même manière, j'ai compris au niveau de l'architecture d'une application que les couches dialoguaient entres elles grâce aux interfaces pour pouvoir modifier facilement l'implémentation de celle ci. Mais je ne comprend pas par exemple, la synthaxe suivante (tiré du cours web3tiers p.11 dans les tutos du site):

Code :

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

private IArticlesDao articlesDao;

Il y a marqué qu'il s'agit de l'objet d'accès aux données fourni par la couche d'accès aux données

Vous voyez un peu mon niveau

Merci de m'éclairer un peu...

[in]

En fait les interfaces sont à la base de la généricité.

En gros le fait de déclarer un objet de type interface permet en fait de déclarer un objet dont on est sûr qu'il implémente un certain nombre de méthode.

Par contre il est impossible d'instancier une interface.

Par 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
23
24
25
26
27
28
29
30
31
32
33
34
35
 
public interface MonInterface {
 
      public void maMethode();
}
 
 
public maClass1 implements MonInterface {
 
       public void maMethode(){...}
}
 
 
public maClass2 implements MonInterface {
 
       public void maMethode(){...}
}
 
 
public class Test{
 
    public static void main (String[] args){
 
    MonInterface mi;
 
    mi = new MonInterface(); // IMPOSSIBLE
    mi = new MaClass1();   // OK
    mi = new MaClass2();   // OK
 
    // là tu te sers de mi, et quelque soit son "vrai" type, tu peux appeler les même méthodes.
   // ton code est donc générique dans le sens ou le même bout de code peut s'appliquer à plusieurs types d'objets
 
    }
 
}

J'espère que ça répond à une partie de tes interrogations. Désolé je suis pas très inspiré pour l'exemple ...

Dans ton cas, pour l'Iterator, tu te fiches de connaitre son implémentation. En gros les objets "parcourables" fournissent un objet qui implémente Iterator et ceci pour que tout le monde puisse les utiliser facilement. Si chaque objet fournissait son propre type de "curseur" ça serait le bordel ...

Mais bon je suis sûr que des personnes hautement qualifiées (suivez mon regard) te donneront de meilleures explications/exemples.

(Quant à moi j'espère ne pas m'attirer leurs foudres si mon explications est pourrie

PS : je connais des gens ne se disant pas débutant qui ont l'air d'en comprendre moins que toi ...

[coco-sup]

Merci beaucoup pour ton indulgence, ta réponse est claire, je dois être la seule personne au monde à faire un bloquage la dessus

J'aimerais quand même te demander davantage de précision.

Quelle différence fais tu alors entre :

Code :

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

MonInterface mi = new MaClass1();

et :

Code :

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

MaClass1 mi = new MaClass1();

(ou

Code :

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

MaClass2 mi = new MaClass2();

)

Tu parles de généricité, je pensais avoir compris ce concept mais apparemment il y a des subtilités qui m'échappent...

En fait dans mon exemple MaClass1 mi = new MaClass1();, si je fais mi.maMethode() j'aurais l'implémentation de maMéthode() pour MaClasse1.

De la même manière, pour MaClass2 mi = new MaClass2(); jsi je fais mi.maMethode() j'aurais l'implémentation de maMéthode() pour MaClasse2.

Maintenant si avec MonInterface mi = new MaClass1(); je fais mi.maMethode() j'aurais toujours l'implémentation de maMéthode() pour MaClasse1... arf je encore perdu LOL

[in]

je dois être la seule personne au monde à faire un bloquage la dessus

Non c'est un des points "bloquant" des concepts de la POO ...

Quelle différence fais tu alors entre :

Code :

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

MonInterface mi = new MaClass1();

et :

Code :

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

MaClass1 mi = new MaClass1();

Ben ya pas de différence mis à part qu'en déclarant un objet MonInterface, tu fais abstraction dans ton code du "vrai" type de l'objet

par 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
23
24
25
26
27
28
29
30
31
32
33
34
public interface Vehicule{
 
    public void deplacement();
}
 
public class Voiture implements Vehicule{
 
    public void deplacement(){
         System.out.println("Je roule !");
    }
}
 
public class Avion implements Vehicule{
 
    public void deplacement(){
         System.out.println("Je vole !");
    }
}
 
public class Test {
 
     public static void main(String[] args){
          ArrayList<Vehicule> liste = new ArrayList<Vehicule>();
          liste.add(new Voiture());
          liste.add(new Avion());
          liste.add(new Voiture());
          liste.add(new Avion());
 
          for(Vehicule v : liste){
 
               v.deplacement();
          }
     }
}

Affichera :
je roule !
je vole !
je roule !
je vole !

Tu parles de généricité, je pensais avoir compris ce concept mais apparemment il y a des subtilités qui m'échappent...
...
Maintenant si avec MonInterface mi = new MaClass1(); je fais mi.maMethode() j'aurais toujours l'implémentation de maMéthode() pour MaClasse1... arf je encore perdu LOL

Oui c'est ça ... non t'es pas perdu

Et voilà, j'espère qu'avec ce nouvel super exemple tu auras mieux saisi ce que j'entends par généricité ...

[adiGuba]

Salut,

Merci beaucoup pour ton indulgence, ta réponse est claire, je dois être la seule personne au monde à faire un bloquage la dessus

Rassures-toi : ce n'est pas un concept si évident que cela ! Et il faut un peu de temps pour comprendre tous les avantages que cela apporte...



Les interfaces permettent simplement de définir un comportement qui pourra être repris par plusieurs classes. En gros une interface définit "ce qu'il faut faire", mais pas "comment il faut le faire"...


Je ne sais pas si c'est une bonne idée, mais on va prendre l'exemple des collections de Java.


Jusqu'à Java 1.2, pour gérer une liste d'objet, on ne disposait que de la classe Vector, qui utilisait un tableau redimensionnable en interne, et qu'on utilisait simplement :

Code :

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

Vector v = new Vector();

Ce qui est très limité puisque tu n'as aucun choix alternatif !



Avec Java 1.2, l'API de Collections a été grandement amélioré, en utilisant massivement des interface. Ainsi désormais l'interface java.util.List définit un certain nombre de méthode pour gérer une liste d'objet. Elle dispose principalement de trois classes qui propose une implémentation différente pour le même "comportement" global :

• ArrayList qui utilise un tableau redimensionnable en interne (tout comme Vector).
• LinkedList, qui propose un organisation en liste chainé.
• La classe Vector existante a été modifié afin d'implémenter l'interface List

Chacune de ces classes a ses avantages et ses défauts (voir la FAQ : Quelles différences entre ArrayList, LinkedList et Vector ?), même si Vector devrait être remplacé par ArrayList lorsque c'est possible.



Maintenant quel est l'intérêt d"voir une interface commune ? C'est tout simplement d'écrire du code générique, c'est à dire qui marchera quel que soit l'implémentation de la liste.


Maintenant, imagine que tu as une méthode qui doivent ajouter des éléments dans une liste d'objet, par exemple dans un Vector :

Code :

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

1
2
3
4
5
6
	public void ajouterDans(Vector vector) {
		// Ajoute 10 éléments :
		for (int i=0; i<10; i++) {
			vector.add( "Element " + i );
		}
	}

Le problème de ce code, c'est qu'il oblige à utiliser un Vector dans tous les cas, alors que le développeur voudrait peut-être utilser un autre type de liste...

La mauvaise solution sera de surcharger les méthodes avec les différents types :

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
	public void ajouterDans(Vector vector) {
		// Ajoute 10 éléments :
		for (int i=0; i<10; i++) {
			vector.add( "Element " + i );
		}
	}
 
	public void ajouterDans(ArrayList arrayList) {
		// Ajoute 10 éléments :
		for (int i=0; i<10; i++) {
			arrayList.add( "Element " + i );
		}
	}
 
	public void ajouterDans(LinkedList linkedList) {
		// Ajoute 10 éléments :
		for (int i=0; i<10; i++) {
			linkedList.add( "Element " + i );
		}
	}

Mais cela pose plusieurs problèmes :

1. C'est lourd...
2. C'est pas très maintenable (toutes modifs devra être répercuté dans les trois méthodes).
3. Ce n'est pas très évolutif (on ne peut pas utiliser un autre type de List sans rajouter une méthode.

Maintenant, en utilisant l'interface List, on peut faire un méthode générique :

Code :

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

1
2
3
4
5
6
	public void ajouterDans(List list) {
		// Ajoute 10 éléments :
		for (int i=0; i<10; i++) {
			list.add( "Element " + i );
		}
	}

Lorsqu'on code la méthode, on ne sait pas forcément avec quel type de List elle sera utilisé, mais quel que soit l'implémentation choisit (Vector, LinkedList, ArrayList ou n'importe quel autre), on est sûr que cela marchera.

La méthode est générique : elle utilise une interface qui défini un comportement et non pas une implémentation particulière.

Ainsi, le developpeur a le droit d'utiliser n'importe quel List avec ta méthode...


a++

[coco-sup]

Merci ton exemple est très interressant, je comprend mieux a quoi cela sert
Merci à tous les 2 !