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

 public static class A {} //ERROR

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

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

 }

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

我认为在上述答案中，真正的区别并不明显。

首先要正确使用条款：

嵌套类是包含在源代码级别的另一个类中的类。如果使用static修饰符声明它，则它是静态的。非静态嵌套类称为内部类。（我使用非静态嵌套类。）

到目前为止，马丁的回答是正确的。然而，实际的问题是：声明一个嵌套类静态或不静态的目的是什么？

如果您只想将类保持在一起（如果它们在主题上属于一起），或者如果嵌套类只在封闭类中使用，则可以使用静态嵌套类。静态嵌套类和其他类之间没有语义差异。

非静态嵌套类是另一种野兽。与匿名内部类类似，此类嵌套类实际上是闭包。这意味着它们捕获其周围范围和封闭实例，并使其可访问。也许一个例子可以说明这一点。查看容器的存根：

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

在这种情况下，您希望具有从子项到父容器的引用。使用非静态嵌套类，这可以在不做任何工作的情况下工作。您可以使用语法Container.this访问容器的封闭实例。

更多核心解释如下：

如果您查看编译器为（非静态）嵌套类生成的Java字节码，可能会更清楚：

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public <init>(Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

如您所见，编译器创建了一个隐藏字段Container this$0。这是在构造函数中设置的，该构造函数有一个Container类型的附加参数，用于指定封闭实例。在源代码中看不到该参数，但编译器为嵌套类隐式生成该参数。

马丁的例子

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

将被编译为类似（字节码）的调用

new InnerClass(outerObject)

为完整起见：

匿名类是一个非静态嵌套类的完美例子，它只是没有与之关联的名称，以后无法引用。

A图表

静态嵌套类和非静态嵌套类之间的主要区别在于，静态嵌套类不能访问非静态外部类成员

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

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

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

考虑以下示例：

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

首先，没有这样的类称为静态类。与内部类一起使用的静态修饰符（称为嵌套类）表示它是外部类的静态成员，这意味着我们可以像其他静态成员一样访问它，而不需要外部类的任何实例。（这本来就是静态的好处。）

使用嵌套类和常规内部类之间的区别是：

OuterClass.InnerClass inner = new OuterClass().new InnerClass();

首先我们可以实例化Outerclass，然后我们可以访问Inner。

但如果类是嵌套的，则语法为：

OuterClass.InnerClass inner = new OuterClass.InnerClass();

它使用静态语法作为静态关键字的正常实现。