我认为上面的答案都没有给你一个真正的例子，说明在应用程序设计方面，嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。

让我们看看下面的两个例子。

静态嵌套类：使用静态嵌套类的一个好例子是生成器模式(https://dzone.com/articles/design-patterns-the-builder-pattern).

对于BankAccount，我们使用静态嵌套类，主要是因为

静态嵌套类实例可以在外部类之前创建。在构建器模式中，构建器是一个帮助器类，用于创建BankAccount。BankAccount.Builder仅与BankAccount关联。没有其他类与BankAccount.Builder相关，因此最好在不使用名称约定的情况下将它们组织在一起。

public class BankAccount {

    private long accountNumber;
    private String owner;
    ...

    public static class Builder {

    private long accountNumber;
    private String owner;
    ...

    static public Builder(long accountNumber) {
        this.accountNumber = accountNumber;
    }

    public Builder withOwner(String owner){
        this.owner = owner;
        return this; 
    }

    ...
    public BankAccount build(){
            BankAccount account = new BankAccount(); 
            account.accountNumber = this.accountNumber;
            account.owner = this.owner;
            ...
            return account;
        }
    }
}

内部类：内部类的一个常见用法是定义事件处理程序。https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html

对于MyClass，我们使用内部类，主要是因为：

内部类MyAdapter需要访问外部类成员。在示例中，MyAdapter仅与MyClass关联。没有其他类与MyAdapter相关。因此最好将它们组织在一起，而不使用名称约定

public class MyClass extends Applet {
    ...
        someObject.addMouseListener(new MyAdapter());
    ...
    class MyAdapter extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {
            ...// Event listener implementation goes here...
            ...// change some outer class instance property depend on the event
        }
    }
}

我认为上面的答案都没有给你一个真正的例子，说明在应用程序设计方面，嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。

让我们看看下面的两个例子。

静态嵌套类：使用静态嵌套类的一个好例子是生成器模式(https://dzone.com/articles/design-patterns-the-builder-pattern).

对于BankAccount，我们使用静态嵌套类，主要是因为

静态嵌套类实例可以在外部类之前创建。在构建器模式中，构建器是一个帮助器类，用于创建BankAccount。BankAccount.Builder仅与BankAccount关联。没有其他类与BankAccount.Builder相关，因此最好在不使用名称约定的情况下将它们组织在一起。

public class BankAccount {

    private long accountNumber;
    private String owner;
    ...

    public static class Builder {

    private long accountNumber;
    private String owner;
    ...

    static public Builder(long accountNumber) {
        this.accountNumber = accountNumber;
    }

    public Builder withOwner(String owner){
        this.owner = owner;
        return this; 
    }

    ...
    public BankAccount build(){
            BankAccount account = new BankAccount(); 
            account.accountNumber = this.accountNumber;
            account.owner = this.owner;
            ...
            return account;
        }
    }
}

内部类：内部类的一个常见用法是定义事件处理程序。https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html

对于MyClass，我们使用内部类，主要是因为：

内部类MyAdapter需要访问外部类成员。在示例中，MyAdapter仅与MyClass关联。没有其他类与MyAdapter相关。因此最好将它们组织在一起，而不使用名称约定

public class MyClass extends Applet {
    ...
        someObject.addMouseListener(new MyAdapter());
    ...
    class MyAdapter extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {
            ...// Event listener implementation goes here...
            ...// change some outer class instance property depend on the event
        }
    }
}

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

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

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

嗯……内部类是嵌套类……您是指匿名类和内部类吗？

编辑：如果您实际上是指内部v.s.匿名：内部类只是在类中定义的类，例如：

public class A {
    public class B {
    }
}

…而匿名类是匿名定义的类的扩展，因此没有定义实际的“类”，如：

public class A {
}

A anon = new A() { /* You could change behavior of A here */ };

进一步编辑：

维基百科声称Java存在差异，但我已经用Java工作了八年，这是我第一次听到这样的区别——更不用说那里没有引用来支持这一说法……总之，内部类是在类中定义的类（静态或非静态），嵌套只是另一个意思相同的术语。

静态和非静态嵌套类之间有一个微妙的区别……基本上，非静态内部类可以隐式访问封闭类的实例字段和方法（因此它们不能在静态上下文中构造，这将是编译器错误）。另一方面，静态嵌套类不具有对实例字段和方法的隐式访问，并且可以在静态上下文中构造。

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

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

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

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

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

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中的内部类和嵌套静态类及其示例