在Java中，可以在另一个类中定义一个类，此类被称为嵌套类。它们使您能够对仅在一个地方使用的类进行逻辑分组，从而增加了封装的使用，并创建了更具可读性和可维护性的代码。

• 嵌套类的范围受其封闭类的范围限制。因此，在下面的例子中，类NestedClass并不独立存在在于OuterClass类之外。
• 嵌套类可以访问嵌套它的类的成员，包括私有成员。但是，反过来不是正确的，即，封闭类无法访问嵌套类的成员。
• 嵌套类也是其封闭类的成员。
• 作为其封闭类的成员，可以将嵌套类声明为private，public，protected或package private(默认)。
• 嵌套类分为两类：
  1. 静态嵌套类：被声明为嵌套类的静态被称为静态嵌套类。
  2. 内部类：内部类是一个非静态的嵌套类。

语法：

class OuterClass
{
...
    class NestedClass
    {
        ...
    }
}

静态嵌套类

与类方法和变量一样，静态嵌套类与其外部类相关联。与静态类方法一样，静态嵌套类不能直接引用其封闭类中定义的实例变量或方法：它只能通过对象引用来使用它们。
使用封闭的类名可以访问它们。

OuterClass.StaticNestedClass

例如，为静态嵌套类创建一个对象，请使用以下语法：

OuterClass.StaticNestedClass nestedObject =
     new OuterClass.StaticNestedClass();

// Java展示从外部访问静态嵌套类
class OuterClass
{
    // 静态方法
    static int outer_x = 10;
    // instance(non-static) member
    int outer_y = 20;
    // 私有成员
    private static int outer_private = 30;
    // 静态嵌套方法
    static class StaticNestedClass
    {
        void display()
        {
            // 可从外部类访问静态成员
            System.out.println("outer_x = " + outer_x);
            //  展示外部类的private static成员
            System.out.println("outer_private = " + outer_private);
            // 如下语句会编译错误
            // 因为静态嵌套类，不能直接访问费静态成员
            // System.out.println("outer_y = " + outer_y);
        }
    }
}
// 测试代码
public class StaticNestedClassDemo
{
    public static void main(String[] args)
    {
        // 访问静态嵌套类
        OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
        nestedObject.display();
    }
}

输出：

external_x = 10
outside_private = 30

内部类

要实例化内部类，必须首先实例化外部类。然后，使用以下语法在外部对象内创建内部对象：

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

有两种特殊的内部类：

1. 本地内部类
2. 匿名内部类

   // Java展示访问内部类
   class OuterClass
   {
       // static成员
       static int outer_x = 10;
       // instance(non-static) member
       int outer_y = 20;
       // private成员
       private int outer_private = 30;
       // inner class
       class InnerClass
       {
           void display()
           {
               // 访问外部类的静态成员
               System.out.println("outer_x = " + outer_x);
               // 访问外部类的非静态成员
               System.out.println("outer_y = " + outer_y);
               // 访问外部类的静态成员
               System.out.println("outer_private = " + outer_private);
           }
       }
   }
   // 测试代码
   public class InnerClassDemo
   {
       public static void main(String[] args)
       {
           // 访问内部类
           OuterClass outerObject = new OuterClass();
           OuterClass.InnerClass innerObject = outerObject.new InnerClass();
           innerObject.display();
       }
   }

   输出：

   outer_x = 10
   outer_y = 20
   outer_private = 30

静态和内部(非静态嵌套)类之间的区别

• 静态嵌套类无法直接访问该封闭类的其他成员(非静态变量和方法)，因为它是静态的，因此必须通过一个对象访问其封闭类的非静态成员。也就是说，它不能直接引用其封闭类的非静态成员。由于此限制，很少使用静态嵌套类。
• 非静态嵌套类(内部类)可以访问其外部类的所有成员(静态和非静态变量和方法，包括私有的)，并且可以与外部其他非静态成员相同的方式直接引用它们。