Java 所有声明为类变量的数组都应该是静态的吗？

我正在尝试编写一个代码，分别使用类的两个不同对象递增声明为类变量的整数数组

class Foo {
    int n[];

    Foo(int n1[], int x, int y) {
        n = new int[]{0, 0, 0, 0};
        n1[0] = n1[0] + x;
        n1[1] = n1[1] + y;
        this.n = n1;
    }
}

public class stats {
    public static void print(Foo obj) {
        for (int i = 0; i < obj.n.length; i++) {
            System.out.println(obj.n[i]);
        }
    }

    public static void main(String[] args) {
        int n[] = {1, 1, 1, 1};
        Foo a = new Foo(n, 1, 1);

        Foo b = new Foo(n, 2, 2);
        print(a);
        print(b);

    }
}

实际产量

4
4
1
1
4
4
1
1

尽管没有将变量声明为静态变量，但它还是将对象中的数组作为静态变量递增，这有什么原因吗？每个整数数组都声明为类变量静态吗？我将如何获得预期的输出？

重要的部分是这个。n=n1；。 这意味着两个对象都引用了您在主方法中创建的同一数组n。

在Foo参数中，您将新值写入n1参数，该参数与主方法中n引用的数组相同

---

您在构造函数中分配了一个新数组，但您从未实际使用过它，并且在构造函数的最后一行中用这个来覆盖对它的引用。n=n1。

a和b都递增同一数组的原因是因为您都将n传递给了这两个数组。类中保存的变量不是实际的数组，而是对数组的内存引用。因此，由于您已将相同的内存引用n传递给两个对象，因此它们都在修改内存的相同部分。它与静电几乎没有关系。如果希望它们都有不同的数组，则必须创建n的一个副本，以便在内存中有两个分开的数组。

这是因为引用没有将数组的副本传递给Foo的构造函数

在您的主要功能中：

数组已声明

int n[] = {1, 1, 1, 1};

//下一个语句将把n的值更改为{2,2,1,1}，这个数组将保存在Foo类中

Foo a = new Foo(n, 1, 1); 

//现在记住主方法中n的值是{2,2,1,1}

Foo b = new Foo(n, 2, 2);  // Here n = {2,2,1,1}

---

在上述语句之后，主方法中的n变成{4,4,1,1}

this.n=n1；用参数n1的数组对象覆盖字段n；在类Foo中声明的是实例变量，而不是类变量。类变量是用static关键字声明的。它是否只指向数组的内存引用？我注意到，当我将它与int一起使用时，它指向的是值，而内存引用案例不适用于int和char以及其他基本类型，因为这些类型是不可变的。如果将int传递给修改它的函数，则传递的int将被复制，以便保留其原始值。但是，对于所有对象，变量实际上是指为堆栈上的对象分配的内存。

Foo b = new Foo(n, 2, 2);  // Here n = {2,2,1,1}