modèle d'itérateur

Le modèle Iterator est un modèle de conception très couramment utilisé dans les environnements de programmation Java et .Net. Ce modèle est utilisé pour accéder séquentiellement aux éléments d'un objet de collection sans connaître la représentation sous-jacente de l'objet de collection.

Le modèle itérateur est un modèle comportemental.

Introduction

Intention : Fournir une méthode pour accéder séquentiellement à chaque élément d'un objet agrégé sans exposer la représentation interne de l'objet.

Solution principale : Différentes manières de parcourir l'ensemble de l'objet intégré.

Quand utiliser : Traverser un objet agrégé.

Comment le résoudre : Donnez la responsabilité de marcher entre les éléments à l'itérateur au lieu de l'objet agrégé.

Code clé : Définir l'interface : hasNext, next.

Exemple d'application : itérateur en JAVA.

Avantages : 1. Il prend en charge la traversée d'un objet agrégé de différentes manières. 2. Les itérateurs simplifient les classes agrégées. 3. Il peut y avoir plusieurs parcours sur le même agrégat. 4. En mode itérateur, il est très pratique d'ajouter de nouvelles classes d'agrégation et classes d'itérateur sans modifier le code d'origine.

Inconvénients : Étant donné que le modèle d'itérateur sépare les responsabilités de stockage des données et de parcours des données, l'ajout d'une nouvelle classe agrégée nécessite l'ajout d'une nouvelle classe d'itérateur, et le nombre de classes augmente par paires. augmente dans une certaine mesure la complexité du système.

Scénarios d'utilisation : 1. Accédez au contenu d'un objet agrégé sans exposer sa représentation interne. 2. Il est nécessaire de fournir plusieurs méthodes de parcours pour les objets agrégés. 3. Fournir une interface unifiée pour parcourir différentes structures d'agrégats.

Remarque : Le modèle itérateur sépare le comportement de traversée des objets de collection et résume une classe itérateur pour prendre en charge, de sorte que la structure interne de la collection ne soit pas exposée et que le code externe soit laissé de manière transparente accéder aux données à l’intérieur de la collection.

Implémentation

Nous allons créer une interface Iterator qui décrit les méthodes de navigation et une interface Container qui renvoie un itérateur. Les classes d'entités qui implémentent l'interface Container seront responsables de l'implémentation de l'interface Iterator.

IteratorPatternDemo, notre classe de démonstration utilise la classe d'entité NamesRepository pour imprimer les Names stockés sous forme de collection dans le NamesRepository.

Étape 1

Créer une interface.

Iterator.java

public interface Iterator {
   public boolean hasNext();
   public Object next();
}

Container.java

public interface Container {
   public Iterator getIterator();
}

Étape 2

Créé et implémentéContainer La classe d'entité de l'interface. Cette classe a une classe interne NameIterator qui implémente l'interface Iterator.

NameRepository.java

public class NameRepository implements Container {
   public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};

   @Override
   public Iterator getIterator() {
      return new NameIterator();
   }

   private class NameIterator implements Iterator {

      int index;

      @Override
      public boolean hasNext() {
         if(index < names.length){
            return true;
         }
         return false;
      }

      @Override
      public Object next() {
         if(this.hasNext()){
            return names[index++];
         }
         return null;
      }		
   }
}

Étape 3

Utilisez NameRepository pour obtenir l'itérateur et imprimer le nom.

IteratorPatternDemo.java

public class IteratorPatternDemo {
	
   public static void main(String[] args) {
      NameRepository namesRepository = new NameRepository();

      for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
         String name = (String)iter.next();
         System.out.println("Name : " + name);
      } 	
   }
}

Étape 4

Vérifiez la sortie.

Name : Robert
Name : John
Name : Julie
Name : Lora