迭代器模式

1️⃣ 概念

定义：提供一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示
类型：行为型

2️⃣ 适用场景

• 访问一个集合对象的内容而无需暴露它的内部表示
• 为遍历不同的集合结构提供一个统一的接口

3️⃣ 优点

• 分离了集合对象的遍历行为

4️⃣ 缺点

• 类的个数成对增加

5️⃣ 迭代器模式Coding

迭代器模式使用的非常广泛，一般我们都是使用已经封装好的很少会有自己封装迭代器的情况

① 创建Course类

class Course:
    def __init__(self, name):
        self.name = name

    def get_name(self):
        return self.name

② 创建抽象类CourseAggregate

from abc import ABC, abstractmethod

class CourseAggregate(ABC):
    @abstractmethod
    def add_course(self, course):
        pass

    @abstractmethod
    def remove_course(self, course):
        pass

    @abstractmethod
    def get_course_iterator(self):
        pass

③ 创建抽象类CourseIterator

from abc import ABC, abstractmethod

class CourseIterator(ABC):
    @abstractmethod
    def next_course(self):
        pass

    @abstractmethod
    def is_last_course(self):
        pass

④ 创建CourseAggregateImpl类实现CourseAggregate

class CourseAggregateImpl(CourseAggregate):
    def __init__(self):
        self.course_list = []

    def add_course(self, course):
        self.course_list.append(course)

    def remove_course(self, course):
        if course in self.course_list:
            self.course_list.remove(course)

    def get_course_iterator(self):
        return CourseIteratorImpl(self.course_list)

⑤ 创建CourseIteratorImpl实现CourseIterator

class CourseIteratorImpl(CourseIterator):
    def __init__(self, course_list):
        self.course_list = course_list
        self.position = 0
        self.course = None

    def next_course(self):
        print(f"返回课程,位置是: {self.position}")
        self.course = self.course_list[self.position]
        self.position += 1
        return self.course

    def is_last_course(self):
        if self.position < len(self.course_list):
            return False
        return True

⑥ UML类图

⑦ 编写测试类

def main():
    course1 = Course("Java电商一期课程")
    course2 = Course("Java电商二期课程")
    course3 = Course("Java设计模式课程")
    course4 = Course("Python课程")
    course5 = Course("算法课程")
    course6 = Course("前端课程")

    course_aggregate = CourseAggregateImpl()
    course_aggregate.add_course(course1)
    course_aggregate.add_course(course2)
    course_aggregate.add_course(course3)
    course_aggregate.add_course(course4)
    course_aggregate.add_course(course5)
    course_aggregate.add_course(course6)

    print("-----课程列表-----")
    print_courses(course_aggregate)

    course_aggregate.remove_course(course4)
    course_aggregate.remove_course(course5)

    print("-----删除操作之后的课程列表-----")
    print_courses(course_aggregate)

def print_courses(course_aggregate):
    course_iterator = course_aggregate.get_course_iterator()
    while not course_iterator.is_last_course():
        course = course_iterator.next_course()
        print(course.get_name())

if __name__ == "__main__":
    main()

6️⃣ 迭代器模式的实际使用

Python内置迭代器协议 (iter和next)

Python内置迭代器示例

# 使用Python内置的迭代器协议重构CourseAggregate
class CourseAggregateBuiltIn:
    def __init__(self):
        self.course_list = []

    def add_course(self, course):
        self.course_list.append(course)

    def remove_course(self, course):
        if course in self.course_list:
            self.course_list.remove(course)

    def __iter__(self):
        return iter(self.course_list)

# 使用示例
course_aggregate = CourseAggregateBuiltIn()
course_aggregate.add_course(Course("Python基础课程"))
course_aggregate.add_course(Course("Python高级课程"))

# 直接使用for循环遍历
for course in course_aggregate:
    print(course.get_name())