Java 在Util类中使用私有静态字段是否不好？

假设我在util类中有一个方法，该方法中有一个无法更改的参数，因为它会更改结果并需要以某种方式保存。在util类中有一个

私有静态

字段会是一种不好的做法吗？如果是，如何正确操作

我的意思是：

公共类Util{
私有静态最终整数[]向量1备份=新整数[3]；
私有静态最终int[]向量2backup=new int[3]；
私有Util（）{
}
公共静态无效操作（int[]vector1、int[]vector2、int[]result）{
//在vecto1或vector2=result的情况下需要备份
向量1备份[0]=向量1[0]；
向量1备份[1]=向量1[1]；
向量1备份[2]=向量1[2]；
向量2备份[0]=向量2[0]；
向量2备份[1]=向量2[1]；
向量2备份[2]=向量2[2]；
结果[0]=向量1备份[0]+向量2备份[2]；
结果[1]=向量1备份[1]+向量2备份[1]；
结果[2]=向量1备份[2]+向量2备份[0]；
}
}

---

编辑：只有一个线程存在

一般来说，使用私有常量并不坏。隐藏类的内部是可以的，在OOP中我们称之为封装。但是我觉得你的代码应该修改一下

1） 就我个人而言，我完全反对静态方法，因为它们不遵循OOP，并且使测试更加困难。然而，很多库和java本身都有很多库。我想这是口味的问题。如果您喜欢静态方法，则应该将其设置为无状态，这意味着不在类中存储任何内容，只需基于vector1和vector2创建结果并从方法返回

2） 在静态类中存储某些内容有点容易出错。我只需要创建单独的类，并将其称为VectorBackup。在那个类中，我会像你们一样存储向量。然后，您可以创建所需数量的实例（备份）。它将是线程安全的（在一定程度上）并且更像OOP。如果你有3个向量而不是2个向量，那么修改代码也会更容易

3） 常量类应该有私有构造函数，并且它们应该是

final

，所以没有人可以扩展它们

public final class Util {

    private Util() {
    }

    public static void doOperation(int[] vector1, int[] vector2) {
        int[] result = new int[3];
        result[0] = vector1[0] + vector2[2];
        result[1] = vector1[1] + vector2[1];
        result[2] = vector1[2] + vector2[0];
        return result;
    }

}


public class Backup {

    private final int[] vectorBackup = new int[3];

    public Backup(int[] vector) {
        vectorBackup[0] = vector[0];
        vectorBackup[1] = vector[1];
        vectorBackup[2] = vector[2];
    }

    public int[] restore(){
     //some code to create vector from backup
    }

}

---

拥有私有常量是一种不错的做法

但在您的例子中，有一个私有字段，比如缓冲区。此外，还可以执行所谓的就地操作，更改

result

array的值

如果我是你，我会创建一个返回结果的函数

int[] doOperation(int[] vector1, int[] vector2){
  int[] result = new int[vector1.length];
  // do your logic
  return result;
}

---

如果两个线程同时调用方法

doOperation

，会发生什么情况？@KevinO我认为更好的问题是，什么不会发生太糟糕了。Util类不应保持状态。在单个方法中处理所有内容，或者构建一个计算器对象，在该对象中，您只需使用一次即可进行计算（创建对象、执行计算、销毁对象）。不修改的私有静态最终字段也可以。私有静态可变字段是一个主要的代码气味。只要它的单线程字段和你的字段被用作计算的临时结构，我看不出有什么问题。还有其他库也以同样的方式工作。例如LibGDX。它使用临时向量和矩阵进行计算，以防止实例化过多。