Java中的内部类和嵌套静态类都是在另一个类中声明的类，在Java中称为顶级类。在Java术语中，如果您将嵌套类声明为静态的，则在Java中将其称为嵌套静态类，而非静态嵌套类则简称为内部类。

什么是Java中的内部类？

任何不是顶级或在另一个类中声明的类都称为嵌套类，在这些嵌套类中，声明为非静态的类在Java中称为内部类。Java中有三种内部类：

1） 本地内部类-在代码块或方法中声明。2） 匿名内部类-是一个没有名称可引用的类，并在创建它的同一位置初始化。3） 成员内部类-声明为外部类的非静态成员。

public class InnerClassTest {
    public static void main(String args[]) {      
        //creating local inner class inside method i.e. main() 
        class Local {
            public void name() {
                System.out.println("Example of Local class in Java");

            }
        }      
        //creating instance of local inner class
        Local local = new Local();
        local.name(); //calling method from local inner class

        //Creating anonymous inner class in Java for implementing thread
        Thread anonymous = new Thread(){
            @Override
            public void run(){
                System.out.println("Anonymous class example in java");
            }
        };
        anonymous.start();

        //example of creating instance of inner class
        InnerClassTest test = new InnerClassTest();
        InnerClassTest.Inner inner = test.new Inner();
        inner.name(); //calling method of inner class
    }

     //Creating Inner class in Java
    private class Inner{
        public void name(){
            System.out.println("Inner class example in java");
        }
    }
}

什么是Java中的嵌套静态类？

嵌套静态类是另一个在类内部声明为成员并使其成为静态的类。嵌套的静态类也被声明为外部类的成员，并且可以像任何其他成员一样成为私有的、公共的或受保护的。嵌套静态类相对于内部类的主要优点之一是嵌套静态类的实例不附加到外部类的任何封闭实例。您也不需要任何外部类的实例来在Java中创建嵌套静态类的实例。

1） 它可以访问外部类（包括private）的静态数据成员。2） 静态嵌套类无法访问非静态（实例）数据成员或方法。

public class NestedStaticExample {
    public static void main(String args[]){  
        StaticNested nested = new StaticNested();
        nested.name();
    }  
    //static nested class in java
    private static class StaticNested{
        public void name(){
            System.out.println("static nested class example in java");
        }
    }
}

参考：Java中的内部类和嵌套静态类及其示例

静态嵌套类访问在其中定义的类的PRIVATE类级静态变量。从体系结构的角度来看，这可能是巨大的（即服务定位器模式在服务中使用嵌套的静态助手类），并可能帮助OP了解它们与内部类一起存在的原因。

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

 public static class A {} //ERROR

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

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

 }

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

嵌套类：类内的类

类型：

静态嵌套类非静态嵌套类[内部类]

差异：

非静态嵌套类[内部类]

在非静态嵌套类中，内部类的对象存在于外部类的对象中。因此，内部类可以访问外部类的数据成员。所以要创建内部类的对象，我们必须首先创建外部类的对象。

outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass(); 

静态嵌套类

在静态嵌套类中，内部类的对象不需要外部类的对象，因为单词“static”表示不需要创建对象。

class outerclass A {
    static class nestedclass B {
        static int x = 10;
    }
}

如果要访问x，请在内部方法中写入以下内容

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

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

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

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

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