将两个类合二为一

Question

我想弄清楚是否有一种方法将我的两个类组合成一个。我的程序只是一个循环链表，我必须使用尽可能少的类。我还希望一些帮助设置一个方法，让我用另一个节点替换一个节点。这是我的两门课，有什么想法吗?

第一个:

public class Node {
    static int numOfLists = 0;
    int data;
    Node nextNode;
    Node(int data) {
        this.data = data;
        numOfLists++;
    }
}

第二个:

public class LinkedList {
    // i = head
    // j = tail
    static Node i;
    static Node temp;
    static Node j;
    int num;
    Node nextNode;
    public void addNodes(int data) {
        Node node = new Node(data);
        if (j == null) {
            j = node;
            j.nextNode = j;
        } else {
            i = j;
            while (i.nextNode != j) {
                i = i.nextNode;
            }
            i.nextNode = node;
            node.nextNode = j;
        }
    }
    public void print() {
        i = j;
        boolean list = false;
        do {
            System.out.print((list) ? "--> |" + i.data + "|" : "|" + i.data
                + "|");
            list = true;
            i = i.nextNode;
        } while (i != j);
    }
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addNodes(3);
        list.addNodes(7);
        list.addNodes(2);
        list.addNodes(1);
        list.print();
    }
}

Answer 1

使用两个类是正确的方法。每个类都有不同的、定义良好的职责，这些应该是单独的类。不要把它们混在一起。当然可以，但那将是非常糟糕的OOP，所以不要这样做。

然而，Node是链表的实现细节，它确实不需要对链表的用户可见。因此，将Node移到链表类中作为静态内部类，并将其设置为私有。这样，它将不会从外部可见，遵循良好的封装和信息隐藏原则。

像这样(我也清理了剩下的代码):

public class CircularLinkedList {
    private static class Node {
        private final int data;
        private Node nextNode;
        private Node(int data) {
            this.data = data;
        }
    }
    private Node head;
    public void addNodes(int data) {
        Node node = new Node(data);
        if (head == null) {
            head = node;
            head.nextNode = head;
        } else {
            Node runner = head;
            while (runner.nextNode != head) {
                runner = runner.nextNode;
            }
            runner.nextNode = node;
            node.nextNode = head;
        }
    }
    public void print() {
        Node runner = head;
        boolean first = false;
        do {
            System.out.print((first) ? "--> |" + runner.data + "|" : "|" + runner.data + "|");
            first = true;
            runner = runner.nextNode;
        } while (runner != head);
    }
}

Answer 2

你可以使用嵌套类:

public class LinkedList {

    static public class Node {
        static int numOfLists = 0;
        int data;
        Node nextNode;
        Node(int data) {
            this.data = data;
            numOfLists++;
        }
    }
}

最好使用静态嵌套类。常规类的数量减少了一个，但我们现在有一个嵌套类。

Answer 3

如果您希望在添加新元素时跳过遍历整个列表，则可以使用此选项。你仍然有两个参考，一个是头，一个是尾。如果遍历列表没有问题，那么使用@janos的解决方案。

  public class LinkedList
  {
    Node head;
    Node tail;
    public void addNodes(int data) {
      Node node = new Node(data);
      if (head == null) {
        head = node;
        tail = node;
      } else {
        tail.nextNode = node;
        tail = node;
      }
    }
    public void print() {
      boolean first = true;
      Node currentNode = head;
      while (currentNode != null) {
        System.out.print(!first ? "--> |" + currentNode.data + "|" : "|" + currentNode.data + "|");
        first = false;
        currentNode = currentNode.nextNode;
      }
    }

    private static class Node
    {
      int numOfLists = 0;
      int data;
      Node nextNode;
      Node(int data) {
        this.data = data;
        numOfLists++;
      }
    }
   }