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

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

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

在创建实例的情况下静态内部类是使用的引用创建的定义它的外部类的对象。这表示它具有包含实例。但是静态内部类的实例使用外部类的引用创建，而不是使用外部类对象的引用。这意味着没有包含实例。

例如：

class A
{
  class B
  {
    // static int x; not allowed here…..    
  }
  static class C
  {
    static int x; // allowed here
  }
}

class Test
{
  public static void main(String… str)
  {
    A o=new A();
    A.B obj1 =o.new B();//need of inclosing instance

    A.C obj2 =new A.C();

    // not need of reference of object of outer class….
  }
}

这些术语可以互换使用。如果你真的想变得迂腐，那么你可以定义“嵌套类”来引用一个静态的内部类，这个类没有封闭的实例。在代码中，您可能有如下内容：

public class Outer {
    public class Inner {}

    public static class Nested {}
}

但这并不是一个被广泛接受的定义。

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

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

考虑以下示例：

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

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

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

静态嵌套类：使用静态嵌套类的一个好例子是生成器模式(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
        }
    }
}

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

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