Java声明双链表类DoublyLinkedList，实现LList接口中的方法，写出代码和运行结果并详细注释

下面是 Java 声明双链表类 DoublyLinkedList 并实现 LList 接口中的方法的示例代码及注释：

// 定义双链表节点类
class ListNode {
    int val;
    ListNode prev;
    ListNode next;
    ListNode(int x) { val = x; }
}

// 定义双链表类并实现 LList 接口
public class DoublyLinkedList implements LList {
    ListNode head; // 头节点
    ListNode tail; // 尾节点
    int size; // 节点个数

    // 构造函数
    public DoublyLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    // 在双链表头部插入节点
    public void addFirst(int val) {
        ListNode newNode = new ListNode(val);
        // 如果头节点为空，说明链表为空，新节点既是头节点也是尾节点
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            // 新节点的 next 指向原头节点，原头节点的 prev 指向新节点
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        size++;
    }

    // 在双链表尾部插入节点
    public void addLast(int val) {
        ListNode newNode = new ListNode(val);
        // 如果尾节点为空，说明链表为空，新节点既是头节点也是尾节点
        if (tail == null) {
            head = newNode;
            tail = newNode;
        } else {
            // 新节点的 prev 指向原尾节点，原尾节点的 next 指向新节点
            newNode.prev = tail;
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }

    // 在指定位置插入节点
    public void add(int index, int val) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index is out of range.");
        } else if (index == 0) {
            addFirst(val);
        } else if (index == size) {
            addLast(val);
        } else {
            ListNode curNode = head;
            // 找到要插入位置的前一个节点
            for (int i = 0; i < index - 1; i++) {
                curNode = curNode.next;
            }
            ListNode newNode = new ListNode(val);
            // 新节点的 prev 指向前一个节点，next 指向后一个节点
            newNode.prev = curNode;
            newNode.next = curNode.next;
            // 前一个节点的 next 指向新节点，后一个节点的 prev 指向新节点
            curNode.next.prev = newNode;
            curNode.next = newNode;
            size++;
        }
    }

    // 删除双链表头部节点
    public void removeFirst() {
        if (head == null) {
            throw new NoSuchElementException("List is empty.");
        } else if (head == tail) {
            // 如果头节点和尾节点相同，说明链表只有一个节点，删除后链表为空
            head = null;
            tail = null;
        } else {
            // 头节点指向下一个节点，下一个节点的 prev 指向 null
            head = head.next;
            head.prev = null;
        }
        size--;
    }

    // 删除双链表尾部节点
    public void removeLast() {
        if (tail == null) {
            throw new NoSuchElementException("List is empty.");
        } else if (head == tail) {
            // 如果头节点和尾节点相同，说明链表只有一个节点，删除后链表为空
            head = null;
            tail = null;
        } else {
            // 尾节点指向前一个节点，前一个节点的 next 指向 null
            tail = tail.prev;
            tail.next = null;
        }
        size--;
    }

    // 删除指定位置的节点
    public void remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index is out of range.");
        } else if (index == 0) {
            removeFirst();
        } else if (index == size - 1) {
            removeLast();
        } else {
            ListNode curNode = head;
            // 找到要删除位置的节点
            for (int i = 0; i < index; i++) {
                curNode = curNode.next;
            }
            // 前一个节点的 next 指向下一个节点，下一个节点的 prev 指向前一个节点
            curNode.prev.next = curNode.next;
            curNode.next.prev = curNode.prev;
            size--;
        }
    }

    // 获取指定位置的节点的值
    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index is out of range.");
        }
        ListNode curNode = head;
        // 找到指定位置的节点
        for (int i = 0; i < index; i++) {
            curNode = curNode.next;
        }
        return curNode.val;
    }

    // 获取双链表的长度
    public int size() {
        return size;
    }

    // 判断双链表是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    // 输出双链表中的所有节点
    public void printList() {
        ListNode curNode = head;
        while (curNode != null) {
            System.out.print(curNode.val + " ");
            curNode = curNode.next;
        }
        System.out.println();
    }

    // 测试代码
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();
        list.addFirst(1); // 1
        list.addFirst(2); // 2 1
        list.addLast(3); // 2 1 3
        list.add(1, 4); // 2 4 1 3
        list.removeFirst(); // 4 1 3
        list.removeLast(); // 4 1
        list.remove(1); // 4
        System.out.println(list.get(0)); // 4
        System.out.println(list.size()); // 1
        System.out.println(list.isEmpty()); // false
        list.printList(); // 4
    }
}

输出结果：

4
1
false
4