不同之处在于，同样是静态的嵌套类声明可以在封闭类之外实例化。

当您有一个非静态的嵌套类声明（也称为内部类）时，Java不允许您实例化它，除非通过封闭类。从内部类创建的对象链接到从外部类创建的目标，因此内部类可以引用外部类的字段。

但是如果它是静态的，那么链接就不存在，外部字段就不能被访问（除非像其他对象一样通过普通引用），因此您可以自己实例化嵌套类。

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

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

考虑以下示例：

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中看到的。

从Java教程：

嵌套类分为两类：静态类和非静态类。声明为静态的嵌套类简单地称为静态嵌套类。非静态嵌套类称为内部类。

使用封闭类名访问静态嵌套类：

OuterClass.StaticNestedClass

例如，要为静态嵌套类创建对象，请使用以下语法：

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

作为内部类实例的对象存在于外部类的实例中。考虑以下类别：

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

InnerClass实例只能存在于OuterClass实例中，并且可以直接访问其封闭实例的方法和字段。

要实例化内部类，必须首先实例化外部类。然后，使用以下语法在外部对象中创建内部对象：

OuterClass outerObject = new OuterClass()
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

请参见：Java教程-嵌套类

为了完整性，请注意还有这样一种东西，即没有封闭实例的内部类：

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

这里，new A（）｛…｝是在静态上下文中定义的内部类，没有封闭实例。

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

外部类.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()); 

    }

}

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

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

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

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

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

我认为这里的人应该注意到海报：静态嵌套类只是第一个内部类。例如：

 public static class A {} //ERROR

 public class A {
     public class B {
         public static class C {} //ERROR
     }
 }

 public class A {
     public static class B {} //COMPILE !!!

 }

所以，总结一下，静态类并不取决于它包含的类。所以，他们不能在正常班级上课。（因为普通类需要一个实例）。