以下是静态嵌套类和内部类的示例：

外部类.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()); 

    }

}

A图表

静态嵌套类和非静态嵌套类之间的主要区别在于，静态嵌套类不能访问非静态外部类成员

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

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

考虑以下示例：

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

Java教程说：

术语：嵌套类是分为两类：静态并且是非静态的。嵌套的类被声明为静态的静态嵌套类。非静态嵌套类称为内部类类。

一般来说，术语“嵌套”和“内部”被大多数程序员互换使用，但我将使用正确的术语“嵌套类”，它涵盖内部和静态。

类可以无限嵌套，例如类A可以包含B类，B类包含C类，C类包含D类等。但是，很少有一个以上的类嵌套，因为这通常是错误的设计。

创建嵌套类有三个原因：

组织：有时将一个类分类到另一个类的命名空间中似乎是最明智的，尤其是当它不会在任何其他上下文中使用时访问：嵌套类具有对其包含类的变量/字段的特殊访问权限（确切地说，哪些变量/字段取决于嵌套类的类型，无论是内部的还是静态的）。方便：必须为每个新类型创建一个新文件，这同样令人烦恼，尤其是当该类型只在一个上下文中使用时

Java中有四种嵌套类。简而言之，它们是：

静态类：声明为另一个类的静态成员内部类：声明为另一个类的实例成员本地内部类：在另一个类的实例方法中声明匿名内部类：类似于本地内部类，但作为返回一次性对象的表达式编写

让我详细说明一下。

静态类

静态类最容易理解，因为它们与包含类的实例无关。

静态类是声明为另一个类的静态成员的类。就像其他静态成员一样，这样的类实际上只是一个使用包含类作为其名称空间的挂接器，例如，pizza包中声明为Rhino类静态成员的Goat类被称为pizza.Hino.Goat。

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

坦率地说，静态类是一个非常无用的特性，因为类已经被包划分为名称空间。创建静态类的唯一真正可以想象的原因是这样的类可以访问其包含类的私有静态成员，但我发现这是静态类特性存在的一个非常蹩脚的理由。

内部类

内部类是声明为另一个类的非静态成员的类：

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

    private void jerry() {
        Goat g = new Goat();
    }
}

与静态类一样，内部类通过其包含类名pizza.Hino.Goat来限定，但在包含类内部，可以通过其简单名称来限定。然而，内部类的每个实例都与其包含类的一个特定实例相关联：上面，在jerry中创建的Goat被隐式地绑定到Rhino实例，这是在jerrry中创建的。否则，当我们实例化Goat时，我们将显式显示关联的Rhino实例：

Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();

（注意，你在奇怪的新语法中将内部类型称为Goat：Java从rhino部分推断出包含类型。是的，new rhino.Goat（）对我来说也更有意义。）

那么这给我们带来了什么？内部类实例可以访问包含类实例的实例成员。这些封闭实例成员仅通过其简单名称在内部类中引用，而不是通过this（内部类中的this引用内部类实例，而不是关联的包含类实例）：

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

在内部类中，您可以将包含类的this引用为Rhino.this，也可以使用它来引用其成员，例如Rhino.tis.barry。

本地内部类

本地内部类是在方法体中声明的类。这样的类只在其包含方法中是已知的，因此只能在其包含的方法中实例化并访问其成员。这样做的好处是，本地内部类实例绑定到并可以访问其包含方法的最终本地变量。当实例使用其包含方法的最终局部变量时，即使变量已超出范围（这实际上是Java的粗糙、有限版本的闭包），该变量仍保留其在创建实例时所保持的值。

因为本地内部类既不是类或包的成员，所以它没有用访问级别声明。（但是，要清楚，它自己的成员拥有与普通类一样的访问级别。）

如果在实例方法中声明了本地内部类，则在创建实例时，内部类的实例化与包含方法的this所持有的实例相关联，因此包含类的实例成员可以像在实例内部类中一样访问。本地内部类仅通过其名称实例化，例如，本地内部类Cat被实例化为new Cat（），而不是您可能期望的new this.Cat（）。

匿名内部类

匿名内部类是编写本地内部类的语法上方便的方法。最常见的情况是，本地内部类在每次运行其包含方法时最多实例化一次。那么，如果我们能够将本地内部类定义及其单个实例化组合成一种方便的语法形式，这将是很好的，如果我们不必为类想出一个名称（代码中包含的无用名称越少越好），这也是很好的。匿名内部类同时允许以下两种功能：

new *ParentClassName*(*constructorArgs*) {*members*}

这是一个返回扩展ParentClassName的未命名类的新实例的表达式。您不能提供自己的构造函数；相反，一个是隐式提供的，它只是调用超级构造函数，因此提供的参数必须适合超级构造函数。（如果父级包含多个构造函数，则称为“最简单”的构造函数，由一组相当复杂的规则决定，不值得详细学习——只需注意NetBeans或Eclipse告诉您的内容。）

或者，您可以指定要实现的接口：

new *InterfaceName*() {*members*}

这样的声明创建了一个未命名类的新实例，该类扩展了Object并实现了InterfaceName。同样，您不能提供自己的构造函数；在本例中，Java隐式地提供了一个无参数、不做任何事情的构造函数（因此在本例中将不会有构造函数参数）。

即使您不能给匿名内部类一个构造函数，您仍然可以使用初始值设定项块（放置在任何方法外部的｛｝块）进行任何设置。

请注意，匿名内部类只是用一个实例创建本地内部类的一种不太灵活的方式。如果您想要一个实现多个接口的本地内部类，或者在扩展除Object之外的某个类时实现接口，或者指定自己的构造函数，那么您只能创建一个常规的命名本地内部类。

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

嵌套类的另一个用例，除了已经提到的那些用例之外，是当嵌套类具有只能从外部类访问的方法时。这是可能的，因为外部类可以访问嵌套类的私有构造函数、字段和方法。

在下面的示例中，银行可以发行具有私有构造函数的Bank.CreditCard，并可以使用Bank.credit card的私有setLimit（…）实例方法根据当前银行策略更改信用卡的限额。从任何其他类只能访问Bank.CreditCard的公共方法。

public class Bank {

    // maximum limit as per current bank policy
    // is subject to change
    private int maxLimit = 7000;

    // ------- PUBLIC METHODS ---------

    public CreditCard issueCard(
            final String firstName,
            final String lastName
    ) {
        final String number = this.generateNumber();
        final int expiryDate = this.generateExpiryDate();
        final int CVV = this.generateCVV();
        return new CreditCard(firstName, lastName, number, expiryDate, CVV);
    }


    public boolean setLimit(
            final CreditCard creditCard,
            final int limit
    ) {
        if (limit <= this.maxLimit) {    // check against current bank policy limit
            creditCard.setLimit(limit);  // access private method Bank.CreditCard.setLimit(int)
            return true;
        }
        return false;
    }

    // ------- PRIVATE METHODS ---------

    private String generateNumber() {
        return "1234-5678-9101-1123";   // the numbers should be unique for each card
    }


    private int generateExpiryDate() {
        return 202405;                  // date is YYYY=2024, MM=05
    }


    private int generateCVV() {
        return 123;                     // is in real-life less predictable
    }


    // ------- PUBLIC STATIC NESTED CLASS ---------

    public static final class CreditCard {
        private final String firstName;
        private final String lastName;
        private final String number;
        private final int expiryDate;
        private final int CVV;

        private int balance;
        private int limit = 100; // default limit

        // the constructor is final but is accessible from outer class
        private CreditCard(
                final String firstName,
                final String lastName,
                final String number,
                final int expiryDate,
                final int CVV
        ) {
            this.firstName = firstName;
            this.lastName = lastName;
            this.number = number;
            this.expiryDate = expiryDate;
            this.CVV = CVV;
        }

        // ------- PUBLIC METHODS ---------

        public String getFirstName() {
            return this.firstName;
        }

        public String getLastName() {
            return this.lastName;
        }

        public String getNumber() {
            return this.number;
        }

        public int getExpiryDate() {
            return this.expiryDate;
        }

        // returns true if financial transaction is successful
        // otherwise false
        public boolean charge(final int amount) {
            final int newBalance = this.balance - amount;
            if (newBalance < -this.limit) {
                return false;
            }
            this.balance = newBalance;
            return true;
        }

        // ------- PRIVATE METHODS ---------

        private int getCVV() {
            return this.CVV;
        }

        private int getBalance() {
            return this.balance;
        }

        private void setBalance(final int balance) {
            this.balance = balance;
        }

        private int getLimit() {
            return limit;
        }

        private void setLimit(final int limit) {
            this.limit = limit;
        }
    }
}