有人可能会建议，在使用静态变量的大多数情况下，您确实希望使用单例模式。

全局状态的问题在于，有时在简单的上下文中作为全局是有意义的，但在实际的上下文中需要更加灵活，这就是单例模式变得有用的地方。

邪恶是一个主观的术语。

你不能从创建和破坏的角度来控制静态。他们按照程序的要求生活装卸。

由于静态对象存在于一个空间中，所有希望使用它们的线程都必须通过您必须管理的访问控制。这意味着程序更加耦合，这种变化更难想象和管理(就像J Skeet说的那样)。这导致了隔离变更影响的问题，从而影响了如何管理测试。

这是我对他们的两个主要问题。

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.

静态变量表示全局状态。这很难推理，也很难测试:如果我创建了一个对象的新实例，我就可以在测试中推理它的新状态。如果我使用使用静态变量的代码，它可以处于任何状态-任何东西都可以修改它。

我还可以继续讲很久，但更重要的概念是，事物的范围越窄，就越容易进行推理。我们擅长思考小事，但如果没有模块化，就很难推断出百万行系统的状态。顺便说一下，这适用于各种各样的东西——不仅仅是静态变量。

还有一个原因:脆弱性。

如果你有一个类，大多数人都希望能够随意创建和使用它。

您可以记录这种情况，或者防止这种情况发生(单例/工厂模式)——但这是额外的工作，因此需要额外的成本。 即使这样，在大公司中，也有可能有人在某些时候尝试使用您的类，而没有完全注意到所有好的评论或工厂。

如果你经常使用静态变量，它就会崩溃。虫子是昂贵的。

在0.0001%的性能改进和可能不了解的开发人员更改的健壮性之间，在很多情况下健壮性是不错的选择。

我玩过很多静力学，我可以给你一个稍微不同的答案——或者可能是稍微不同的看待它的方式吗?

当我在一个类中使用静态(成员和方法)时，我最终开始注意到我的类实际上是两个分担责任的类——“静态”部分很像单例，而非静态部分(普通类)。据我所知，你可以通过为一个类选择所有静态类，为另一个类选择所有非静态类来完全分离这两个类。

当我在一个类中有一个静态集合，其中包含类的实例和一些静态方法来管理集合时，这种情况经常发生。一旦你思考一下，很明显你的类不是在做“一件事”，它是一个集合，做一些完全不同的事情。

现在，让我们稍微重构一下这个问题:如果你把你的类分成一个类，其中所有的东西都是静态的，而另一个类只是一个“普通类”，然后忘记“普通类”，那么你的问题就变成了纯静态类vs单例，这是在这里详细讨论的(可能还有其他十几个问题)。