Java 设计模式之迭代器模式

Java 设计模式之迭代器模式

在软件开发中，迭代器模式是一种行为型设计模式，它允许我们访问一个聚合对象的元素，而不需要暴露聚合对象的内部结构。该模式属于行为型模式，因为它可以在运行时改变对象的行为。

在本文中，我们将介绍迭代器模式的基本原理，并通过一个简单的案例来演示如何使用迭代器模式。

迭代器模式基本原理

迭代器模式提供了一种遍历聚合对象的方法，而不需要暴露聚合对象的内部结构。该模式通过定义一个公共的接口来遍历聚合对象，而不是暴露聚合对象的实现细节。

在迭代器模式中，我们首先定义一个抽象的迭代器接口，它包含了一些方法，如 next()、hasNext() 等，用于遍历聚合对象。然后，我们定义一个抽象的聚合对象接口，它包含了一个创建迭代器对象的方法 createIterator()。

具体的迭代器类和聚合对象类则实现了对应的接口，并提供了实现细节。

在使用迭代器模式时，我们首先创建一个聚合对象，并使用 createIterator() 方法创建一个迭代器对象。然后，我们使用迭代器对象遍历聚合对象的元素，而不需要了解聚合对象的内部结构。

迭代器模式案例

假设我们正在开发一个商店销售管理系统，我们需要实现一个订单列表，用于展示所有订单的信息。我们可以使用迭代器模式来实现订单列表，如下所示：

首先，我们创建一个名为 Order 的订单类，它包含了一些属性，如订单号、客户名称、订单金额等。

public class Order {
    
    
    private int orderId;
    private String customerName;
    private double orderAmount;

    public Order(int orderId, String customerName, double orderAmount) {
    
    
        this.orderId = orderId;
        this.customerName = customerName;
        this.orderAmount = orderAmount;
    }

    public int getOrderId() {
    
    
        return orderId;
    }

    public String getCustomerName() {
    
    
        return customerName;
    }

    public double getOrderAmount() {
    
    
        return orderAmount;
    }

    @Override
    public String toString() {
    
    
        return "Order{" +
                "orderId=" + orderId +
                ", customerName='" + customerName + '\'' +
                ", orderAmount=" + orderAmount +
                '}';
    }
}

然后，我们创建一个名为 OrderList 的订单列表类，它实现了迭代器模式中的聚合对象接口。在 OrderList 类中，我们包含了一个 Order 类型的列表，并实现了 createIterator() 方法来创建迭代器对象

public class OrderList implements Iterable<Order> {
    
    
    private List<Order> orders;

    public OrderList() {
    
    
        orders = new ArrayList<>();
    }

    public void addOrder(Order order) {
    
    
        orders.add(order);
    }

    public void removeOrder(Order order) {
    
    
        orders.remove(order);
    }

    @Override
    public Iterator<Order> iterator() {
    
    
        return new OrderIterator();
    }

    private class OrderIterator implements Iterator<Order> {
    
    
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
    
    
            return currentIndex < orders.size();
        }

        @Override
        public Order next() {
    
    
            return orders.get(currentIndex++);
        }
    }
}

在 OrderList 类中，我们实现了 Iterable 接口，并在 iterator() 方法中返回了一个 OrderIterator 类型的迭代器对象。在 OrderIterator 类中，我们包含了一个当前索引 currentIndex，并实现了 hasNext() 和 next() 方法，用于遍历订单列表中的元素。

现在，我们可以创建一个 OrderList 对象，并使用 addOrder() 方法添加一些订单。然后，我们可以使用 OrderList 对象的迭代器对象遍历订单列表中的元素，如下所示：

OrderList orderList = new OrderList();
orderList.addOrder(new Order(1, "Alice", 100.0));
orderList.addOrder(new Order(2, "Bob", 200.0));
orderList.addOrder(new Order(3, "Charlie", 300.0));

for (Order order : orderList) {
    
    
    System.out.println(order);
}

在这个示例中，我们首先创建了一个 OrderList 对象，并使用 addOrder() 方法添加了三个订单。然后，我们使用 for 循环和迭代器对象遍历订单列表中的元素，并输出每个订单的信息。

通过使用迭代器模式，我们可以轻松地遍历聚合对象中的元素，而不需要了解聚合对象的内部结构。这提高了代码的可维护性和可扩展性。

总结

迭代器模式是一种常用的行为型设计模式，它允许我们遍历聚合对象中的元素，而不需要暴露聚合对象的内部结构。在本文中，我们介绍了迭代器模式的基本原理，并通过一个简单的案例来演示如何使用迭代器模式。通过实现迭代器接口来遍历聚合对象中的元素，我们可以提高代码的可维护性和可扩展性。