嵌套类：类内的类

类型：

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

差异：

非静态嵌套类[内部类]

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

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和/或嵌套类新手的学习者

嵌套类可以是：1.静态嵌套类。2.非静态嵌套类。（也称为内部类）=>请记住这一点

1.内部类例子：

class OuterClass  {
/*  some code here...*/
     class InnerClass  {  }
/*  some code here...*/
}

内部类是嵌套类的子集：

内部类是特定类型的嵌套类内部类是嵌套类的子集可以说内部类也是嵌套类，但不能说嵌套类也是内部类。

内层专业：

内部类的实例可以访问外部类的所有成员，即使是标记为“private”的成员

2.静态嵌套类：例子：

class EnclosingClass {
  static class Nested {
    void someMethod() { System.out.println("hello SO"); }
  }
}

案例1：从非封闭类实例化静态嵌套类

class NonEnclosingClass {

  public static void main(String[] args) {
    /*instantiate the Nested class that is a static
      member of the EnclosingClass class:
    */

    EnclosingClass.Nested n = new EnclosingClass.Nested(); 
    n.someMethod();  //prints out "hello"
  }
}

案例2：从封闭类实例化静态嵌套类

class EnclosingClass {

  static class Nested {
    void anotherMethod() { System.out.println("hi again"); } 
  }

  public static void main(String[] args) {
    //access enclosed class:

    Nested n = new Nested(); 
    n.anotherMethod();  //prints out "hi again"
  }

}

静态类专业：

静态内部类只能访问外部类的静态成员，不能访问非静态成员。

结论：问：Java中内部类和静态嵌套类的主要区别是什么？答：只需仔细阅读上面提到的每门课的细节。

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

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

考虑以下示例：

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教程：

嵌套类分为两类：静态类和非静态类。声明为静态的嵌套类简单地称为静态嵌套类。非静态嵌套类称为内部类。

使用封闭类名访问静态嵌套类：

OuterClass.StaticNestedClass

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

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

作为内部类实例的对象存在于外部类的实例中。考虑以下类别：

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

InnerClass实例只能存在于OuterClass实例中，并且可以直接访问其封闭实例的方法和字段。

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

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

请参见：Java教程-嵌套类

为了完整性，请注意还有这样一种东西，即没有封闭实例的内部类：

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

这里，new A（）｛…｝是在静态上下文中定义的内部类，没有封闭实例。

这里是Java内部类和静态嵌套类之间的关键区别和相似之处。

希望它有帮助！

内部类

可以访问实例和静态方法以及字段的外部类与封闭类的实例关联，因此要实例化它，首先需要一个外部类的实例（注意new关键字place）：Outerclass.InnerClass innerObject=outerObject.new InnerClass（）；无法定义任何静态成员本身不能有类或接口声明

静态嵌套类

无法访问外部类实例方法或字段不与封闭类的任何实例关联，因此要实例化它：OuterClass.StaticNestedClass嵌套对象=新OuterClass.staticNestClass（）；

相似之处

两个内部类甚至可以访问外部类的私有字段和方法外部类也可以访问内部类的私有字段和方法两个类都可以具有私有、受保护或公共访问修饰符

为什么使用嵌套类？

根据Oracle文档，有几个原因（完整文档）：

这是一种对仅在一个地方使用的类进行逻辑分组的方法：如果一个类只对另一个类有用，那么将其嵌入该类并将两者保持在一起是合乎逻辑的。嵌套这样的“助手类”使它们的包更加精简。它增加了封装：考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为私有。通过将类B隐藏在类A中，可以将A的成员声明为私有，B可以访问它们。此外，B本身可以对外界隐藏。它可以产生更可读和可维护的代码：将小类嵌套在顶级类中，使代码更接近使用它的地方。

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