以上所有答案都说明了为什么静态方法很糟糕。它们是邪恶的原因是因为它给人一种错误的印象，即你在编写面向对象的代码，而事实上你并不是。 这简直是邪恶。

如果我必须在一个类中对一个函数进行10,000次调用，我会 很高兴使方法静态和使用直接 使用class.methodCall()来代替内存中10,000的混乱 类的实例，对吧?

您必须平衡将数据封装到具有状态的对象中的需求，以及简单地计算某些数据上的函数的结果的需求。

此外，静态减少了对代码其他部分的相互依赖。

封装也是如此。在大型应用程序中，静态方法往往会产生意大利面条式的代码，并且不容易进行重构或测试。

其他答案也为反对过度使用静态数据提供了很好的理由。

总结在Java中使用静态方法的几个基本优点和缺点:

优点:

全局可访问，即不与任何特定的对象实例绑定。 每个JVM一个实例。 可以通过类名访问(不需要对象)。 包含一个适用于所有实例的值。 在JVM启动时加载，并在JVM关闭时死亡。 它们不会修改Object的状态。

缺点:

Static members are always part of memory whether they are in use or not. You can not control creation and destruction of static variable. Usefully they have been created at program loading and destroyed when program unload (or when JVM shuts down). You can make statics thread safe using synchronize but you need some extra efforts. If one thread change value of a static variable that can possibly break functionality of other threads. You must know “static“ before using it. You cannot override static methods. Serialization doesn't work well with them. They don't participate in runtime polymorphism. There is a memory issue (to some extent but not much I guess) if a large number of static variables/methods are used. Because they will not be Garbage Collected until program ends. Static methods are hard to test too.

静态变量最重要的是会造成数据安全性问题(任何时间更改，任何人都可以更改，直接访问而不需要对象等)。

欲了解更多信息，请阅读这篇文章 谢谢。

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.

a)关于程序的原因。

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

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

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

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

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