从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内部类和静态嵌套类之间的关键区别和相似之处。

希望它有帮助！

内部类

可以访问实例和静态方法以及字段的外部类与封闭类的实例关联，因此要实例化它，首先需要一个外部类的实例（注意new关键字place）：Outerclass.InnerClass innerObject=outerObject.new InnerClass（）；无法定义任何静态成员本身不能有类或接口声明

静态嵌套类

无法访问外部类实例方法或字段不与封闭类的任何实例关联，因此要实例化它：OuterClass.StaticNestedClass嵌套对象=新OuterClass.staticNestClass（）；

相似之处

两个内部类甚至可以访问外部类的私有字段和方法外部类也可以访问内部类的私有字段和方法两个类都可以具有私有、受保护或公共访问修饰符

为什么使用嵌套类？

根据Oracle文档，有几个原因（完整文档）：

这是一种对仅在一个地方使用的类进行逻辑分组的方法：如果一个类只对另一个类有用，那么将其嵌入该类并将两者保持在一起是合乎逻辑的。嵌套这样的“助手类”使它们的包更加精简。它增加了封装：考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为私有。通过将类B隐藏在类A中，可以将A的成员声明为私有，B可以访问它们。此外，B本身可以对外界隐藏。它可以产生更可读和可维护的代码：将小类嵌套在顶级类中，使代码更接近使用它的地方。

内部类的实例是在创建外部类的实例时创建的。因此，内部类的成员和方法可以访问外部类的实例（对象）的成员和对象。当外部类的实例超出范围时，内部类实例也将停止存在。

静态嵌套类没有具体实例。它只是在第一次使用时加载的（就像静态方法一样）。它是一个完全独立的实体，其方法和变量不能访问外部类的实例。

静态嵌套类不与外部对象耦合，它们速度更快，并且不占用堆/堆栈内存，因为不需要创建此类的实例。因此，经验法则是尽量使用有限的范围（private>=class>=protected>=public）定义静态嵌套类，然后将其转换为内部类（通过删除“static”标识符），如果确实有必要，则放宽范围。

我认为上面的答案都没有向您解释嵌套类和静态嵌套类在应用程序设计方面的真正区别：

概述

嵌套类可以是非静态的或静态的，并且在每种情况下都是在另一个类中定义的类。嵌套类应该只存在于服务于封闭类，如果嵌套类对其他类（不仅仅是封闭类）有用，则应该声明为顶级类。

差别

非静态嵌套类：与包含类的封闭实例隐式关联，这意味着可以调用封闭实例的方法和访问变量。非静态嵌套类的一个常见用法是定义Adapter类。

静态嵌套类：无法访问封闭类实例并在其上调用方法，因此当嵌套类不需要访问封闭类的实例时应使用。静态嵌套类的一个常见用法是实现外部对象的组件。

结论

所以从设计角度来看，两者之间的主要区别是：非静态嵌套类可以访问容器类的实例，而静态类不能。

针对Java和/或嵌套类新手的学习者

嵌套类可以是：1.静态嵌套类。2.非静态嵌套类。（也称为内部类）=>请记住这一点

1.内部类例子：

class OuterClass  {
/*  some code here...*/
     class InnerClass  {  }
/*  some code here...*/
}

内部类是嵌套类的子集：

内部类是特定类型的嵌套类内部类是嵌套类的子集可以说内部类也是嵌套类，但不能说嵌套类也是内部类。

内层专业：

内部类的实例可以访问外部类的所有成员，即使是标记为“private”的成员

2.静态嵌套类：例子：

class EnclosingClass {
  static class Nested {
    void someMethod() { System.out.println("hello SO"); }
  }
}

案例1：从非封闭类实例化静态嵌套类

class NonEnclosingClass {

  public static void main(String[] args) {
    /*instantiate the Nested class that is a static
      member of the EnclosingClass class:
    */

    EnclosingClass.Nested n = new EnclosingClass.Nested(); 
    n.someMethod();  //prints out "hello"
  }
}

案例2：从封闭类实例化静态嵌套类

class EnclosingClass {

  static class Nested {
    void anotherMethod() { System.out.println("hi again"); } 
  }

  public static void main(String[] args) {
    //access enclosed class:

    Nested n = new Nested(); 
    n.anotherMethod();  //prints out "hi again"
  }

}

静态类专业：

静态内部类只能访问外部类的静态成员，不能访问非静态成员。

结论：问：Java中内部类和静态嵌套类的主要区别是什么？答：只需仔细阅读上面提到的每门课的细节。

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