Java链表实现中的静态字段陷阱与正确实践

public class MyLinkedList {
    static Node first; // 静态字段
    static Node last;  // 静态字段
    static int size = 0; // 静态字段

    public MyLinkedList() {
        first = null;
        last = null;
        size = 0;
    }

    public static void insertLast(int x, int y) { // 静态方法
        Node newNode = new Node(x, y);
        if (first == null) {
            first = newNode;
            last = newNode;
        } else {
            last.next = newNode;
            last = newNode;
        }
        size++;
    }

    // Node类定义（假设存在）
    static class Node {
        int coef;
        int power;
        Node next;

        public Node(int coef, int power) {
            this.coef = coef;
            this.power = power;
            this.next = null;
        }
    }

    public String toString() {
        Node tmp = first;
        String str = "";
        while (tmp != null) {
            str += tmp.coef + "x^" + tmp.power + "->";
            tmp = tmp.next;
        }
        return str;
    }
}

MyLinkedList ml = new MyLinkedList(); // 第一次初始化 MyLinkedList 类的静态字段
// 添加节点到 ml
MyLinkedList ml2 = new MyLinkedList(); // 再次初始化 MyLinkedList 类的静态字段
// 添加节点到 ml2

public class MyLinkedList {
    // 移除 static 修饰符，使它们成为实例变量
    private Node first; 
    private Node last;
    private int size;

    // 内部类 Node 最好也定义为非静态的，或者至少是 private static 的
    // 但如果 Node 依赖于 MyLinkedList 的实例状态，则不应是静态的
    // 在这里，Node 是链表结构的基本单元，可以定义为内部类，或者单独的公共类
    // 为了简化，我们假设它是一个独立的非静态内部类
    public static class Node { // 可以是静态内部类，因为不直接访问MyLinkedList的实例成员
        int coef;
        int power;
        Node next;

        public Node(int coef, int power) {
            this.coef = coef;
            this.power = power;
            this.next = null;
        }
    }

    public MyLinkedList() {
        this.first = null; // 使用 this 关键字明确指向当前实例的字段
        this.last = null;
        this.size = 0;
    }

    // 移除 static 修饰符，使它成为实例方法
    public void insertLast(int x, int y) {
        Node newNode = new Node(x, y);
        if (this.first == null) {
            this.first = newNode;
            this.last = newNode;
        } else {
            this.last.next = newNode;
            this.last = newNode;
        }
        this.size++;
    }

    public String toString() {
        Node tmp = this.first; // 访问当前实例的 first 字段
        String str = "";

        while (tmp != null) {
            str += tmp.coef + "x^" + tmp.power + "->";
            tmp = tmp.next;
        }
        // 如果链表为空，返回一个有意义的字符串
        if (str.isEmpty()) {
            return "Empty List";
        }
        return str;
    }

    // 可以添加获取链表大小的方法
    public int size() {
        return this.size;
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);

        MyLinkedList ml = new MyLinkedList();
        System.out.println("Enter the coefficient and power of the first polynomial. Type 0 at the end:");
        int coefficient, degree;
        while (true) {
            coefficient = scn.nextInt();
            degree = scn.nextInt();
            if (coefficient == 0 && degree == 0) { // 假设输入 0 0 表示结束
                break;
            }
            ml.insertLast(coefficient, degree);
        }
        System.out.println("First polynomial: " + ml.toString());

        MyLinkedList ml2 = new MyLinkedList();
        System.out.println("Enter the coefficient and power of the second polynomial. Type 0 at the end:");
        int coef, deg;
        while (true) {
            coef = scn.nextInt();
            deg = scn.nextInt();
            if (coef == 0 && deg == 0) { // 假设输入 0 0 表示结束
                break;
            }
            ml2.insertLast(coef, deg);
        }
        System.out.println("Second polynomial: " + ml2.toString());

        // 示例：可以进行加法、乘法等操作
        // MyLinkedList sumList = addPolynomials(ml, ml2);
        // System.out.println("Sum: " + sumList.toString());

        scn.close();
    }

    // 辅助方法，例如多项式加法（此处仅为示例，未实现具体逻辑）
    /*
    public static MyLinkedList addPolynomials(MyLinkedList p1, MyLinkedList p2) {
        MyLinkedList result = new MyLinkedList();
        // 实现加法逻辑
        return result;
    }
    */
}