在我看来，这与性能无关，而是与设计有关。我不认为使用静态方法和使用静态变量是错误的(但我猜你实际上是在谈论方法调用)。

它只是关于如何分离逻辑并给它一个好的位置。有时这证明使用静态方法是正确的，java.lang.Math就是一个很好的例子。我认为，当您将大多数类命名为XxxUtil或Xxxhelper时，您最好重新考虑您的设计。

在我看来，这与性能无关，而是与设计有关。我不认为使用静态方法和使用静态变量是错误的(但我猜你实际上是在谈论方法调用)。

它只是关于如何分离逻辑并给它一个好的位置。有时这证明使用静态方法是正确的，java.lang.Math就是一个很好的例子。我认为，当您将大多数类命名为XxxUtil或Xxxhelper时，您最好重新考虑您的设计。

a)关于程序的原因。

如果你有一个小型到中型的程序，其中静态变量Global。Foo被访问，对它的调用通常不知道从哪里来——没有路径，因此也没有时间轴，变量是如何到达这个地方的，它在哪里被使用。现在我怎么知道是谁设置了它的实际值呢?如果我现在修改它，我怎么知道会发生什么呢?我让grep覆盖整个源代码，收集所有访问，知道发生了什么。

如果你知道如何使用它，因为你只是写了代码，问题是看不见的，但如果你试着理解外国代码，你就会明白。

b)你真的只需要一个吗?

静态变量通常会阻止相同类型的多个程序在相同JVM中运行，但它们的值不同。您通常无法预见在哪些情况下您的程序的多个实例是有用的，但是如果它发展了，或者如果它对其他人有用，他们可能会遇到这样的情况，他们想要启动您的程序的多个实例。

只有那些在较长时间内不会被很多人密集使用的或多或少无用的代码才可能适合使用静态变量。

我只是对回答中的一些观点进行了总结。如果你发现任何错误，请随时改正。

伸缩性:每个JVM只有一个静态变量实例。假设我们正在开发一个图书馆管理系统，我们决定将book的名称作为一个静态变量，因为每本书只有一个。但是如果系统增长了，我们使用了多个jvm，那么我们就没有办法知道我们在处理哪本书了?

线程安全:在多线程环境中使用实例变量和静态变量都需要控制。但对于实例变量，它不需要保护，除非它在线程之间显式地共享，但对于静态变量，它总是由进程中的所有线程共享。

测试:虽然可测试的设计并不等于好的设计，但我们很少会看到一个好的设计是不可测试的。由于静态变量代表全局状态，因此测试它们非常困难。

关于状态的推理:如果我创建一个类的新实例，那么我们可以推理这个实例的状态，但如果它有静态变量，那么它可以处于任何状态。为什么?因为静态变量可能已经被一些不同的实例修改过，因为静态变量是跨实例共享的。

序列化:序列化也不能很好地与它们一起工作。

创建和销毁:静态变量的创建和销毁是无法控制的。通常它们在程序加载和卸载时被创建和销毁。这意味着它们不利于内存管理，还会在启动时增加初始化时间。

但如果我们真的需要它们呢?

但有时我们可能真的需要它们。如果我们真的觉得需要在应用程序中共享许多静态变量，那么一种选择是使用单例设计模式，它将拥有所有这些变量。或者我们可以创建一些对象，它有这些静态变量，可以被传递。

同样，如果静态变量被标记为final，它就变成了一个常量，赋给它一次的值就不能改变了。这意味着它将把我们从由于其可变性而面临的所有问题中拯救出来。

Its not very object oriented: One reason statics might be considered "evil" by some people is they are contrary the object-oriented paradigm. In particular, it violates the principle that data is encapsulated in objects (that can be extended, information hiding, etc). Statics, in the way you are describing using them, are essentially to use them as a global variable to avoid dealing with issues like scope. However, global variables is one of the defining characteristics of procedural or imperative programming paradigm, not a characteristic of "good" object oriented code. This is not to say the procedural paradigm is bad, but I get the impression your supervisor expects you to be writing "good object oriented code" and you're really wanting to write "good procedural code".

在Java中，当您开始使用静态时，有许多并不总是立即明显的陷阱。例如，如果在同一个VM中运行两个程序副本，它们会共享静态变量的值并混淆彼此的状态吗?或者当你扩展类时会发生什么，你能重写静态成员吗?您的虚拟机内存不足，因为您有疯狂的静态数据，并且内存不能为其他需要的实例对象回收?

Object Lifetime: Additionally, statics have a lifetime that matches the entire runtime of the program. This means, even once you're done using your class, the memory from all those static variables cannot be garbage collected. If, for example, instead, you made your variables non-static, and in your main() function you made a single instance of your class, and then asked your class to execute a particular function 10,000 times, once those 10,000 calls were done, and you delete your references to the single instance, all your static variables could be garbage collected and reused.

防止某些重复使用: 此外，静态方法不能用于实现接口，因此静态方法会阻止某些面向对象的特性的可用性。

Other Options: If efficiency is your primary concern, there might be other better ways to solve the speed problem than considering only the advantage of invocation being usually faster than creation. Consider whether the transient or volatile modifiers are needed anywhere. To preserve the ability to be inlined, a method could be marked as final instead of static. Method parameters and other variables can be marked final to permit certain compiler optimiazations based on assumptions about what can change those variables. An instance object could be reused multiple times rather than creating a new instance each time. There may be compliler optimization switches that should be turned on for the app in general. Perhaps, the design should be set up so that the 10,000 runs can be multi-threaded and take advantage of multi-processor cores. If portablity isn't a concern, maybe a native method would get you better speed than your statics do.

If for some reason you do not want multiple copies of an object, the singleton design pattern, has advantages over static objects, such as thread-safety (presuming your singleton is coded well), permitting lazy-initialization, guaranteeing the object has been properly initialized when it is used, sub-classing, advantages in testing and refactoring your code, not to mention, if at some point you change your mind about only wanting one instance of an object it is MUCH easier to remove the code to prevent duplicate instances than it is to refactor all your static variable code to use instance variables. I've had to do that before, its not fun, and you end up having to edit a lot more classes, which increases your risk of introducing new bugs...so much better to set things up "right" the first time, even if it seems like it has its disadvantages. For me, the re-work required should you decide down the road you need multiple copies of something is probably one of most compelling reasons to use statics as infrequently as possible. And thus I would also disagree with your statement that statics reduce inter-dependencies, I think you will end up with code that is more coupled if you have lots of statics that can be directly accessed, rather than an object that "knows how to do something" on itself.

静态变量有两个主要问题:

线程安全——静态资源根据定义不是线程安全的 代码隐式——你不知道一个静态变量何时被实例化，也不知道它是否会在另一个静态变量之前被实例化