当生成一个内部类对象时,这个内部类对象就与制造它的

外围类对象(enclosing object)之间就有了一种关系.

所以它能访问外围类对象的所有成员,而不需要任何特殊条件.

所以,内部类对象 拥有 外围类的所有元素的访问权(包含private的).

/**
 * 
 * 内部类实现迭代器
 * 内部类可以访问 外围类的任意属性字段,包括private的
 * 迭代器接口,正向迭代器从第一个元素开始迭代 方法 end() 判断迭代是否完成,
 * current() 返回当前对象,next()移动迭代指针
 * 反向迭代器从最后一个元素开始迭代,end()和current()和正向迭代器一样,
 * previous()方法,表示将迭代指针向前移动一个
 */

interface Selector
{
  boolean end();

  Object current();

  void next();
}

//反向迭代器接口
interface IReverseSelector
{
  boolean end();
  Object current();
  void previous();
}

public class Sequence
{
  private Object[] items;   // 外围类 的 private 域
  private int      next = 0;

  public Sequence(int size)
  {
    items = new Object[size];
  }

  public void add(Object x)
  {
    if (next < items.length) items[next++] = x;
  }

  private class SequenceSelector implements Selector
  {
    private int i = 0;

    public boolean end()
    {
      return i == items.length;
    }

    public Object current()
    {
      return items[i]; // 内部类使用外围类的private域,优雅的方式
    }

    public void next()
    {
      if (i < items.length) i++;
    }
  }
  
  //实现一个 反向 迭代 的迭代器
  private class ReverseSelector implements IReverseSelector
  {
    private int i = items.length - 1; //最后一个元素的下标
    
    @Override
    public Object current()
    {
      return items[i];
    }

    @Override
    public boolean end()
    {
      return i < 0; //当i<0,表示遍历完成
    }

    @Override
    public void previous()
    {
      if(i>=0) 
      {
        i --;
      }
      
    }
  }

  public Selector selector()
  {
    return new SequenceSelector();
  }
  
  //获取反向迭代器
  public IReverseSelector getReserveSelector()
  {
    return new ReverseSelector();
  }

  public static void main(String[] args)
  {
    Sequence sequence = new Sequence(10);
    for (int i = 0; i < 10; i++)
    {
      sequence.add(Integer.toString(i));
    }
    
    //正向迭代
    Selector selector = sequence.selector();
    while (!selector.end())
    {
      System.out.print(selector.current() + " ");
      selector.next();//改变迭代指针,防止死循环出现
    }
    
    System.out.println("\n---------------------");
    
    //反向迭代
    IReverseSelector reverseSelector = sequence.getReserveSelector();
    while(!reverseSelector.end())
    {
      System.out.print(reverseSelector.current() + " ");
      reverseSelector.previous(); //改变迭代指针,防止死循环出现
    }
  }
} 

本文固定链接: https://www.jack-yin.com/coding/thinking-in-java/2387.html | 边城网事