这是一篇好文章：http://javarevisited.blogspot.com.au/2013/03/difference-between-singleton-pattern-vs-static-class-java.html

静态类

具有所有静态方法的类。更好的性能（静态方法在编译时绑定）无法重写方法，但可以使用方法隐藏。（Java中隐藏的方法是什么？甚至JavaDoc的解释都令人困惑）公共级动物{公共静态void foo（）{System.out.println（“动物”）；}}公共课猫延伸动物{public static void foo（）｛//隐藏Animal.foo（）System.out.println（“类别”）；}}

辛格尔顿

只能实例化一次的对象。方法可以被重写（为什么Java不允许重写静态方法？）比静态方法更容易模拟更善于保持状态

总之，我只使用静态类来保存util方法，而使用Singleton来处理其他所有事情。

编辑

静态类也被延迟加载。谢谢@jmoreno（静态类初始化何时发生？）静态类的方法隐藏。谢谢@MaxPeng。

是什么让你说单例或静态方法都不是线程安全的？通常，这两者都应该实现为线程安全的。

单例和一堆静态方法之间的最大区别是，单例可以实现接口（或从有用的基类派生，尽管在我的经验中这不太常见），因此您可以将单例作为“另一个”实现来传递。

我不是一个伟大的OO理论家，但据我所知，我认为与Singleton相比，静态类唯一缺少的OO特性是多态性。但如果您不需要它，那么使用静态类，您当然可以继承（不确定接口实现）以及数据和函数封装。

Morendil的评论，“静态类中体现的设计风格纯粹是程序性的”我可能是错的，但我不同意。在静态方法中，您可以访问静态成员，这与单例方法访问其单个实例成员完全相同。

编辑：我现在实际上在想，另一个区别是，静态类在程序开始时被实例化，并且在整个程序的生命周期中都存在，而单例在某个时刻被显式实例化，也可以被销毁。

*或者它可能在第一次使用时被实例化，这取决于语言，我认为。

真正的答案是Jon Skeet在这里的另一个论坛上给出的。

单例允许访问单个已创建实例-该实例（或而是对该实例的引用）可以作为参数传递给其他方法，并视为正常对象静态类只允许静态方法。

主要区别在于：

Singleton有一个实例/对象，而静态类是一堆静态方法Singleton可以在静态时通过接口进行扩展班级不可能。Singleton可以继承，它支持另一方面，静态类不能继承SOLID原则我们需要自己做出改变。Singleton对象可以传递给方法，而静态类作为它没有实例不能作为参数传递

两者都可以在没有实例化的情况下调用，两者都只提供一个“实例”，而且都不是线程安全的。还有其他区别吗？

问题是错误的，这两种说法都是错误的。请注意：这里的静态类意味着嵌套的静态类，而不是只有静态方法的类。

我假设（即，静态类意味着嵌套的静态类，而不是只有静态成员的类），因为如果我看到最流行的Singleton实现，即DCL方式，它只不过是实例的静态声明和获取Singleton实例的静态方法。它是一个实现。那么在这种情况下，Singleton和只有静态成员的类之间有什么区别呢。尽管其他实现也是可能的，比如使用Enum。

让我纠正以下说法：

Singleton类可以具有单实例应用程序范围。嵌套的静态类可以有多个实例（请参阅下面的代码作为证明）。在这里阅读嵌套类的基础知识。没有一个类本质上是线程安全的，它必须通过编程实现线程安全。它既可以用于嵌套静态类，也可以用于Singleton。

下面是更多的神话故事（这个问题的大多数答案都给出了这些陈述，因此认为最好通过编程来证明这一点）：

嵌套的静态类可以像任何其他类一样实现接口。嵌套的静态类可以扩展其他非最终类。嵌套静态类可以具有实例变量。嵌套静态类可以具有参数化构造函数。

在下面的代码中，您可以看到嵌套的静态类NestedStaticClass实现了接口，扩展了另一个类，具有实例变量和参数化构造函数。

 package com.demo.core;

    public class NestedStaticClassTest
    {
        public static void main(String[] args)
        {
            OuterClass.NestedStaticClass obj1 = new OuterClass.NestedStaticClass();
            OuterClass.NestedStaticClass obj2 = new OuterClass.NestedStaticClass();

            if(obj1 == obj2)
            {
                System.out.println("Both nested static objects are equal....");
            }
            else
            {
                System.out.println("NOT EQUAL......");
            }

            System.out.println(OuterClass.NestedStaticClass.d);

            obj1.setD(5);

            System.out.println(OuterClass.NestedStaticClass.d);

            System.out.println(obj1.sum());
        }
    }

    class OuterClass
    {
        int a =1;
        static int b = 2;

        static class NestedStaticClass extends OneClass implements Sample
        {
            int c = 3;
            static int d = 4;

            public NestedStaticClass()
            {
            }

            //Parameterized constructor
            public NestedStaticClass(int z)
            {
                c = z;
            }

            public int sum()
            {
                int sum = 0;
                sum = b + c + d + getE();
                return sum;
            }

            public static int staticSum()
            {
                int sum = 0;
                sum = b + d;
                return sum;
            }

            public int getC()
            {
                return c;
            }
            public void setC(int c)
            {
                this.c = c;
            }
            public static int getD()
            {
                return d;
            }
            public static void setD(int d)
            {
                NestedStaticClass.d = d;
            }
        }
    }

    interface Sample
    {

    }

    class OneClass
    {
        int e = 10;
        static int f = 11;

        public int getE()
        {
            return e;
        }
        public void setE(int e)
        {
            this.e = e;
        }
        public static int getF()
        {
            return f;
        }
        public static void setF(int f)
        {
            OneClass.f = f;
        }

    }