Java内部类和静态嵌套类

Question

Java 中内部类和静态嵌套类的主要区别是什么？ 设计/实施在选择其中之一时发挥作用吗？

Answer 1

来自 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() { ... } 是一个 >在静态上下文中定义的内部类并且没有封闭实例。

Answer 2

Java 教程说：

术语：嵌套类是
分为两类：静态
并且非静态。 嵌套类
被声明为静态的，只是简单地调用
静态嵌套类。 非静态
嵌套类称为内部类
类。

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

类可以无限嵌套，例如，类 A 可以包含类 B，类 B 包含类 C，类 C 又包含类 D，等等。但是，多于一层的类嵌套很少见，因为这通常是糟糕的设计。

创建嵌套类有以下三个原因：

• 组织：有时将一个类排序到另一个类的命名空间中似乎是最明智的，特别是当它不会在任何其他上下文
• 访问中使用时：嵌套类对其包含类的变量/字段（具体哪些变量/字段取决于嵌套类的类型，无论是内部类还是静态类）。
• 方便：必须为每个新类型创建一个新文件，这又很麻烦，尤其是当该类型仅在一个上下文中使用时。Java

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

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

让我详细说明一下。

静态类

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

静态类是声明为另一个类的静态成员的类。 就像其他静态成员一样，这样的类实际上只是一个使用包含类作为其命名空间的挂钩，例如类Goat声明为类<的静态成员pizza 包中的 em>Rhino 的名称为 pizza.Rhino.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.Rhino.Goat< /em>，但在包含类中，可以通过其简单的名称来了解它。 然而，内部类的每个实例都与其包含类的特定实例相关联：上面，在jerry中创建的Goat隐式地与Rhino相关联实例this在jerry中。 否则，当我们实例化 Goat 时，我们会显式关联 Rhino 实例：（

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

请注意，在奇怪的 Goat 中，您将内部类型称为 Goat em>new 语法：Java 从 rhino 部分推断出包含类型，并且，new rhino.Goat() 对我来说也更有意义。 .)

那么这对我们有什么好处呢？ 那么，内部类实例可以访问包含类实例的实例成员。 这些封闭实例成员在内部类内部via仅引用它们的简单名称，而不是viathis（this内部类中指的是内部类实例，而不是关联的包含类实例）：

public class Rhino {

    private String barry;

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

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

局部内部类

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

因为局部内部类既不是类也不是包的成员，所以它没有声明访问级别。 （但是请注意，它自己的成员具有与普通类相同的访问级别。）

如果在实例方法中声明局部内部类，则内部类的实例化将与包含方法的 this 在实例创建时，因此可以像在实例内部类中一样访问包含类的实例成员。 本地内部类只需通过其名称进行实例化，eg本地内部类Cat实例化为new Cat() >，不是您所期望的 new this.Cat() 。

匿名内部类

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

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

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

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

new *InterfaceName*() {*members*}

这样的声明创建了一个未命名类的新实例，该类扩展了 Object 并实现了InterfaceName。 同样，您不能提供自己的构造函数； 在这种情况下，Java 隐式提供一个无参数、不执行任何操作的构造函数（因此在这种情况下永远不会有构造函数参数）。

即使您无法为匿名内部类提供构造函数，您仍然可以使用初始化块（放置在任何方法外部的 {} 块）进行任何您想要的设置。

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

Answer 3

我认为上述答案中真正的区别并没有变得清晰。

首先要正确理解术语：

• 嵌套类是在源代码级别包含在另一个类中的类。
• 如果使用 static 修饰符声明它，它就是静态的。
• 非静态嵌套类称为内部类。 （我坚持使用非静态嵌套类。）

到目前为止，马丁的答案是正确的。 然而，真正的问题是：将嵌套类声明为静态或非静态的目的是什么？

如果您只想将类放在一起（如果它们在主题上属于一起）或者如果嵌套类专门在封闭类中使用，则可以使用静态嵌套类。 静态嵌套类与其他类之间没有语义差异。

非静态嵌套类是一种不同的野兽。 与匿名内部类类似，此类嵌套类实际上是闭包。 这意味着他们捕获周围的范围和封闭的实例并使其易于访问。 也许一个例子可以澄清这一点。 请参阅容器的存根：

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

在本例中，您希望拥有从子项到父容器的引用。 使用非静态嵌套类，无需做任何工作即可实现。 您可以使用语法 Container.this 访问 Container 的封闭实例。

更多核心解释如下：

如果您查看编译器为（非静态）嵌套类生成的 Java 字节码，它可能会变得更加清晰：

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public <init>(Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

如您所见，编译器创建了一个隐藏字段 Container this$0 。 这是在构造函数中设置的，该构造函数具有 Container 类型的附加参数来指定封闭实例。 您在源代码中看不到此参数，但编译器会为嵌套类隐式生成它。

马丁的示例

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

将被编译为类似的调用（以字节码形式）

new InnerClass(outerObject)

为了完整起见，

：匿名类是非静态嵌套类的完美示例，它没有与它并且以后无法引用。

Answer 4

我认为上述答案都没有向您解释嵌套类和静态嵌套类在应用程序设计方面的真正区别：

OverView

嵌套类可以是非静态或静态的，并且在每种情况下< strong>是一个在另一个类中定义的类。 嵌套类应该只为外围类服务，如果嵌套类对其他类（不仅仅是外围类）有用，则应将其声明为顶级类。

区别

非静态嵌套类：与包含类的封闭实例隐式关联，这意味着可以调用封闭实例的方法和访问变量。 非静态嵌套类的一种常见用途是定义 Adapter 类。

静态嵌套类：无法访问封闭类实例并调用其方法，因此应在嵌套类不需要访问封闭类实例时使用。 静态嵌套类的常见用途是实现外部对象的组件。

结论

因此，从设计的角度来看，两者之间的主要区别是：非静态嵌套类可以访问容器类的实例，而静态则不能。

Answer 5

以下是 Java 内部类和静态嵌套类之间的主要区别和相似之处。

希望能帮助到你！

内部类

• 可以访问外部类实例和静态方法和字段

• 与封闭类的实例关联，因此首先需要实例化它外部类的实例（注意 new 关键字位置）：

  Outerclass.InnerClass innerObject = outerObject.new Innerclass(); 
    

• < strong>不能定义任何静态成员本身

• 不能 有类或接口声明

静态嵌套类

• 无法访问外部类实例方法或字段

• 不与封闭类的任何实例关联因此要实例化它：

  OuterClass.StaticNestedClassnestedObject = new OuterClass.StaticNestedClass(); 
    

相似之处

• 内部类甚至可以访问私有字段和方法< 外部类的/strong>
• 另外，外部类可以访问内部类的私有字段和方法
• 这两个类可以有私有、受保护或公共访问修饰符

为什么使用嵌套类？

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

• 这是一种对仅在一个地方使用的类进行逻辑分组的方法：如果一个类仅对另一个类有用，那么将其嵌入到该类中是合乎逻辑的并将两者保持在一起。 嵌套这样的“帮助类”使得它们的包更加精简。

• 它增加了封装性：考虑两个顶级类 A 和 B，其中 B 需要访问 A 的成员，否则这些成员将被声明为私有。 通过将类 B 隐藏在类 A 中，可以将 A 的成员声明为私有，并且 B 可以访问它们。 另外，B本身可以对外界隐藏。

• 它可以生成更具可读性和可维护性的代码：在顶级类中嵌套小类可以使代码更接近其使用位置。

Answer 6

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

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

它们被视为封闭类的成员，因此您可以指定四个访问说明符中的任何一个 - private、package、protected、public。 我们没有顶级类的这种奢侈，只能将其声明为公共或包私有。

内部类（又名非堆栈类）可以访问顶级类的其他成员，即使它们被声明为私有，而静态嵌套类则无法访问顶级类的其他成员。

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

Inner1 是我们的静态内部类，Inner2 是我们的非静态内部类。 它们之间的主要区别是，您无法在没有 Outer 的情况下创建 Inner2 实例，而您可以独立创建 Inner1 对象。

什么时候会使用内部类？

考虑一下Class A和Class B相关的情况，Class B需要访问Class A成员， B 类 仅与A 类 相关。 内部类就出现了。

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

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

或者

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

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

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

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

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

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

Answer 7

我认为，通常遵循的约定是：

• 顶级类中的静态类是
• 顶级类中的嵌套类非静态类 level 类是一个内部类，它进一步
  还有两种形式：
  • 本地类 - 在块内部声明的命名类，如方法或构造函数体
  • 匿名类 - 其实例在表达式和语句中创建的未命名类

但是，很少有其他要记住的要点是：

• 顶级类和静态嵌套类在语义上是相同的，除了在静态嵌套类的情况下，它可以静态引用其外部[父类的私有静态字段/方法] ] 类，反之亦然。

• 内部类可以访问外部[父]类的封闭实例的实例变量。 但是，并非所有内部类都有封闭实例，例如静态上下文中的内部类（如静态初始化块中使用的匿名类）就没有。

• 匿名类默认扩展父类或实现父接口，并且没有进一步的子句来扩展任何其他类或实现更多接口。 所以，

  • new YourClass(){}; 表示 class [Anonymous] 扩展 YourClass {}
  • new YourInterface(){}; 表示 class [Anonymous] 实现 YourInterface {}

---

我觉得更大的问题仍然悬而未决，该使用哪一个以及何时使用？ 好吧，这主要取决于您正在处理什么情况，但阅读 @jrudolph 给出的回复可能会帮助您做出一些决定。

Answer 8

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

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

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

Answer 9

嵌套类：类内部的类

类型：

1. 静态嵌套类
2. 非静态嵌套类[内部类]

区别：

非静态嵌套类[内部类]

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

outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass(); 

静态嵌套类

在静态嵌套类中，内部类的对象不需要外部类的对象，因为“静态”一词表示不需要创建对象。

class outerclass A {
    static class nestedclass B {
        static int x = 10;
    }
}

如果要访问x，则在方法内部编写以下内容

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

Answer 10

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

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

考虑这个例子：

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”。 那个设定
直到类被实例化之后（或者至少
直到第一次引用嵌套静态项之后），正如您自己所看到的
通过注释和取消注释我上面提到的行。 同样不成立
对于“outerItem”为真。

至少这是我在 Java 6.0 中看到的。

Answer 11

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

public class Outer {
    public class Inner {}

    public static class Nested {}
}

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

Answer 12

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

例如：

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….
  }
}

Answer 13

我认为这里不需要添加太多内容，大多数答案都完美地解释了静态嵌套类和内部类之间的区别。 但是，在使用嵌套类与内部类时请考虑以下问题。
正如几个答案中提到的，内部类不能在没有其封闭类实例的情况下实例化，这意味着它们持有一个指向其封闭类实例的指针，该实例可以导致内存溢出或堆栈溢出异常，因为 GC 将无法对封闭类进行垃圾回收，即使它们不再使用。 为了清楚地说明这一点，请检查以下代码：

public class Outer {


    public  class Inner {

    }


    public Inner inner(){
        return new Inner();
    }

    @Override
    protected void finalize() throws Throwable {
    // as you know finalize is called by the garbage collector due to destroying an object instance
        System.out.println("I am destroyed !");
    }
}


public static void main(String arg[]) {

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

    // out instance is no more used and should be garbage collected !!!
    // However this will not happen as inner instance is still alive i.e used, not null !
    // and outer will be kept in memory until inner is destroyed
    outer = null;

    //
    // inner = null;

    //kick out garbage collector
    System.gc();

}

如果删除 // inside = null; 上的注释，程序将输出 put
“我被摧毁了！”，但保留此评论不会。
原因是白色内部实例仍然被引用，GC 无法收集它，并且因为它引用（具有指向）外部实例，所以它也没有被收集。 如果您的项目中有足够的这些对象，则可能会耗尽内存。
与静态内部类相比，静态内部类不持有指向内部类实例的点，因为它与实例无关，而是与类相关。
如果您将内部类设为静态并使用 Outer.Inner i = new Outer.Inner(); 实例化，上面的程序可以打印“I am destroy！”

Answer 14

我认为上述答案都没有给您提供真实的例子，说明嵌套类和静态嵌套类在应用程序设计方面的区别。 静态嵌套类和内部类的主要区别在于访问外部类实例字段的能力。

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

静态嵌套类：使用静态嵌套类的一个很好的例子是构建器模式（https:// /dzone.com/articles/design-patterns-the-builder-pattern）。

对于BankAccount，我们使用静态嵌套类，主要是因为

1. 静态嵌套类实例可以在外部类之前创建。

2. 在构建器模式中，构建器是一个用于创建 BankAccount 的帮助器类。

3. 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，我们使用内部类，主要是因为：

1. 内部类MyAdapter需要访问外部类成员。

2. 在示例中，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
        }
    }
}

Answer 15

嵌套类是一个非常笼统的术语：每个非顶级的类都是嵌套类。
内部类是非静态嵌套类。
Joseph Darcy 写了一篇关于嵌套类、内部类、成员类和顶级类的非常好的解释。

Answer 16

针对 Java 和/或嵌套类新手的学习者

嵌套类可以是：

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

1.内部类
示例：

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

内部类是嵌套类的子集：

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

内部类的特殊性：

• 内部类的实例可以访问外部类的所有成员，甚至是那些标记为“私有”的

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 中内部类和静态嵌套类的主要区别是什么？
答案：只需查看上述每个类别的具体信息即可。

Answer 17

嗯...内部类是嵌套类...您的意思是匿名类和内部类吗？

编辑：如果您实际上指的是内部与匿名：内部类只是在类中定义的类，例如：

public class A {
    public class B {
    }
}

...而匿名类是匿名定义的类的扩展，因此没有定义实际的“类”，如：

public class A {
}

A anon = new A() { /* You could change behavior of A here */ };

进一步编辑：

维基百科声称Java中存在差异，但我一直在使用使用 Java 八年了，这是我第一次听到这样的区别——更不用说没有任何参考文献来支持这种说法……底线是，内部类是在类（静态或非静态）中定义的类，并且嵌套只是表示同一事物的另一个术语。

静态和非静态嵌套类之间存在微妙的区别......基本上，非静态内部类可以隐式访问封闭类的实例字段和方法（因此它们不能在静态上下文中构造，这将是编译器错误）。 另一方面，静态嵌套类没有对实例字段和方法的隐式访问，并且可以在静态上下文中构造。

Answer 18

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) 它可以访问外部类的静态数据成员，包括私有的。
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 中的嵌套静态类示例

Answer 19

静态嵌套类访问定义它们的类的私有类级静态变量。从体系结构的角度来看，这可能是巨大的（即在服务中使用嵌套静态帮助器类的服务定位器模式），并且可以帮助OP了解它们为什么存在内部类。

Answer 20

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

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

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

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

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

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

为什么我们使用嵌套类

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

来源：Java™ 教程 - 嵌套类

Answer 21

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

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

}

OuterClassTest:

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

    }

}

Answer 22

我认为这里的人们应该注意到海报：静态嵌套类只是第一个内部类。
例如：

 public static class A {} //ERROR

 public class A {
     public class B {
         public static class C {} //ERROR
     }
 }

 public class A {
     public static class B {} //COMPILE !!!

 }

所以，总结一下，静态类不依赖于它包含哪个类。 所以，他们不能正常上课。 （因为普通类需要一个实例）。

Answer 23

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

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

Answer 24

图表

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

Answer 25

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

在下面的示例中，Bank 可以发行一个 Bank.CreditCard，它具有私有构造函数，并且可以使用私有构造函数根据当前银行政策更改信用卡限额。 Bank.CreditCard 的 setLimit(...) 实例方法。 （在这种情况下，对实例变量 limit 的直接字段访问也可以工作）。 从任何其他类中，只能访问 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;
        }
    }
}

Answer 26

首先，不存在称为静态类的类。与内部类（称为嵌套类）一起使用的静态修饰符表示它是外部类的静态成员，这意味着我们可以像其他静态成员一样访问它，而无需任何其他静态成员。外部类的实例。 （这本来就是静态的好处。）

使用嵌套类和常规内部类之间的区别是：

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

首先我们可以实例化外部类，然后我们可以访问内部类。

但如果类是嵌套的，那么语法是：

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

它使用静态语法作为静态关键字的正常实现。

Answer 27

我已经说明了 Java 代码中可能出现的各种可能的正确和错误场景。

    class Outter1 {

        String OutStr;

        Outter1(String str) {
            OutStr = str;
        }

        public void NonStaticMethod(String st)  {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            //  below static attribute not permitted
            // static String tempStatic1 = "static";    

            //  below static with final attribute not permitted         
            // static final String  tempStatic1 = "ashish";  

            // synchronized keyword is not permitted below          
            class localInnerNonStatic1 {            

                synchronized    public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /* 
        //  static method with final not permitted
          public static void innerStaticMethod(String str11) { 

                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }                            

        }

        public static  void StaticMethod(String st)     {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            // static attribute not permitted below
            //static String tempStatic1 = "static";     

            //  static with final attribute not permitted below
            // static final String  tempStatic1 = "ashish";                         

            class localInnerNonStatic1 {
                public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /*
    // static method with final not permitted
    public static void innerStaticMethod(String str11) {  
                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }    

        }

        // synchronized keyword is not permitted
        static  class inner1 {          

            static String  temp1 = "ashish";
            String  tempNonStatic = "ashish";
            // class localInner1 {

            public void innerMethod(String str11) {
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            public static void innerStaticMethod(String str11) {
                //  error in below step
                str11 = temp1 +" india";    
                //str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }
            //}
        }

        //synchronized keyword is not permitted below
        class innerNonStatic1 {             

//This is important we have to keep final with static modifier in non
// static innerclass below
            static final String  temp1 = "ashish";  
            String  tempNonStatic = "ashish";
            // class localInner1 {

            synchronized    public void innerMethod(String str11) {
                tempNonStatic = tempNonStatic +" ...";
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            /*
            //  error in below step
            public static void innerStaticMethod(String str11) {   
                            //  error in below step
                            // str11 = tempNonStatic +" india";                     
                            str11 = temp1 +" india";
                            System.out.println("innerMethod ===> "+str11);
                        }*/
                    //}
                }
    }

Answer 28

不同之处在于，同样是静态的嵌套类声明可以在封闭类之外实例化。

当您有一个非静态的嵌套类声明（也称为内部类）时，Java 不会让您实例化它，除非通过封闭类。 从内部类创建的对象链接到从外部类创建的对象，因此内部类可以引用外部类的字段。

但如果它是静态的，则链接不存在，无法访问外部字段（除非像任何其他对象一样通过普通引用），因此您可以自行实例化嵌套类。