一个数组中存在Student和Teacher两种对象，现有两种访问需求，一个是访问所有学生，一个是访问所有人员，请用迭代器模式实现两种访问，并打印出人员的基本信息。 要求：所有迭代器使用用一个聚合对象，用Java编写实现

迭代器模式是一种设计模式，它提供了一种顺序访问聚合对象元素的能力，而无需暴露其内部表示。在这种情况下，我们可以创建一个`PersonList`聚合类，包含`Student`和`Teacher`对象的列表，然后分别定义两个迭代器：一个专门用于学生，另一个用于所有人员。以下是使用Java实现这个场景的示例：

import java.util.ArrayList;
import java.util.List;

// 聚合对象 - PersonList
class PersonList {
    private List<Person> people;

    public PersonList() {
        this.people = new ArrayList<>();
    }

    // 添加学生和教师
    public void add(Student student) {
        people.add(student);
    }
    public void add(Teacher teacher) {
        people.add(teacher);
    }

    // 使用迭代器访问所有学生
    public void iterateStudents(Iterator<Student> iterator) {
        for (Person person : people) {
            if (person instanceof Student) {
                Student student = (Student) person;
                System.out.println("Student: Name=" + student.getName() + ", Age=" + student.getAge());
            } else {
                iterator.next(); // 如果不是学生，跳过并继续迭代
            }
        }
    }

    // 使用迭代器访问所有人员
    public void iterateAll(Iterator<Person> allIterator) {
        while (allIterator.hasNext()) {
            Person person = allIterator.next();
            System.out.println("Person: " + person.getClass().getSimpleName() + ", Name=" + person.getName());
        }
    }
}

// 基类和子类 - Person
abstract class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    abstract void printInfo();
}

class Student extends Person {
    int age;

    public Student(String name, int age) {
        super(name);
        this.age = age;
    }

    @Override
    void printInfo() {
        System.out.println("Student: Name=" + name + ", Age=" + age);
    }
}

class Teacher extends Person {
    String subject;

    public Teacher(String name, String subject) {
        super(name);
        this.subject = subject;
    }

    @Override
    void printInfo() {
        System.out.println("Teacher: Name=" + name + ", Subject=" + subject);
    }
}

public class Main {
    public static void main(String[] args) {
        PersonList list = new PersonList();
        list.add(new Student("Alice", 20));
        list.add(new Teacher("Bob", "Math"));

        // 创建学生迭代器
        Iterator<Student> studentIterator = list.createStudentIterator();

        // 创建所有人员迭代器
        Iterator<Person> allIterator = list.createAllIterator();

        // 访问学生
        list.iterateStudents(studentIterator);

        // 访问所有人员
        list.iterateAll(allIterator);
    }

    // 创建对应类型的迭代器
    static Iterator<Student> createStudentIterator(PersonList list) {
        return new FilterIterator<>(list.people.iterator(), Student.class);
    }

    static Iterator<Person> createAllIterator(PersonList list) {
        return list.people.iterator();
    }

    // 过滤迭代器，只返回特定类型的对象
    private static class FilterIterator<T> implements Iterator<T> {
        private Iterator<Person> iterator;
        private Class<T> clazz;

        FilterIterator(Iterator<Person> iterator, Class<T> clazz) {
            this.iterator = iterator;
            this.clazz = clazz;
        }

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }

        @Override
        public T next() {
            Person nextElement = iterator.next();
            if (nextElement instanceof clazz) {
                return clazz.cast(nextElement);
            } else {
                throw new IllegalStateException("Unexpected element type");
            }
        }

        @Override
        public void remove() {
            iterator.remove();
        }
    }
}

在这个例子中，我们创建了`FilterIterator`作为通用的`Person`迭代器的子类，通过检查每个元素是否属于所需类型来过滤结果。在`main`函数中，我们分别创建了学生迭代器和所有人员迭代器，并使用它们来访问数据。