嵌套类：类内的类

类型：

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

差异：

非静态嵌套类[内部类]

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

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

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

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

A图表

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

简单来说，我们需要嵌套类，主要是因为Java不提供闭包。

嵌套类是在另一个封闭类的主体内定义的类。它们有两种类型——静态和非静态。

它们被视为封闭类的成员，因此您可以指定四个访问说明符中的任意一个-私有、包、受保护和公共。对于顶级类，我们没有这种奢侈，它只能声明为public或packageprivate。

内部类（也称为非堆栈类）可以访问顶级类的其他成员，即使它们被声明为私有，而静态嵌套类不能访问顶级类中的其他成员。

public class OuterClass {
    public static class Inner1 {
    }
    public class Inner2 {
    }
}

Inner1是我们的静态内部类，Inner2是我们的非静态内部类。它们之间的关键区别是，如果没有Outer，就无法创建Inner2实例，因为您可以独立创建Inner1对象。

你什么时候使用内部类？

想象一下这样一种情况：a类和B类是相关的，B类需要访问a类成员，而B类只与a类相关。

为了创建内部类的实例，需要创建外部类的实例。

OuterClass outer = new OuterClass();
OuterClass.Inner2 inner = outer.new Inner2();

or

OuterClass.Inner2 inner = new OuterClass().new Inner2();

什么时候使用静态内部类？

当您知道静态内部类与封闭类/顶层类的实例没有任何关系时，可以定义它。如果您的内部类不使用外部类的方法或字段，这只是浪费空间，所以请将其设置为静态。

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

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

静态嵌套类的优点是它不需要包含类/顶级类的对象来工作。这可以帮助您减少应用程序在运行时创建的对象数量。

嵌套类是一个非常通用的术语：每个不是顶级的类都是嵌套类。内部类是非静态嵌套类。约瑟夫·达西写了一篇关于嵌套、内部、成员和顶级课程的非常好的解释。

Java编程语言允许您在另一个类中定义一个类。这样的类称为嵌套类，如下所示：

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

嵌套类分为两类：静态类和非静态类。声明为静态的嵌套类称为静态嵌套类。非静态嵌套类称为内部类。我们应该记住的一点是，非静态嵌套类（内部类）可以访问封闭类的其他成员，即使它们被声明为私有。静态嵌套类只能访问封闭类的其他成员（如果这些成员是静态的）。它无法访问外部类的非静态成员。与类方法和变量一样，静态嵌套类与其外部类相关联。例如，要为静态嵌套类创建对象，请使用以下语法：

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

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

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

为什么我们使用嵌套类

这是一种对仅在一个地方使用的类进行逻辑分组的方法。它增加了封装性。它可以产生更可读和可维护的代码。

来源：Java™ 教程-嵌套类