Java中Iterable接口的继承与类型兼容性：设计模式与实践

public class Node implements Iterable<Node> {
    private Node upNode;
    private Node downNode;
    private Node leftNode;
    private Node rightNode;
    private Column column; // 关联的列

    // 构造函数及其他方法省略...

    @Override
    public java.util.Iterator<Node> iterator(){
        // 返回一个Node的迭代器，遍历水平方向上的Node
        return new NodeIter(this);
    }

    // NodeIter实现
    private static class NodeIter implements java.util.Iterator<Node>{
        private Node head;
        private Node current;

        public NodeIter(Node node){
            this.head = this.current = node;
        }

        @Override
        public boolean hasNext(){
            return current.getR() != head; // getR() 获取右节点
        }
        @Override
        public Node next(){
            if (!hasNext()) throw new java.util.NoSuchElementException();
            current = current.getR();
            return current;
        }
    }
}

// 尝试一：编译错误
// public class Column extends Node implements Iterable<Column>{
public class Column extends Node { // 暂时不实现Iterable<Column>
    // ... 其他Column特有属性和方法 ...

    /*
    // 尝试重写iterator()方法以返回Iterator<Column>
    @Override
    public Iterator<Column> iterator(){ // 编译错误：返回类型不兼容
        return new Iterator<Column>(){
            private Column currNode = Column.this;

            @Override
            public boolean hasNext(){
                return currNode.getR() != Column.this;
            }
            @Override
            public Column next(){
                if (!hasNext()) throw new NoSuchElementException();
                currNode = currNode.getR();
                return currNode;
            }
        };
    }
    */
}

error: Iterable cannot be inherited with different arguments: <Column> and <Node>
public class Column extends Node implements Iterable<Column>{
       ^
error: iterator() in Column cannot implement iterator() in Iterable
    public Iterator<Column> iterator(){
                            ^
  return type Iterator<Column> is not compatible with Iterator<Node>

// 假设你有一个Column类型的实例 mainColumn
Column mainColumn = new Column();
// ... 初始化 mainColumn ...

// 遍历Column及其相邻的Column
// 由于Column继承了Node的Iterable<Node>，所以它迭代出的是Node
for (Node n : mainColumn) {
    // 检查并强制转换为Column类型
    if (n instanceof Column) {
        Column currColumn = (Column) n;
        // 现在可以使用Column特有的方法
        System.out.print(currColumn.getSize() + " ");
    }
}

// 核心数据节点
class DLNode { // 更名为DLNode以避免与Column混淆
    DLNode up;
    DLNode down;
    DLNode left;
    DLNode right;
    ColumnHeader columnHeader; // 指向其所属的列头

    public DLNode() {
        this.up = this;
        this.down = this;
        this.left = this;
        this.right = this;
        this.columnHeader = null;
    }
    // 其他链接操作方法
    // ...
}

// 列头，管理列中的所有DLNode
class ColumnHeader implements Iterable<DLNode> { // ColumnHeader不再继承DLNode
    String name;
    int size;
    DLNode firstNodeInColumn; // 列中的第一个DLNode（通常是自身，如果它也是一个DLNode）

    public ColumnHeader() {
        this.name = "";
        this.size = 0;
        // 如果ColumnHeader也需要参与四向链表，它内部可以有一个DLNode实例
        this.firstNodeInColumn = new DLNode();
        this.firstNodeInColumn.columnHeader = this; // 让其内部节点指向自身
    }

    // 增加/减少列大小
    public void increment() { this.size++; }
    public void decrement() { this.size--; }

    // 实现Iterable<DLNode>，遍历此列下的所有数据节点
    @Override
    public java.util.Iterator<DLNode> iterator() {
        // 遍历此列的垂直方向上的DLNode
        return new VerticalNodeIterator(this.firstNodeInColumn);
    }

    // 内部迭代器实现
    private static class VerticalNodeIterator implements java.util.Iterator<DLNode> {
        private DLNode head;
        private DLNode current;

        public VerticalNodeIterator(DLNode columnHeadNode) {
            this.head = columnHeadNode;
            this.current = columnHeadNode;
        }

        @Override
        public boolean hasNext() {
            return current.down != head; // down是下一个节点
        }

        @Override
        public DLNode next() {
            if (!hasNext()) throw new java.util.NoSuchElementException();
            current = current.down;
            return current;
        }
    }
    // 其他方法，如获取右侧的ColumnHeader等
    // 如果需要遍历ColumnHeader，则需要另一个类来管理ColumnHeader的链表
    // 例如：RootColumnHeader extends ColumnHeader
}

// 整个Dancing Links矩阵的根
class DancingLinksMatrix {
    ColumnHeader root; // 根列头，可能是一个特殊的ColumnHeader
    // ... 构造函数和添加行等方法 ...

    public DancingLinksMatrix(int[][] matrix) throws Exception {
        // 初始化根列头
        this.root = new ColumnHeader();
        // 根据矩阵创建ColumnHeader链表
        ColumnHeader currentColumn = this.root;
        for (int i = 0; i < matrix[0].length; i++) {
            ColumnHeader nextColumn = new ColumnHeader();
            // 链接ColumnHeader（如果它们也形成一个循环链表）
            // currentColumn.firstNodeInColumn.linkR(nextColumn.firstNodeInColumn); // 或者直接链接ColumnHeader
            currentColumn = nextColumn;
        }
        // currentColumn.firstNodeInColumn.linkR(this.root.firstNodeInColumn); // 完成循环

        // 添加行数据
        for (int[] rowVector : matrix) {
            // this.addRow(rowVector);
        }
    }

    // 遍历所有ColumnHeader
    public Iterable<ColumnHeader> getColumns() {
        return () -> new Iterator<ColumnHeader>() {
            ColumnHeader current = root;
            boolean first = true; // 处理循环链表的第一个元素

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

            @Override
            public ColumnHeader next() {
                if (!hasNext()) throw new NoSuchElementException();
                if (first) {
                    first = false;
                    return current;
                }
                // current = current.firstNodeInColumn.right.columnHeader; // 假设ColumnHeader通过其内部DLNode链接
                // 更好的方式是ColumnHeader内部直接维护rightColumnHeader引用
                return current; // 需要具体实现ColumnHeader之间的链接
            }
        };
    }
}