对链接列表使用私有类的正确方法

Question

I'm studying data structure. While studying a linked list, I wonder if this is good practice or not. Here is my code:

class LinkedListStack {
    // <-- Node
    private class Node { // I made a private class!
        private int data;
        private Node next;

        public Node(int data) {
            this.data = data;
        }

        public int getData() {
            return data;
        }
        public void setData(int data) {
            this.data = data;
        }
        public Node getNext() {
            return next;
        }
        public void setNext(Node next) {
            this.next = next;
        }
    }
    // Node -->
    // <-- Logic

    private Node headNode = null;

    public int top() {
        if(headNode == null) {
            System.out.println("Empty stack");
            return 0;
        }
        else {
            return headNode.getData();
        }
    }
 ...

Actually, I usually make the node class outside of the class LinkedListStack - but is it okay to make private class Node ? The problem I have found is that in the method top() , I can access the variable data and next directly . Is there any way to prevent from accessing the local variables (data, next) of the class Node in the class LinkedListStack? Also, I'd like to know 'real' examples of a private class. When do actually people use a private class in the real world? And why do we need it?

Answer 1

The problem I have found is that in the method top() , I can access the variable data and next directly.

It's not a problem, it's a feature. Java lets your outer class access private methods and fields of its inner class, even when the class and all its fields are private .

The rationale for that is that a nested class is part of your own class implementation, so both classes have access to each others' private members.

I usually make the node class outside of the class LinkedListStack

When a nested class looks like a class that can be defined outside your class, it's a good indication that the class should be made static, like this:

private static class Node {
    ...
}

This is because non-static nested classes have implicit references to an object of their outer class - LinkedListStack in your case, which the Node class does not need.

Answer 2

If you implement it with an inner class, there is no way to prevent the parent class to see the private fields of it. Fortunately, it's no use doing so. An inner class is perfectly fine here, see for example the implementation of java.util.HashMap that uses (in JDK8 at least) an inner class called Node used to represent linked lists.

Actually, a Node alone would have no meaning, that's why it is better practice to hide it as a private inner class.

Answer 3

From outer class you can access private variable of inner class.Nothing much you can do there.

Private inner class is used when we can be sure from design perspective that the private inner class will not be used outside the enclosing class. For LinkedList Node doesn't seem correct as private because in some other code you would like to reference Node Object in the LinkedList.

As @Dici has suggested in comments that it can be used as private. Only if you next() method return the data in the Node and not the Node itself. You can see this private Node class in LinkedList JDK implementation . However if you wish to manipulate Node object outside of the enclosing class it should not be private.