我认为这里没有什么要补充的，大多数答案完美地解释了静态嵌套类和内部类之间的区别。但是，当使用嵌套类与内部类时，请考虑以下问题。正如在两个答案中提到的，如果没有封闭类的实例，内部类就无法实例化，这意味着它们持有指向封闭类实例的指针，这可能导致内存溢出或堆栈溢出异常，因为即使不再使用封闭类，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教程：

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

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

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()); 

    }

}

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

 public static class A {} //ERROR

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

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

 }

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

当我们在类中声明静态成员类时，它被称为顶级嵌套类或静态嵌套类。可以证明如下：

class Test{
    private static int x = 1;
        static class A{
        private static int y = 2;
        public static int getZ(){
            return B.z+x;
        }
    }
    static class B{
        private static int z = 3;
        public static int getY(){
            return A.y;
        }
    }
}

class TestDemo{
     public static void main(String[] args){
        Test t = new Test();
        System.out.println(Test.A.getZ());
        System.out.println(Test.B.getY());
    }
}

当我们在类中声明非静态成员类时，它被称为内部类。内部类可演示如下：

    class Test{
        private int i = 10;
        class A{
            private int i =20;
            void display(){
            int i = 30;
            System.out.println(i);
            System.out.println(this.i);
            System.out.println(Test.this.i);
        }
    }
}

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

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

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

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

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

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

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