Java辅助方法无法访问内部类Node的问题及正确写法问询

咱们先拆解你遇到的问题：为啥明明Link和Node都是public的，reverse方法却找不到Node类？其实核心原因是Node是Link类的非静态内部类，它的作用域被限定在Link类内部，而你的reverse方法是顶层Solution类的方法，直接写Node的话，编译器根本不知道这个Node是哪个类的成员。

错误根源详解 #

Java里的内部类分两种：静态内部类和非静态内部类（成员内部类）。你写的Node是Link的非静态内部类，这意味着：

• Node类的实例必须依赖于Link类的实例存在
• 在Link类外部引用Node时，必须明确指定它属于Link类，也就是要用Link.Node这种限定类名，而不能直接写Node
• 你当前的reverse方法签名是public Node reverse(Node curr)，编译器在Solution类的作用域里找不到名为Node的类，所以报“cannot find symbol”错误

另外，你的代码还有几个小bug，顺便提一下：

• Java里访问对象成员用.而不是C++的->，所以curr->next要改成curr.next
• return res;里的res根本没定义，递归终止条件应该返回当前节点curr
• main方法里reverse(head)的head是未定义的，应该传first.head这种具体的节点

三种解决方案 #

方案1：给reverse方法的参数/返回值加上类限定

把reverse方法的签名改成用Link.Node来引用Node类，这样编译器就能找到它了：

public Link.Node reverse(Link.Node curr) {
    if (curr == null) return null;
    if (curr.next != null) {
        Link.Node newHead = reverse(curr.next);
        curr.next.next = curr;
        curr.next = null;
        return newHead;
    } else {
        return curr;
    }
}

同时main方法里调用的时候要传正确的参数：

first.head = reverse(first.head);
second.head = reverse(second.head);

方案2：把Node改成静态内部类

如果Node不需要访问Link类的实例成员（比如你的场景里Node只存data和next，不需要访问Link的head），可以把Node改成静态内部类：

public class Link {
    Node head;
    // 加static变成静态内部类
    public static class Node {
        int data;
        Node next;
        Node(int x) {
            data = x;
            next = null;
        }
    }
    // 其他方法不变
}

这样Node就属于Link类本身，而不是Link的实例，Solution类里的reverse方法可以直接用Node或者Link.Node来引用。

方案3：把reverse方法移到Link类内部（最推荐）

反转链表是和Link类强相关的操作，把reverse方法放到Link类内部最符合面向对象的封装原则，这样在Link内部可以直接访问Node类，不需要任何限定：

public class Link {
    Node head;
    public class Node {
        int data;
        Node next;
        Node(int x) {
            data = x;
            next = null;
        }
    }

    // 其他方法：printList、createList...

    // 把reverse方法放到Link类内部
    public Node reverse(Node curr) {
        if (curr == null) return null;
        // 递归终止：当前节点是最后一个，作为反转后的头
        if (curr.next == null) {
            return curr;
        }
        // 递归反转后续链表
        Node newHead = reverse(curr.next);
        // 调整指针指向
        curr.next.next = curr;
        curr.next = null;
        return newHead;
    }
}

调用的时候直接通过Link实例调用：

first.head = first.reverse(first.head);

额外的代码修正点 #

还有两个容易忽略的问题：

1. createList方法里，num.charAt(i)返回的是字符的ASCII值（比如'1'的ASCII是49），直接传给Node构造函数会存错值，要改成num.charAt(i) - '0'转换成对应的整数
2. Link是Solution的非静态内部类，在main方法里创建Link实例时，需要先创建Solution的实例：Solution solution = new Solution(); Link first = solution.new Link();

修正后的完整代码 #

import java.util.Scanner;

public class Solution {
    public class Link {
        Node head;

        public class Node {
            int data;
            Node next;

            Node(int x) {
                data = x;
                next = null;
            }
        }

        public void printList() {
            Node n = head;
            while (n != null) {
                System.out.print(n.data + " ");
                n = n.next;
            }
        }

        public void createList(String num) {
            // 修正：char转int要减去'0'
            this.head = new Node(num.charAt(0) - '0');
            Node prev = head;
            for (int i = 1; i < num.length(); i++) {
                Node newNode = new Node(num.charAt(i) - '0');
                prev.next = newNode;
                prev = newNode;
            }
        }

        public Node reverse(Node curr) {
            if (curr == null) return null;
            if (curr.next == null) {
                return curr;
            }
            Node newHead = reverse(curr.next);
            curr.next.next = curr;
            curr.next = null;
            return newHead;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String number1 = sc.next();
        String number2 = sc.next();

        // 非静态内部类需要通过外部类实例创建
        Solution solution = new Solution();
        Link first = solution.new Link();
        first.createList(number1);
        System.out.print("原链表1: ");
        first.printList();
        System.out.println("\n-------------------");

        Link second = solution.new Link();
        second.createList(number2);
        System.out.print("原链表2: ");
        second.printList();
        System.out.println("\n-------------------");

        first.head = first.reverse(first.head);
        System.out.print("反转后链表1: ");
        first.printList();
        System.out.println("\n-------------------");

        second.head = second.reverse(second.head);
        System.out.print("反转后链表2: ");
        second.printList();
        System.out.println("\n-------------------");

        sc.close();
    }
}

Java嵌套类访问规则总结 #

• 非静态内部类：必须依赖外部类实例，外部引用时用外部类.内部类，创建实例用外部类实例.new 内部类()
• 静态内部类：属于外部类本身，不需要外部实例，引用用外部类.内部类，创建实例用new 外部类.内部类()
• 辅助方法编写：优先把操作类内部结构的辅助方法放到类内部，既符合封装，又能直接访问内部成员；如果必须写在外部，一定要正确使用类限定名

内容的提问来源于stack exchange，提问作者Gopala Krishna