public class Teacher implements Iterable{  

     private String name;  
     private int age;  


     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
     public int getAge() {  
         return age;  
     }  
     public void setAge(int age) {  
         this.age = age;  
     }  
     public Iterator iterator() {  
         return new Itr();  
     }  


     public static void main(String[] args) {  
         Teacher t = new Teacher();  
         t.setName("aaaaaaa");  
         t.setAge(23);  
         for (Object o : t) {  
             System.out.println(o.toString());  
         }  
     }  


     private class Itr implements Iterator{  
         private int cursor=0; // 属性的索引  
         private Field[] fields = Teacher.class.getDeclaredFields(); // 属性的数组  

         public boolean hasNext() {  

             return cursor!=(Teacher.class.getDeclaredFields().length);  
         }  

         public Object next() {  
             Object o=null;  
             try{  
                 fields[cursor].setAccessible(true);  // 让内部类可以访问外部类的私有属性的值  
                 o = fields[cursor].getName()+" "+fields[cursor].get(Teacher.this);  
                 cursor++;  
             }catch(Exception e){  
                 System.out.println(e);  
             }  

             return o;  
         }  

         public void remove() {  
             // TODO Auto-generated method stub  

         }  

     }  
 } 

import java.util.Iterator;

//测试类
public class Exec {
    public static void main(String[] args) throws Exception {
        // 创建学生集合类
        Students students = new Students(10);

        // 通过for each语句迭代循环学生集合类的每个元素
        for (Object obj : students) {
            Student stu = (Student) obj;
            System.out.println(stu.getSid() + ":" + stu.getName());
        }
    }
}

// 支持for each迭代循环的学生集合类
class Students implements Iterable {
    // 存储所有学生类的数组
    private Student[] stus;

    // 该构造函数可以生成指定大小的学生类变量数组，并初始化该学生类变量数组
    public Students(int size) {
        stus = new Student[size];
        for (int i = 0; i < size; i++) {
            stus[i] = new Student(String.valueOf(i), "学生" + String.valueOf(i));
        }
    }

    // 实现Iterable接口的重要方法，返回自定义的迭代类变量
    public Iterator iterator() {
        return new StudentIterator();
    }

    // 实现Iterator接口的私有内部类，外界无法直接访问
    private class StudentIterator implements Iterator {
        // 当前迭代元素的下标
        private int index = 0;

        // 判断是否还有下一个元素，如果迭代到最后一个元素就返回false
        public boolean hasNext() {
            return index != stus.length;
        }

        // 返回当前元素数据，并递增下标
        public Object next() {
            return stus[index++];
        }

        // 这里不支持，抛出不支持操作异常
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}

// 学生类
class Student {
    // 学生学号
    private String sid;

    // 学生姓名
    private String name;

    // 默认构造函数
    public Student() {
    }

    // 支持属性值初始化的构造函数
    public Student(String sid, String name) {
        setSid(sid);
        setName(name);
    }

    // 学生学号的读取函数
    public String getSid() {
        return sid;
    }

    // 学生学号的设置函数
    public void setSid(String sid) {
        this.sid = sid;
    }

    // 学生姓名的读取函数
    public String getName() {
        return name;
    }

    // 学生姓名的设置函数
    public void setName(String name) {
        this.name = name;
    }

    // 格式化字符信息输出
    public String toString() {
        return this.sid + ":" + this.name;
    }
}