[JAVA] Iterator Pattern

On this page ・ Checking the structure of Iterator ・ Iterator concealment ・ Iterator Pattern and object orientation Describes about

Design Pattarm MENU

Structural confirmation of Iterator

Check with the following class configuration

• User Includes the meaning that other developers use this pattern

The basic structure of the sam and Iterator classes looks like this:

sam.class

class sam{
  int[] i= {0,1,2};
  Iterator iterate(){}
}

Iterator.class

class Iterator{
  boolean hasNext(){}
  int next(){}
}

sam.class

class sam{
  int[] i={0,1,2};

  Iterator iterate(){           //Returns Iterator
    return new Iterator(this.i); // Iterator.Pass an array of sam as an argument to class
  }
}

Iterator.class

class Iterator{
  int[] i;                      // sam.Stores an array of classes A
  int index=0;                  //A variable that counts the elements of an array B

  Iterator(int[] i){this.i=i;}  // sam.Take an array from class and store it in A

  boolean hasNext(){
    boolean b=false;
    if(index<i.length){b=true;} //Compare the number of elements in the array with the value of B to determine if the next element is present:
    else{return b;}
    return b;
  }

  int next(){
    int ans = i[index];         //Sam the current element.Return to class
    index++;
    return ans;
  }
}

user(Main.class)

public static void main(String[] args){
  sam s1 = new sam();
  Iterator it = s1.iterate();
  while(it.hasNext()){
    System.out.println((int) it.next());}
}}

Iterator concealment

Check with the following class configuration

• user is Main.class

The basic class structure is as follows

Interface.interface

interface Interface{
  Iterator iterate();
}

use.class

class use {
  Interface newInstance(){}
}

sam.class

class sam implements Interface{
  int[] i={0,1,2};
  Iterator iterate(){}
}

[Iterator side]

Iterator.interface

interface Iterator{
  boolean hasNext();
  int     next();
}

samIterator.class

class samIterator implements Iterator{
  samIterator(){}
  public  boolean hasNext(){}
  public  int next(){}
}

Let's make each class

Interface.interface

interface Interface{
  Iterator iterate();
}

use.class

class use {
  public static Interface newInstance(){
         return new sam();}
}

sam.class

class sam implements Interface{
  private int[] i={0,1,2};

  public  Iterator iterate(){
          return new samIterator(this.i);
  }
}

Iterator.interface

interface Iterator{
  boolean hasNext();
  int     next();
}

samIterator.class

class samIterator implements Iterator{
  private int i[];
  private int index=0;

  samIterator(int[] i){
          this.i=i;
  }

  public  boolean hasNext(){
          if(index<i.length){return true;}
          else{return false;}
  }

  public  int next(){
          int ans = i[index];
          index++;
          return ans;}
}

user(Main.class)

public static void main(String[] args){
  Interface face = use.newInstance();
  Iterator  it   = face.iterate();
  while(it.hasNext()){
    System.out.println(it.next());
}

Iterator Pattern and object orientation

From user, just use use.class and two interfaces Each implementation class is Unvisible, which eliminates the dependency

The developer can change the array contents of sam.class Even if you change to branch processing to use Map depending on the conditions Nothing needs to be changed on the user side as long as Iterator works