Java Iterable 接口的继承陷阱与数据结构设计优化

public class Node implements Iterable<Node> {
    // ... 其他成员和方法 ...

    @Override
    public java.util.Iterator<Node> iterator(){
        // ... 实现细节 ...
        return new NodeIter(this);
    }
}

// public class Column extends Node implements Iterable<Column>{ // 编译错误
public class Column extends Node {
    // ... 其他成员和方法 ...

    /*
    @Override
    public Iterator<Column> iterator(){ // 编译错误
        // ... 实现细节 ...
    }
    */
}

// 假设你有一个Node对象，其getColumn()方法返回一个Column对象
// 并且这个Column对象（作为Node的子类）可以被迭代为Node
for (Node n : someNode) { // 迭代Node
    // 假设n.getColumn()返回的是Column实例，但其类型是Node
    // 并且这个Column实例本身也实现了Iterable<Node>
    for (Node cNode : n.getColumn()) { // 迭代Node类型的元素
        // 将Node类型的迭代元素强制转换为Column类型
        ((Column) cNode).increment(); // 现在可以访问Column特有的方法
    }
}

// 或者在Column的toString()方法中，如果Column被视为Iterable<Node>
@Override
public String toString(){
    String str = "";
    // 这里的this实际上是Column实例，它继承了Iterable<Node>
    // 因此可以用for-each循环遍历Node类型的元素
    for (Node currNode : this) {
        // 如果我们知道迭代出来的是Column，可以进行类型转换
        if (currNode instanceof Column) {
            str += ((Column) currNode).getSize() + " ";
        } else {
            // 处理非Column类型的Node，或者根据设计判断是否会发生
            str += "Node(" + currNode.hashCode() + ") ";
        }
    }
    return str;
}

// 1. Node类：纯粹的四向链表节点
public class Node {
    Node up, down, left, right;
    Column header; // 每个节点都属于一个列，指向其列头

    public Node() {
        this.up = this;
        this.down = this;
        this.left = this;
        this.right = this;
        this.header = null;
    }

    // 链接方法
    void linkDown(Node other) { /* ... */ }
    void linkRight(Node other) { /* ... */ }
    // ... 其他节点操作方法 ...

    public Column getHeader() {
        return this.header;
    }

    public void setHeader(Column header) {
        this.header = header;
    }
}

// 2. Column类：表示一个列，并管理该列的节点
public class Column implements Iterable<Node> { // Column现在是Iterable<Node>
    private String name;
    private int size;
    private Node headNode; // Column内部包含一个Node作为列头

    public Column(String name) {
        this.name = name;
        this.size = 0;
        this.headNode = new Node(); // 列头本身也是一个Node
        this.headNode.setHeader(this); // 自身作为列头
        // 对于列头节点，其up和down通常指向自身，或者根据算法需要有特殊处理
    }

    public String getName() { return name; }
    public int getSize() { return size; }
    public void increment() { this.size++; }
    public void decrement() { this.size--; }

    // Column可以提供方法来访问其下的节点
    public Node getFirstDataNode() {
        return headNode.down; // 假设headNode.down是第一个数据节点
    }

    // 实现Iterable<Node>，迭代该列下的所有数据节点（不包括列头本身）
    @Override
    public java.util.Iterator<Node> iterator() {
        return new java.util.Iterator<Node>() {
            private Node current = headNode.down; // 从第一个数据节点开始
            private boolean first = true; // 标记是否是第一次next()调用

            @Override
            public boolean hasNext() {
                // 如果当前节点是列头，且不是第一次检查，则表示遍历结束
                // 或者如果headNode.down == headNode (空列)，则没有next
                return current != headNode || first;
            }

            @Override
            public Node next() {
                if (!hasNext()) {
                    throw new java.util.NoSuchElementException();
                }
                if (first) {
                    first = false;
                } else {
                    current = current.down;
                }
                // 再次检查，如果current回到headNode，说明是空列或者遍历结束
                if (current == headNode) {
                    throw new java.util.NoSuchElementException(); // 确保不会返回headNode
                }
                return current;
            }
        };
    }
}

// 3. Matrix类：管理所有Column
public class Matrix implements Iterable<Column> { // Matrix可以迭代Column
    private Column headColumn; // 矩阵的虚拟头列

    public Matrix(int[][] input) {
        // 初始化列，形成一个循环链表
        // ...
        // 假设headColumn是第一个Column实例
        // headColumn.linkRight(nextColumn);
    }

    // 实现Iterable<Column>，迭代矩阵中的所有列
    @Override
    public java.util.Iterator<Column> iterator() {
        return new java.util.Iterator<Column>() {
            private Column current = headColumn; // 从虚拟头列开始
            private boolean first = true;

            @Override
            public boolean hasNext() {
                return current.right != headColumn || first;
            }

            @Override
            public Column next() {
                if (!hasNext()) throw new java.util.NoSuchElementException();
                if (first) {
                    first = false;
                } else {
                    current = (Column) current.right; // 假设Column也继承Node并有right字段
                }
                // 如果是虚拟头列，跳过它
                if (current == headColumn) {
                     // 再次检查，确保不是空矩阵
                     if (current.right == headColumn) {
                         throw new java.util.NoSuchElementException();
                     }
                     current = (Column) current.right; // 跳过虚拟头列
                }
                return current;
            }
        };
    }
}