iterateur

Itérateur (Iterator ou Cursor)

OBJECTIFS :

Fournir un moyen de parcourir séquentiellement les éléments d'un objet composé.

RAISONS DE L'UTILISER :

Le système doit parcourir les éléments d'un objet complexe. La classe de l'objet complexe peut varier.

Cela est le cas des classes représentant des listes et des ensembles en Java.

Les classes d'un objet complexe (listes) sont des "composes". Elles ont une méthode retournant un itérateur, qui permet de parcourir les éléments. Tous les iterateurs ont la même interface. Ainsi, le système dispose d'un moyen homogène de parcourir les composes.

RESULTAT :

Le Design Pattern permet d'isoler le parcours d'un agrégat.

RESPONSABILITES :

  • Compose : définit l'interface d'un objet composé permettant de créer un Iterateur.
  • ConcreteCompose : est une sous-classe de l'interface Compose. Elle est composée d'éléments et implémente la méthode de création d'un Iterateur.
  • Iterateur : définit l'interface de l'itérateur, qui permet d'accéder aux éléments de l'objet Compose.
  • ConcreteIterateur : est une sous-classe de l'inteface Iterateur. Elle fournit une implémentation permettant de parcourir les éléments de ConcreteCompose. Elle conserve la trace de la position courante.
  • La partie cliente demande à l'objet Compose de fournir un objet Iterateur. Puis, elle utilise l'objet Iterateur afin de parcourir les éléments de l'objet Compose.
IMPLEMENTATION JAVA :
Compose.java
/**
* Définit l'interface d'un objet composé.
*/
public interface Compose {

/**
* Retourne un objet "Iterateur"
*/
public Iterateur creerIterateur();
}
ConcreteCompose.java
/**
* Sous-classe de l'interface "Compose".
*/
public class ConcreteCompose implements Compose {

// Elements composants l'objet "Compose"
private String[] elements = {
"Bonjour" , "le", "monde"
};

/**
* Retourne un objet "Iterateur" permettant
* de parcourir les éléments
*/
public Iterateur creerIterateur() {
return new ConcreteIterateur(elements);
}
}
Iterateur.java
/**
* Définit l'interface de l'itérateur.
*/
public interface Iterateur {

/**
* Retourne l'élément suivant
*/
public String suivant();

/**
* Retourne si l'itérateur
* est arrivé sur le dernier élément
*/
public boolean fini();
}
ConcreteIterateur.java
/**
* Sous-classe de l'inteface "Iterateur".
*/
public class ConcreteIterateur implements Iterateur {

private String[] elements;
private int index = 0;

public ConcreteIterateur(String[] pElements) {
elements = pElements;
}

/**
* Retourne l'élément
* puis incrémente l'index
*/
public String suivant() {
return elements[index++];
}

/**
* Si l'index est supérieur ou égal
* à la taille du tableau,
* on considère que l'on a fini
* de parcourir les éléments
*/
public boolean fini() {
return index >= elements.length;
}
}
IteratorPatternMain.java
public class IteratorPatternMain {

public static void main(String[] args) {
// Création de l'objet "Compose"
Compose lCompose = new ConcreteCompose();
// Création de l'objet "Iterateur"
Iterateur lIterateur = lCompose.creerIterateur();

// Parcours les éléments de l'objet "Compose"
// grâce à l'objet "Iterateur"
while(!lIterateur.fini()) {
System.out.println(lIterateur.suivant());
}

// Affichage :
// Bonjour
// le
// monde
}
}
Comments