Singleton类在应用程序生命周期期间提供一个对象（仅一个实例），例如java.lang.Runtime而静态类只提供静态方法，如java.lang.MathJava中的静态方法不能被重写，但Singleton类中定义的方法可以通过扩展来重写。Singleton类能够继承和多态性来扩展基类、实现接口并能够提供不同的实现。而不是静态的。

例如：java.lang.Runtime是java中的Singleton类，调用getRuntime（）方法返回与当前java应用程序关联的运行时对象，但确保每个JVM只有一个实例。

延迟加载支持接口，以便提供单独的实现能够返回派生类型（作为lazyloading和接口实现的组合）

我阅读了以下内容，认为这也很有意义：

打理业务记住，最重要的OO规则之一是对象对自己负责。这意味着关于类的生命周期的问题应该在类中处理，而不是委托给静态等语言构造。

来自《面向对象的思维过程》第四版。

静态类不适用于任何需要状态的对象。它对于将一堆函数放在一起非常有用，例如Math（或项目中的Utils）。所以类名只是给了我们一个线索，我们可以在哪里找到函数，而不是更多。

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;
        }

    }