嵌套静态类的使用有一个微妙之处，这在某些情况下可能很有用。

尽管静态属性在类通过其构造函数实例化之前被实例化，嵌套静态类内部的静态属性似乎在类的构造函数被调用，或者至少直到属性被首次引用之后，即使它们被标记为“最终”。

考虑以下示例：

public class C0 {

    static C0 instance = null;

    // Uncomment the following line and a null pointer exception will be
    // generated before anything gets printed.
    //public static final String outerItem = instance.makeString(98.6);

    public C0() {
        instance = this;
    }

    public String makeString(int i) {
        return ((new Integer(i)).toString());
    }

    public String makeString(double d) {
        return ((new Double(d)).toString());
    }

    public static final class nested {
        public static final String innerItem = instance.makeString(42);
    }

    static public void main(String[] argv) {
        System.out.println("start");
        // Comment out this line and a null pointer exception will be
        // generated after "start" prints and before the following
        // try/catch block even gets entered.
        new C0();
        try {
            System.out.println("retrieve item: " + nested.innerItem);
        }
        catch (Exception e) {
            System.out.println("failed to retrieve item: " + e.toString());
        }
        System.out.println("finish");
    }
}

即使“nested”和“innerItem”都声明为“static final”。设置nested.innerItem的值在类实例化后才会发生（或至少直到第一次引用嵌套的静态项之后），正如您自己所看到的通过注释和取消注释上面提到的行。这一点不成立对于“outerItem”为true。

至少这是我在Java6.0中看到的。

嵌套类是一个非常通用的术语：每个不是顶级的类都是嵌套类。内部类是非静态嵌套类。约瑟夫·达西写了一篇关于嵌套、内部、成员和顶级课程的非常好的解释。

我认为，通常遵循的惯例是：

顶级类中的静态类是嵌套类顶级类中的非静态类是内部类还有两种形式：本地类-在块（如方法或构造函数体）内部声明的类匿名类-在表达式和语句中创建实例的未命名类

然而，需要记住的其他几点是：

顶级类和静态嵌套类在语义上是相同的，只是在静态嵌套类的情况下，它可以对其外部〔父〕类的私有静态字段/方法进行静态引用，反之亦然。内部类可以访问外部[父]类的封闭实例的实例变量。然而，并不是所有的内部类都有封闭实例，例如静态上下文中的内部类，比如静态初始值设定项块中使用的匿名类。默认情况下，匿名类扩展父类或实现父接口，并且没有进一步的子句来扩展任何其他类或实现任何其他接口。所以新建YourClass（）｛｝；意味着类〔Anonymous〕扩展了YourClass｛｝新建YourInterface（）｛｝；表示类〔Anonymous〕实现YourInterface｛｝

我觉得还有一个更大的问题，那就是什么时候使用？这主要取决于你正在处理的场景，但阅读@jrudolph给出的回复可能会帮助你做出一些决定。

嵌套静态类的使用有一个微妙之处，这在某些情况下可能很有用。

尽管静态属性在类通过其构造函数实例化之前被实例化，嵌套静态类内部的静态属性似乎在类的构造函数被调用，或者至少直到属性被首次引用之后，即使它们被标记为“最终”。

考虑以下示例：

public class C0 {

    static C0 instance = null;

    // Uncomment the following line and a null pointer exception will be
    // generated before anything gets printed.
    //public static final String outerItem = instance.makeString(98.6);

    public C0() {
        instance = this;
    }

    public String makeString(int i) {
        return ((new Integer(i)).toString());
    }

    public String makeString(double d) {
        return ((new Double(d)).toString());
    }

    public static final class nested {
        public static final String innerItem = instance.makeString(42);
    }

    static public void main(String[] argv) {
        System.out.println("start");
        // Comment out this line and a null pointer exception will be
        // generated after "start" prints and before the following
        // try/catch block even gets entered.
        new C0();
        try {
            System.out.println("retrieve item: " + nested.innerItem);
        }
        catch (Exception e) {
            System.out.println("failed to retrieve item: " + e.toString());
        }
        System.out.println("finish");
    }
}

即使“nested”和“innerItem”都声明为“static final”。设置nested.innerItem的值在类实例化后才会发生（或至少直到第一次引用嵌套的静态项之后），正如您自己所看到的通过注释和取消注释上面提到的行。这一点不成立对于“outerItem”为true。

至少这是我在Java6.0中看到的。

我认为这里没有什么要补充的，大多数答案完美地解释了静态嵌套类和内部类之间的区别。但是，当使用嵌套类与内部类时，请考虑以下问题。正如在两个答案中提到的，如果没有封闭类的实例，内部类就无法实例化，这意味着它们持有指向封闭类实例的指针，这可能导致内存溢出或堆栈溢出异常，因为即使不再使用封闭类，GC也无法对其进行垃圾收集。要明确这一点，请检查以下代码：

public class Outer {


    public  class Inner {

    }


    public Inner inner(){
        return new Inner();
    }

    @Override
    protected void finalize() throws Throwable {
    // as you know finalize is called by the garbage collector due to destroying an object instance
        System.out.println("I am destroyed !");
    }
}


public static void main(String arg[]) {

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

    // out instance is no more used and should be garbage collected !!!
    // However this will not happen as inner instance is still alive i.e used, not null !
    // and outer will be kept in memory until inner is destroyed
    outer = null;

    //
    // inner = null;

    //kick out garbage collector
    System.gc();

}

如果删除//inner=null；该计划将付诸实施“我被摧毁了！”，但保持评论不会。原因是白色内部实例仍然被引用，GC无法收集它，并且因为它引用（具有指向）外部实例，所以它也没有被收集。项目中有足够的这些对象，可能会耗尽内存。与静态内部类相比，静态内部类不指向内部类实例，因为它与实例无关，而是与类相关。如果将Inner类设置为静态并使用Outer.Inner I=newOuter.Innr（）实例化，则上述程序可以打印“我被摧毁了！”；

以下是静态嵌套类和内部类的示例：

外部类.java

public class OuterClass {
     private String someVariable = "Non Static";

     private static String anotherStaticVariable = "Static";  

     OuterClass(){

     }

     //Nested classes are static
     static class StaticNestedClass{
        private static String privateStaticNestedClassVariable = "Private Static Nested Class Variable"; 

        //can access private variables declared in the outer class
        public static void getPrivateVariableofOuterClass(){
            System.out.println(anotherStaticVariable);
        }
     }

     //non static
     class InnerClass{

         //can access private variables of outer class
         public String getPrivateNonStaticVariableOfOuterClass(){
             return someVariable;
         }
     }

     public static void accessStaticClass(){
         //can access any variable declared inside the Static Nested Class 
         //even if it private
         String var = OuterClass.StaticNestedClass.privateStaticNestedClassVariable; 
         System.out.println(var);
     }

}

外部类别测试：

public class OuterClassTest {
    public static void main(String[] args) {

        //access the Static Nested Class
        OuterClass.StaticNestedClass.getPrivateVariableofOuterClass();

        //test the private variable declared inside the static nested class
        OuterClass.accessStaticClass();
        /*
         * Inner Class Test
         * */

        //Declaration

        //first instantiate the outer class
        OuterClass outerClass = new OuterClass();

        //then instantiate the inner class
        OuterClass.InnerClass innerClassExample =  outerClass. new InnerClass();

        //test the non static private variable
        System.out.println(innerClassExample.getPrivateNonStaticVariableOfOuterClass()); 

    }

}