当内部类与接口组合在一起的时候，可以真正展现内部类的实用性了。在一个类（顶层类）中定义一个内部类，让这个内部类实现一个接口（在顶层类之外，同包不同包都可），然后通过接口变量来引用这个内部类的实例，于是就不用和内部类的名称打交道，更重要的是可以屏蔽内部类的实现细节。
如下代码是一个简单案例：
java
package com.test;
interface Iterator{
/**
* 接口：Iterator
* 方法：hasNext() 返回一个布尔值
* 方法：next() 返回一个字符串
*/
boolean hasNext();
String next();
}
public class StringHolder {
/**
* 类：StringHolder 用于存储字符串，并提供字符串的迭代功能
*/
private String[] values; // 属性：字符串数组
private int pos; // 属性：整数，数组的索引坐标
/**
类StringHolder的构造函数，参数是一个整数
初始化类StringHolder私有属性values数组的长度
初始化类StringHolder私有属性pos为0
*/
public StringHolder(int length) {
values = new String[length];
pos = 0;
}
/**
* 类StringHolder的成员方法，把参数值添加到类属性values数组中
* @param val 一个字符串
*/
public void put(String val) {
this.values[pos++] = val;
}
/**
* 根据参数返回类属性values数组中的一个元素
* @param index 一个整数
* @return 类属性values数组index索引的值
*/
public String get(int index) {
return values[index];
}
/**
* 定义一个方法：iterator
* @return 私有内部类StringIterator的实例
* 因为类StringIterator是实现接口Iterator，
* 类StringIterator实例对象作为返回值，该方法的类型是Iterator接口，故会发生向上转型，这是合法允许的。
*/
public Iterator iterator() {
return new StringIterator();
}
/**
* 类StringHolder内部的一个私有类StringIterator，实现Iterator接口
*/
private class StringIterator implements Iterator {
private int ipos = 0; // 私有属性ipos，初始值为0，用于从索引位置0开始迭代
// 实现接口Iterator中定义的next()方法
public String next() {
return values[ipos++];
}
// 实现接口Iterator中定义的方法
public boolean hasNext() {
return ipos < values.length;
}
}
public static void main(String[] args) {
// 创建类StringHolder的实例，通过构造函数传入参数，将初始化类属性values数组的元素个数为10
StringHolder sh = new StringHolder(10);
// 调用类StringHolder成员方法put()，给类成员数组values赋值
for(int i=0;i<10;i++){
sh.put(((Integer)(i * 3)).toString());
}
// 创建接口Iterator类型变量it,通过类StringHolder实例中的方法iterator()赋值给变量it
// it变量是StringIterator向上转型的实例对象
Iterator it = sh.iterator();
while (it.hasNext()) {
System.out.print(it.next());
System.out.print(" ");
}
}
}代码理解：
（1）首先定义了一个接口Iterator，这个接口有两个方法分别是hasNext()和next()
（2）定义StringHolder类，这个类的作用是用于存储字符串，并提供字符串的迭代功能。
（3）在StringHolder类中定义了一个内部类StringIterator，StringItertor实现了接口Iterator（编写hasNext()和next()实现代码），
（3）在这个顶层类StringHolder中，定义了一个方法iterator，iterator方法返回的类型是接口Iterator，iterator方法内部创建了一个内部类StringIterator的实例，并返回它。该实例会被向上转型为接口类型。
（4）当需要使用这个内部类的实例时，调用外部类对象的iterator方法，并赋值给外部类中定义的Iterator接口类型的变量即可。如上面代码：
Iterator it = sh.iterator(); //sh是顶层类的实例（5）既然不需要直接访问内部类StringIterator，为了更好地屏蔽内部类的实现细节，把内部类声明为private，这样如同顶层类StringHolder的私有成员一样，无法在顶层类之外访问这个内部类StringIterator。
（6）上面是一段完整的可运行代码，运行结果是：0 3 6 9 12 15 18 21 24 27
总结学习知识点：
（1）使用了迭代器（Itertor）设计模式。在Java的类库中，有Iterator和Iterable接口，当外部类实现了Iterable接口，并且有一个内部类实现了Iterator接口之后，就可以使用"for each"循环来遍历外部类中的元素了。
利用上面提到的Java特性，上面StringHolder类就实现了一个字符串容器，且可以通过方法进行迭代。
（2）StringHolder类内部的实现采用数组来存储字符串。