我发现了一个很好的描述，当使用静态方法:

没有硬性的、写得很好的规则来决定什么时候使一个方法静态或非静态，但是有一些基于经验的观察，这不仅有助于使一个方法静态，而且还教会了什么时候在Java中使用静态方法。你应该考虑在Java中让一个方法是静态的:

If a method doesn't modify state of object, or not using any instance variables. You want to call method without creating instance of that class. A method is good candidate of being static, if it only work on arguments provided to it e.g. public int factorial(int number){}, this method only operate on number provided as argument. Utility methods are also good candidate of being static e.g. StringUtils.isEmpty(String text), this a utility method to check if a String is empty or not. If function of method will remain static across class hierarchy e.g. equals() method is not a good candidate of making static because every Class can redefine equality.

来源在这里

当您不想在代码中创建对象来调用方法时，只需将该方法声明为静态方法。因为静态方法不需要调用实例，但这里的问题是，并不是所有的静态方法都由JVM自动调用。此特权仅由main()节点享有。“public static void main[字符串…]方法，因为在运行时，这是方法Signature public“static”void main[]， JVM寻求作为开始执行代码的入口点。

例子:

public class Demo
{
   public static void main(String... args) 
   {
      Demo d = new Demo();

      System.out.println("This static method is executed by JVM");

     //Now to call the static method Displ() you can use the below methods:
           Displ(); //By method name itself    
      Demo.Displ(); //By using class name//Recommended
         d.Displ(); //By using instance //Not recommended
   }

   public static void Displ()
   {
      System.out.println("This static method needs to be called explicitly");
   }
} 

输出: 这个静态方法由JVM执行 这个静态方法需要显式调用 这个静态方法需要显式调用 这个静态方法需要显式调用

使用静态方法有一些合理的理由:

Performance: if you want some code to be run, and don't want to instantiate an extra object to do so, shove it into a static method. The JVM also can optimize static methods a lot (I think I've once read James Gosling declaring that you don't need custom instructions in the JVM, since static methods will be just as fast, but couldn't find the source - thus it could be completely false). Yes, it is micro-optimization, and probably unneeded. And we programmers never do unneeded things just because they are cool, right? Practicality: instead of calling new Util().method(arg), call Util.method(arg), or method(arg) with static imports. Easier, shorter. Adding methods: you really wanted the class String to have a removeSpecialChars() instance method, but it's not there (and it shouldn't, since your project's special characters may be different from the other project's), and you can't add it (since Java is somewhat sane), so you create an utility class, and call removeSpecialChars(s) instead of s.removeSpecialChars(). Sweet. Purity: taking some precautions, your static method will be a pure function, that is, the only thing it depends on is its parameters. Data in, data out. This is easier to read and debug, since you don't have inheritance quirks to worry about. You can do it with instance methods too, but the compiler will help you a little more with static methods (by not allowing references to instance attributes, overriding methods, etc.).

如果你想创建一个单例，你还必须创建一个静态方法，但是…不喜欢。我的意思是，三思而后行。

更重要的是，为什么不想创建静态方法?基本上，多态被抛在了脑后。你不能重写这个方法，也不能在接口中声明它(在java 8之前)。这给你的设计带来了很大的灵活性。此外，如果您需要状态，如果您不小心，您将以大量并发错误和/或瓶颈告终。

静态方法不需要在对象上调用，这就是你使用它的时候。例如:你的Main()是一个静态的，你没有创建一个对象来调用它。

静态方法应该在类上调用，实例方法应该在类的实例上调用。但这在现实中意味着什么呢?下面是一个有用的例子:

car类可能有一个名为Accelerate()的实例方法。你只能加速一个汽车，如果汽车确实存在(已经构造)，因此这将是一个实例方法。

car类也可能有一个名为GetCarCount()的计数方法。这将返回创建(或构造)的汽车总数。如果没有构造汽车，这个方法将返回0，但它仍然可以被调用，因此它必须是一个静态方法。

在阅读了Misko的文章之后，我相信静态方法从测试的角度来看是不好的。相反，您应该使用工厂(可能使用像Guice这样的依赖注入工具)。

我如何确保我只有一个东西

只吃一种 问题是"我如何确保我 只吃一种东西”是很好的 回避了。实例化一个 单个ApplicationFactory在你的 主要的，结果，只有你 实例化所有的单个实例 你的独生子女。

静态方法的基本问题是它们是过程代码

静态方法的基本问题是 它们是过程代码。我没有 知道如何对过程代码进行单元测试。 单元测试假设我可以 实例化我的应用程序的一部分 在隔离。在实例化过程中 我将依赖项与 mock /友军替换 真正的依赖关系。与程序 编程没有什么可以“连接”的 由于没有对象，代码 数据是分开的。